@i4mi/fhir_r4/dist/definition/index.d.ts

FHIR resource definitions + API methods + utils

/**
 * Created by Institute for Medical Informatics (I4MI) - Department of Engineering and Information Technology - Bern University of Applied Science (BFH)
 * File generated on 2022-11-01T13:49:11.646Z
 * https://www.i4mi.ti.bfh.ch
 *
 *  Copyright 2023 Institute for Medical Informatics
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */
/**
 * Primitive Type base64Binary
 * A stream of bytes, base64 encoded
 * A stream of bytes
 */
export type base64Binary = string;
/**
 * Primitive Type canonical
 * see [Canonical References](references.html#canonical)
 * A URI that is a reference to a canonical URL on a FHIR resource
 */
export type canonical = string;
/**
 * Primitive Type code
 * A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
 */
export type code = string;
/**
 * Primitive Type date
 * A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date.  Dates SHALL be valid dates.
 */
export type date = string;
/**
 * Primitive Type dateTime
 * A date, date-time or partial date (e.g. just year or year + month).  If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored.                 Dates SHALL be valid dates.
 */
export type dateTime = string;
/**
 * Primitive Type decimal
 * Do not use an IEEE type floating point type, instead use something that works like a true decimal, with inbuilt precision (e.g. Java BigInteger)
 * A rational number with implicit precision
 */
export type decimal = number;
/**
 * Primitive Type id
 * RFC 4122
 * Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters.  (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.)  Ids are case-insensitive.
 */
export type id = string;
/**
 * Primitive Type instant
 * Note: This is intended for where precisely observed times are required, typically system logs etc., and not human-reported times - for them, see date and dateTime (which can be as precise as instant, but is not required to be) below. Time zone is always required
 * An instant in time - known at least to the second
 */
export type instant = string;
/**
 * Primitive Type integer
 * 32 bit number; for values larger than this, use decimal
 * A whole number
 */
export type integer = number;
/**
 * Primitive Type markdown
 * Systems are not required to have markdown support, so the text should be readable without markdown processing. The markdown syntax is GFM - see https://github.github.com/gfm/
 * A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
 */
export type markdown = string;
/**
 * Primitive Type oid
 * RFC 3001. See also ISO/IEC 8824:1990 €
 * An OID represented as a URI
 */
export type oid = string;
/**
 * Primitive Type positiveInt
 * An integer with a value that is positive (e.g. >0)
 */
export type positiveInt = number;
/**
 * Primitive Type time
 * A time during the day, with no date specified
 */
export type time = string;
/**
 * Primitive Type unsignedInt
 * An integer with a value that is not negative (e.g. >= 0)
 */
export type unsignedInt = number;
/**
 * Primitive Type uri
 * see http://en.wikipedia.org/wiki/Uniform_resource_identifier
 * String of characters used to identify a name or a resource
 */
export type uri = string;
/**
 * Primitive Type url
 * A URI that is a literal reference
 */
export type url = string;
/**
 * Primitive Type uuid
 * See The Open Group, CDE 1.1 Remote Procedure Call specification, Appendix A.
 * A UUID, represented as a URI
 */
export type uuid = string;
/**
 * Primitive Type xhtml
 * XHTML
 */
export type xhtml = string;
/**
 * home | work | temp | old | billing - purpose of this address
 * The purpose of this address.
 * Applications can assume that an address is current unless it explicitly says that it is temporary or old.
 */
export declare enum AddressUse {
    HOME = "home",
    WORK = "work",
    TEMP = "temp",
    OLD = "old",
    BILLING = "billing"
}
/**
 * postal | physical | both
 * Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both.
 * The definition of Address states that "address is intended to describe postal addresses, not physical locations". However, many applications track whether an address has a dual purpose of being a location that can be visited as well as being a valid delivery destination, and Postal addresses are often used as proxies for physical locations (also see the [Location](location.html#) resource).
 */
export declare enum AddressType {
    POSTAL = "postal",
    PHYSICAL = "physical",
    BOTH = "both"
}
/**
 * phone | fax | email | pager | url | sms | other
 * Telecommunications form for contact point - what communications system is required to make use of the contact.
 */
export declare enum ContactPointSystem {
    PHONE = "phone",
    FAX = "fax",
    EMAIL = "email",
    PAGER = "pager",
    URL = "url",
    SMS = "sms",
    OTHER = "other"
}
/**
 * home | work | temp | old | mobile - purpose of this contact point
 * Identifies the purpose for the contact point.
 * Applications can assume that a contact is current unless it explicitly says that it is temporary or old.
 */
export declare enum ContactPointUse {
    HOME = "home",
    WORK = "work",
    TEMP = "temp",
    OLD = "old",
    MOBILE = "mobile"
}
/**
 * author | editor | reviewer | endorser
 * The type of contributor.
 */
export declare enum ContributorType {
    AUTHOR = "author",
    EDITOR = "editor",
    REVIEWER = "reviewer",
    ENDORSER = "endorser"
}
/**
 * ascending | descending
 * The direction of the sort, ascending or descending.
 */
export declare enum DataRequirementSortDirection {
    ASCENDING = "ascending",
    DESCENDING = "descending"
}
/**
 * xmlAttr | xmlText | typeAttr | cdaText | xhtml
 * Codes that define how this element is represented in instances, when the deviation varies from the normal case.
 * In resources, this is rarely used except for special cases where the representation deviates from the normal, and can only be done in the base standard (and profiles must reproduce what the base standard does). This element is used quite commonly in Logical models when the logical models represent a specific serialization format (e.g. CDA, v2 etc.).
 */
export declare enum ElementDefinitionPropertyRepresentation {
    XMLATTR = "xmlAttr",
    XMLTEXT = "xmlText",
    TYPEATTR = "typeAttr",
    CDATEXT = "cdaText",
    XHTML = "xhtml"
}
/**
 * value | exists | pattern | type | profile
 * How the element value is interpreted when discrimination is evaluated.
 */
export declare enum ElementDefinitionDiscriminatorType {
    VALUE = "value",
    EXISTS = "exists",
    PATTERN = "pattern",
    TYPE = "type",
    PROFILE = "profile"
}
/**
 * closed | open | openAtEnd
 * Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.
 * Allowing additional elements makes for a much for flexible template - it's open for use in wider contexts, but also means that the content of the resource is not closed, and applications have to decide how to handle content not described by the profile.
 */
export declare enum ElementDefinitionSlicingRules {
    CLOSED = "closed",
    OPEN = "open",
    OPENATEND = "openAtEnd"
}
/**
 * contained | referenced | bundled - how aggregated
 * If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.
 * See [Aggregation Rules](elementdefinition.html#aggregation) for further clarification.
 */
export declare enum ElementDefinitionAggregationMode {
    CONTAINED = "contained",
    REFERENCED = "referenced",
    BUNDLED = "bundled"
}
/**
 * either | independent | specific
 * Whether this reference needs to be version specific or version independent, or whether either can be used.
 * The base specification never makes a rule as to which form is allowed, but implementation guides may do this. See [Aggregation Rules](elementdefinition.html#aggregation) for further clarification.
 */
export declare enum ElementDefinitionReferenceVersionRules {
    EITHER = "either",
    INDEPENDENT = "independent",
    SPECIFIC = "specific"
}
/**
 * error | warning
 * Identifies the impact constraint violation has on the conformance of the instance.
 * This allows constraints to be asserted as "shall" (error) and "should" (warning).
 */
export declare enum ElementDefinitionConstraintSeverity {
    ERROR = "error",
    WARNING = "warning"
}
/**
 * required | extensible | preferred | example
 * Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.
 * For further discussion, see [Using Terminologies](terminologies.html).
 */
export declare enum ElementDefinitionBindingStrength {
    REQUIRED = "required",
    EXTENSIBLE = "extensible",
    PREFERRED = "preferred",
    EXAMPLE = "example"
}
/**
 * text/cql | text/fhirpath | application/x-fhir-query | etc.
 * The media type of the language for the expression.
 */
export declare enum Expressionundefined {
    TEXT_CQL = "text/cql",
    TEXT_FHIRPATH = "text/fhirpath",
    APPLICATION_X_FHIR_QUERY = "application/x-fhir-query",
    ETC_ = "etc."
}
/**
 * usual | official | temp | nickname | anonymous | old | maiden
 * Identifies the purpose for this name.
 * Applications can assume that a name is current unless it explicitly says that it is temporary or old.
 */
export declare enum HumanNameNameUse {
    USUAL = "usual",
    OFFICIAL = "official",
    TEMP = "temp",
    NICKNAME = "nickname",
    ANONYMOUS = "anonymous",
    OLD = "old",
    MAIDEN = "maiden"
}
/**
 * usual | official | temp | secondary | old (If known)
 * The purpose of this identifier.
 * Applications can assume that an identifier is permanent unless it explicitly says that it is temporary.
 */
export declare enum IdentifierUse {
    USUAL = "usual",
    OFFICIAL = "official",
    TEMP = "temp",
    SECONDARY = "secondary",
    OLD = "old"
}
/**
 * generated | extensions | additional | empty
 * The status of the narrative - whether it's entirely generated (from just the defined data or the extensions too), or whether a human authored it and it may contain additional data.
 */
export declare enum NarrativeStatus {
    GENERATED = "generated",
    EXTENSIONS = "extensions",
    ADDITIONAL = "additional",
    EMPTY = "empty"
}
/**
 * in | out
 * Whether the parameter is input or output for the module.
 */
export declare enum ParameterDefinitionParameterUse {
    IN = "in",
    OUT = "out"
}
/**
 * < | <= | >= | > - how to understand the value
 * How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
 */
export declare enum QuantityComparator {
    LT = "<",
    LE = "<=",
    GE = ">=",
    GT = ">"
}
/**
 * documentation | justification | citation | predecessor | successor | derived-from | depends-on | composed-of
 * The type of relationship to the related artifact.
 */
export declare enum RelatedArtifactType {
    DOCUMENTATION = "documentation",
    JUSTIFICATION = "justification",
    CITATION = "citation",
    PREDECESSOR = "predecessor",
    SUCCESSOR = "successor",
    DERIVED_FROM = "derived-from",
    DEPENDS_ON = "depends-on",
    COMPOSED_OF = "composed-of"
}
/**
 * s | min | h | d | wk | mo | a - unit of time (UCUM)
 * The units of time for the duration, in UCUM units.
 */
export declare enum TimingUnitsOfTime {
    S = "s",
    MIN = "min",
    H = "h",
    D = "d",
    WK = "wk",
    MO = "mo",
    A = "a"
}
/**
 * mon | tue | wed | thu | fri | sat | sun
 * If one or more days of week is provided, then the action happens only on the specified day(s).
 * If no days are specified, the action is assumed to happen every day as otherwise specified. The elements frequency and period cannot be used as well as dayOfWeek.
 */
export declare enum TimingDayOfWeek {
    MON = "mon",
    TUE = "tue",
    WED = "wed",
    THU = "thu",
    FRI = "fri",
    SAT = "sat",
    SUN = "sun"
}
/**
 * named-event | periodic | data-changed | data-added | data-modified | data-removed | data-accessed | data-access-ended
 * The type of triggering event.
 */
export declare enum TriggerDefinitionTriggerType {
    NAMED_EVENT = "named-event",
    PERIODIC = "periodic",
    DATA_CHANGED = "data-changed",
    DATA_ADDED = "data-added",
    DATA_MODIFIED = "data-modified",
    DATA_REMOVED = "data-removed",
    DATA_ACCESSED = "data-accessed",
    DATA_ACCESS_ENDED = "data-access-ended"
}
/**
 * active | inactive | entered-in-error | on-hold | unknown
 * Indicates whether the account is presently used/usable or not.
 * This element is labeled as a modifier because the status contains the codes inactive and entered-in-error that mark the Account as not currently valid.
 */
export declare enum AccountStatus {
    ACTIVE = "active",
    INACTIVE = "inactive",
    ENTERED_IN_ERROR = "entered-in-error",
    ON_HOLD = "on-hold",
    UNKNOWN = "unknown"
}
/**
 * draft | active | retired | unknown
 * The status of this activity definition. Enables tracking the life-cycle of the content.
 * Allows filtering of activity definitions that are appropriate for use versus not.
 */
export declare enum ActivityDefinitionPublicationStatus {
    DRAFT = "draft",
    ACTIVE = "active",
    RETIRED = "retired",
    UNKNOWN = "unknown"
}
/**
 * proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option
 * Indicates the level of authority/intentionality associated with the activity and where the request should fit into the workflow chain.
 */
export declare enum ActivityDefinitionRequestIntent {
    PROPOSAL = "proposal",
    PLAN = "plan",
    DIRECTIVE = "directive",
    ORDER = "order",
    ORIGINAL_ORDER = "original-order",
    REFLEX_ORDER = "reflex-order",
    FILLER_ORDER = "filler-order",
    INSTANCE_ORDER = "instance-order",
    OPTION = "option"
}
/**
 * routine | urgent | asap | stat
 * Indicates how quickly the activity  should be addressed with respect to other requests.
 */
export declare enum ActivityDefinitionRequestPriority {
    ROUTINE = "routine",
    URGENT = "urgent",
    ASAP = "asap",
    STAT = "stat"
}
/**
 * patient | practitioner | related-person | device
 * The type of participant in the action.
 */
export declare enum ActivityDefinitionActivityParticipantType {
    PATIENT = "patient",
    PRACTITIONER = "practitioner",
    RELATED_PERSON = "related-person",
    DEVICE = "device"
}
/**
 * actual | potential
 * Whether the event actually happened, or just had the potential to. Note that this is independent of whether anyone was affected or harmed or how severely.
 */
export declare enum AdverseEventActuality {
    ACTUAL = "actual",
    POTENTIAL = "potential"
}
/**
 * allergy | intolerance - Underlying mechanism (if known)
 * Identification of the underlying physiological mechanism for the reaction risk.
 * Allergic (typically immune-mediated) reactions have been traditionally regarded as an indicator for potential escalation to significant future risk. Contemporary knowledge suggests that some reactions previously thought to be immune-mediated are, in fact, non-immune, but in some cases can still pose a life threatening risk. It is acknowledged that many clinicians might not be in a position to distinguish the mechanism of a particular reaction. Often the term "allergy" is used rather generically and may overlap with the use of "intolerance" - in practice the boundaries between these two concepts might not be well-defined or understood. This data element is included nevertheless, because many legacy systems have captured this attribute. Immunologic testing may provide supporting evidence for the basis of the reaction and the causative substance, but no tests are 100% sensitive or specific for sensitivity to a particular substance. If, as is commonly the case, it is unclear whether the reaction is due to an allergy or an intolerance, then the type element should be omitted from the resource.
 */
export declare enum AllergyIntoleranceType {
    ALLERGY = "allergy",
    INTOLERANCE = "intolerance"
}
/**
 * food | medication | environment | biologic
 * Category of the identified substance.
 * This data element has been included because it is currently being captured in some clinical systems. This data can be derived from the substance where coding systems are used, and is effectively redundant in that situation.  When searching on category, consider the implications of AllergyIntolerance resources without a category.  For example, when searching on category = medication, medication allergies that don't have a category valued will not be returned.  Refer to [search](search.html) for more information on how to search category with a :missing modifier to get allergies that don't have a category.  Additionally, category should be used with caution because category can be subjective based on the sender.
 */
export declare enum AllergyIntoleranceCategory {
    FOOD = "food",
    MEDICATION = "medication",
    ENVIRONMENT = "environment",
    BIOLOGIC = "biologic"
}
/**
 * low | high | unable-to-assess
 * Estimate of the potential clinical harm, or seriousness, of the reaction to the identified substance.
 * The default criticality value for any propensity to an adverse reaction should be 'Low Risk', indicating at the very least a relative contraindication to deliberate or voluntary exposure to the substance. 'High Risk' is flagged if the clinician has identified a propensity for a more serious or potentially life-threatening reaction, such as anaphylaxis, and implies an absolute contraindication to deliberate or voluntary exposure to the substance. If this element is missing, the criticality is unknown (though it may be known elsewhere).  Systems that capture a severity at the condition level are actually representing the concept of criticality whereas the severity documented at the reaction level is representing the true reaction severity.  Existing systems that are capturing both condition criticality and reaction severity may use the term "severity" to represent both.  Criticality is the worst it could be in the future (i.e. situation-agnostic) whereas severity is situation-dependent.
 */
export declare enum AllergyIntoleranceCriticality {
    LOW = "low",
    HIGH = "high",
    UNABLE_TO_ASSESS = "unable-to-assess"
}
/**
 * mild | moderate | severe (of event as a whole)
 * Clinical assessment of the severity of the reaction event as a whole, potentially considering multiple different manifestations.
 * It is acknowledged that this assessment is very subjective. There may be some specific practice domains where objective scales have been applied. Objective scales can be included in this model as extensions.
 */
export declare enum AllergyIntoleranceSeverity {
    MILD = "mild",
    MODERATE = "moderate",
    SEVERE = "severe"
}
/**
 * proposed | pending | booked | arrived | fulfilled | cancelled | noshow | entered-in-error | checked-in | waitlist
 * The overall status of the Appointment. Each of the participants has their own participation status which indicates their involvement in the process, however this status indicates the shared status.
 * If the Appointment's status is "cancelled" then all participants are expected to have their calendars released for the appointment period, and as such any Slots that were marked as BUSY can be re-set to FREE.

This element is labeled as a modifier because the status contains the code entered-in-error that mark the Appointment as not currently valid.
 */
export declare enum AppointmentStatus {
    PROPOSED = "proposed",
    PENDING = "pending",
    BOOKED = "booked",
    ARRIVED = "arrived",
    FULFILLED = "fulfilled",
    CANCELLED = "cancelled",
    NOSHOW = "noshow",
    ENTERED_IN_ERROR = "entered-in-error",
    CHECKED_IN = "checked-in",
    WAITLIST = "waitlist"
}
/**
 * required | optional | information-only
 * Whether this participant is required to be present at the meeting. This covers a use-case where two doctors need to meet to discuss the results for a specific patient, and the patient is not required to be present.
 */
export declare enum AppointmentParticipantRequired {
    REQUIRED = "required",
    OPTIONAL = "optional",
    INFORMATION_ONLY = "information-only"
}
/**
 * accepted | declined | tentative | needs-action
 * Participation status of the actor.
 */
export declare enum AppointmentParticipationStatus {
    ACCEPTED = "accepted",
    DECLINED = "declined",
    TENTATIVE = "tentative",
    NEEDS_ACTION = "needs-action"
}
/**
 * accepted | declined | tentative | needs-action
 * Participation status of the participant. When the status is declined or tentative if the start/end times are different to the appointment, then these times should be interpreted as a requested time change. When the status is accepted, the times can either be the time of the appointment (as a confirmation of the time) or can be empty.
 * This element is labeled as a modifier because the status contains the code entered-in-error that marks the participant as not currently valid.
 */
export declare enum AppointmentResponseParticipantStatus {
    ACCEPTED = "accepted",
    DECLINED = "declined",
    TENTATIVE = "tentative",
    NEEDS_ACTION = "needs-action"
}
/**
 * organ | tissue | fluid | cells | biologicalAgent
 * Broad category of this product.
 */
export declare enum BiologicallyDerivedProductCategory {
    ORGAN = "organ",
    TISSUE = "tissue",
    FLUID = "fluid",
    CELLS = "cells",
    BIOLOGICALAGENT = "biologicalAgent"
}
/**
 * available | unavailable
 * Whether the product is currently available.
 */
export declare enum BiologicallyDerivedProductStatus {
    AVAILABLE = "available",
    UNAVAILABLE = "unavailable"
}
/**
 * farenheit | celsius | kelvin
 * Temperature scale used.
 */
export declare enum BiologicallyDerivedProductStorageScale {
    FARENHEIT = "farenheit",
    CELSIUS = "celsius",
    KELVIN = "kelvin"
}
/**
 * document | message | transaction | transaction-response | batch | batch-response | history | searchset | collection
 * Indicates the purpose of this bundle - how it is intended to be used.
 * It's possible to use a bundle for other purposes (e.g. a document can be accepted as a transaction). This is primarily defined so that there can be specific rules for some of the bundle types.
 */
export declare enum BundleType {
    DOCUMENT = "document",
    MESSAGE = "message",
    TRANSACTION = "transaction",
    TRANSACTION_RESPONSE = "transaction-response",
    BATCH = "batch",
    BATCH_RESPONSE = "batch-response",
    HISTORY = "history",
    SEARCHSET = "searchset",
    COLLECTION = "collection"
}
/**
 * match | include | outcome - why this is in the result set
 * Why this entry is in the result set - whether it's included as a match or because of an _include requirement, or to convey information or warning information about the search process.
 * There is only one mode. In some corner cases, a resource may be included because it is both a match and an include. In these circumstances, 'match' takes precedence.
 */
export declare enum BundleSearchEntryMode {
    MATCH = "match",
    INCLUDE = "include",
    OUTCOME = "outcome"
}
/**
 * GET | HEAD | POST | PUT | DELETE | PATCH
 * In a transaction or batch, this is the HTTP action to be executed for this entry. In a history bundle, this indicates the HTTP action that occurred.
 */
export declare enum BundleHTTPVerb {
    GET = "GET",
    HEAD = "HEAD",
    POST = "POST",
    PUT = "PUT",
    DELETE = "DELETE",
    PATCH = "PATCH"
}
/**
 * draft | active | retired | unknown
 * The status of this capability statement. Enables tracking the life-cycle of the content.
 * Allows filtering of capability statements that are appropriate for use versus not.This is not intended for use with actual capability statements, but where capability statements are used to describe possible or desired systems.
 */
export declare enum CapabilityStatementPublicationStatus {
    DRAFT = "draft",
    ACTIVE = "active",
    RETIRED = "retired",
    UNKNOWN = "unknown"
}
/**
 * instance | capability | requirements
 * The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).
 */
export declare enum CapabilityStatementKind {
    INSTANCE = "instance",
    CAPABILITY = "capability",
    REQUIREMENTS = "requirements"
}
/**
 * client | server
 * Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations.
 */
export declare enum CapabilityStatementRestfulCapabilityMode {
    CLIENT = "client",
    SERVER = "server"
}
/**
 * read | vread | update | patch | delete | history-instance | history-type | create | search-type
 * Coded identifier of the operation, supported by the system resource.
 */
export declare enum CapabilityStatementTypeRestfulInteraction {
    READ = "read",
    VREAD = "vread",
    UPDATE = "update",
    PATCH = "patch",
    DELETE = "delete",
    HISTORY_INSTANCE = "history-instance",
    HISTORY_TYPE = "history-type",
    CREATE = "create",
    SEARCH_TYPE = "search-type"
}
/**
 * no-version | versioned | versioned-update
 * This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.
 * If a server supports versionIds correctly, it SHOULD support vread too, but is not required to do so.
 */
export declare enum CapabilityStatementResourceVersionPolicy {
    NO_VERSION = "no-version",
    VERSIONED = "versioned",
    VERSIONED_UPDATE = "versioned-update"
}
/**
 * not-supported | modified-since | not-match | full-support
 * A code that indicates how the server supports conditional read.
 * Conditional Read is mainly appropriate for interface engine scripts converting from other formats, such as v2.
 */
export declare enum CapabilityStatementConditionalReadStatus {
    NOT_SUPPORTED = "not-supported",
    MODIFIED_SINCE = "modified-since",
    NOT_MATCH = "not-match",
    FULL_SUPPORT = "full-support"
}
/**
 * not-supported | single | multiple - how conditional delete is supported
 * A code that indicates how the server supports conditional delete.
 * Conditional Delete is mainly appropriate for interface engine scripts converting from other formats, such as v2.
 */
export declare enum CapabilityStatementConditionalDeleteStatus {
    NOT_SUPPORTED = "not-supported",
    SINGLE = "single",
    MULTIPLE = "multiple"
}
/**
 * literal | logical | resolves | enforced | local
 * A set of flags that defines how references are supported.
 */
export declare enum CapabilityStatementReferenceHandlingPolicy {
    LITERAL = "literal",
    LOGICAL = "logical",
    RESOLVES = "resolves",
    ENFORCED = "enforced",
    LOCAL = "local"
}
/**
 * number | date | string | token | reference | composite | quantity | uri | special
 * The type of value a search parameter refers to, and how the content is interpreted.
 * While this can be looked up from the definition, it is included here as a convenience for systems that autogenerate a query interface based on the server capability statement.  It SHALL be the same as the type in the search parameter definition.
 */
export declare enum CapabilityStatementSearchParamType {
    NUMBER = "number",
    DATE = "date",
    STRING = "string",
    TOKEN = "token",
    REFERENCE = "reference",
    COMPOSITE = "composite",
    QUANTITY = "quantity",
    URI = "uri",
    SPECIAL = "special"
}
/**
 * transaction | batch | search-system | history-system
 * A coded identifier of the operation, supported by the system.
 */
export declare enum CapabilityStatementSystemRestfulInteraction {
    TRANSACTION = "transaction",
    BATCH = "batch",
    SEARCH_SYSTEM = "search-system",
    HISTORY_SYSTEM = "history-system"
}
/**
 * sender | receiver
 * The mode of this event declaration - whether application is sender or receiver.
 */
export declare enum CapabilityStatementEventCapabilityMode {
    SENDER = "sender",
    RECEIVER = "receiver"
}
/**
 * producer | consumer
 * Mode of this document declaration - whether an application is a producer or consumer.
 */
export declare enum CapabilityStatementDocumentMode {
    PRODUCER = "producer",
    CONSUMER = "consumer"
}
/**
 * draft | active | on-hold | revoked | completed | entered-in-error | unknown
 * Indicates whether the plan is currently being acted upon, represents future intentions or is now a historical record.
 * The unknown code is not to be used to convey other statuses.  The unknown code should be used when one of the statuses applies, but the authoring system doesn't know the current state of the care plan.

This element is labeled as a modifier because the status contains the code entered-in-error that marks the plan as not currently valid.
 */
export declare enum CarePlanStatus {
    DRAFT = "draft",
    ACTIVE = "active",
    ON_HOLD = "on-hold",
    REVOKED = "revoked",
    COMPLETED = "completed",
    ENTERED_IN_ERROR = "entered-in-error",
    UNKNOWN = "unknown"
}
/**
 * proposal | plan | order | option
 * Indicates the level of authority/intentionality associated with the care plan and where the care plan fits into the workflow chain.
 * This element is labeled as a modifier because the intent alters when and how the resource is actually applicable.
 */
export declare enum CarePlanIntent {
    PROPOSAL = "proposal",
    PLAN = "plan",
    ORDER = "order",
    OPTION = "option"
}
/**
 * Appointment | CommunicationRequest | DeviceRequest | MedicationRequest | NutritionOrder | Task | ServiceRequest | VisionPrescription
 * A description of the kind of resource the in-line definition of a care plan activity is representing.  The CarePlan.activity.detail is an in-line definition when a resource is not referenced using CarePlan.activity.reference.  For example, a MedicationRequest, a ServiceRequest, or a CommunicationRequest.
 */
export declare enum CarePlanActivityKind {
    APPOINTMENT = "Appointment",
    COMMUNICATIONREQUEST = "CommunicationRequest",
    DEVICEREQUEST = "DeviceRequest",
    MEDICATIONREQUEST = "MedicationRequest",
    NUTRITIONORDER = "NutritionOrder",
    TASK = "Task",
    SERVICEREQUEST = "ServiceRequest",
    VISIONPRESCRIPTION = "VisionPrescription"
}
/**
 * not-started | scheduled | in-progress | on-hold | completed | cancelled | stopped | unknown | entered-in-error
 * Identifies what progress is being made for the specific activity.
 * Some aspects of status can be inferred based on the resources linked in actionTaken.  Note that "status" is only as current as the plan was most recently updated.
The unknown code is not to be used to convey other statuses.  The unknown code should be used when one of the statuses applies, but the authoring system doesn't know the current state of the activity.
 */
export declare enum CarePlanActivityStatus {
    NOT_STARTED = "not-started",
    SCHEDULED = "scheduled",
    IN_PROGRESS = "in-progress",
    ON_HOLD = "on-hold",
    COMPLETED = "completed",
    CANCELLED = "cancelled",
    STOPPED = "stopped",
    UNKNOWN = "unknown",
    ENTERED_IN_ERROR = "entered-in-error"
}
/**
 * proposed | active | suspended | inactive | entered-in-error
 * Indicates the current state of the care team.
 * This element is labeled as a modifier because the status contains the code entered-in-error that marks the care team as not currently valid.
 */
export declare enum CareTeamStatus {
    PROPOSED = "proposed",
    ACTIVE = "active",
    SUSPENDED = "suspended",
    INACTIVE = "inactive",
    ENTERED_IN_ERROR = "entered-in-error"
}
/**
 * draft | active | retired | unknown
 * Used to support catalog exchange even for unsupported products, e.g. getting list of medications even if not prescribable.
 */
export declare enum CatalogEntryPublicationStatus {
    DRAFT = "draft",
    ACTIVE = "active",
    RETIRED = "retired",
    UNKNOWN = "unknown"
}
/**
 * triggers | is-replaced-by
 * The type of relation to the related item: child, parent, packageContent, containerPackage, usedIn, uses, requires, etc.
 */
export declare enum CatalogEntryRelationType {
    TRIGGERS = "triggers",
    IS_REPLACED_BY = "is-replaced-by"
}
/**
 * planned | billable | not-billable | aborted | billed | entered-in-error | unknown
 * The current state of the ChargeItem.
 * Unknown does not represent "other" - one of the defined statuses must apply.  Unknown is used when the authoring system is not sure what the current status is.

This element is labeled as a modifier because the status contains the code entered-in-error that marks the charge item as not currently valid.
 */
export declare enum ChargeItemStatus {
    PLANNED = "planned",
    BILLABLE = "billable",
    NOT_BILLABLE = "not-billable",
    ABORTED = "aborted",
    BILLED = "billed",
    ENTERED_IN_ERROR = "entered-in-error",
    UNKNOWN = "unknown"
}
/**
 * draft | active | retired | unknown
 * The current state of the ChargeItemDefinition.
 * Allows filtering of charge item definitions that are appropriate for use versus not.
 */
export declare enum ChargeItemDefinitionPublicationStatus {
    DRAFT = "draft",
    ACTIVE = "active",
    RETIRED = "retired",
    UNKNOWN = "unknown"
}
/**
 * base | surcharge | deduction | discount | tax | informational
 * This code identifies the type of the component.
 */
export declare enum ChargeItemDefinitionPriceComponentType {
    BASE = "base",
    SURCHARGE = "surcharge",
    DEDUCTION = "deduction",
    DISCOUNT = "discount",
    TAX = "tax",
    INFORMATIONAL = "informational"
}
/**
 * active | cancelled | draft | entered-in-error
 * The status of the resource instance.
 * This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.
 */
export declare enum ClaimStatus {
    ACTIVE = "active",
    CANCELLED = "cancelled",
    DRAFT = "draft",
    ENTERED_IN_ERROR = "entered-in-error"
}
/**
 * claim | preauthorization | predetermination
 * A code to indicate whether the nature of the request is: to request adjudication of products and services previously rendered; or requesting authorization and adjudication for provision in the future; or requesting the non-binding adjudication of the listed products and services which could be provided in the future.
 */
export declare enum ClaimUse {
    CLAIM = "claim",
    PREAUTHORIZATION = "preauthorization",
    PREDETERMINATION = "predetermination"
}
/**
 * active | cancelled | draft | entered-in-error
 * The status of the resource instance.
 * This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.
 */
export declare enum ClaimResponseStatus {
    ACTIVE = "active",
    CANCELLED = "cancelled",
    DRAFT = "draft",
    ENTERED_IN_ERROR = "entered-in-error"
}
/**
 * claim | preauthorization | predetermination
 * A code to indicate whether the nature of the request is: to request adjudication of products and services previously rendered; or requesting authorization and adjudication for provision in the future; or requesting the non-binding adjudication of the listed products and services which could be provided in the future.
 */
export declare enum ClaimResponseUse {
    CLAIM = "claim",
    PREAUTHORIZATION = "preauthorization",
    PREDETERMINATION = "predetermination"
}
/**
 * queued | complete | error | partial
 * The outcome of the claim, predetermination, or preauthorization processing.
 * The resource may be used to indicate that: the request has been held (queued) for processing; that it has been processed and errors found (error); that no errors were found and that some of the adjudication has been undertaken (partial) or that all of the adjudication has been undertaken (complete).
 */
export declare enum ClaimResponseRemittanceOutcome {
    QUEUED = "queued",
    COMPLETE = "complete",
    ERROR = "error",
    PARTIAL = "partial"
}
/**
 * display | print | printoper
 * The business purpose of the note text.
 */
export declare enum ClaimResponseNoteType {
    DISPLAY = "display",
    PRINT = "print",
    PRINTOPER = "printoper"
}
/**
 * in-progress | completed | entered-in-error
 * Identifies the workflow status of the assessment.
 * This element is labeled as a modifier because the status contains the code entered-in-error that marks the clinical impression as not currently valid.
 */
export declare enum ClinicalImpressionStatus {
    IN_PROGRESS = "in-progress",
    COMPLETED = "completed",
    ENTERED_IN_ERROR = "entered-in-error"
}
/**
 * draft | active | retired | unknown
 * The date (and optionally time) when the code system resource was created or revised.
 * Allows filtering of code systems that are appropriate for use versus not.
 */
export declare enum CodeSystemPublicationStatus {
    DRAFT = "draft",
    ACTIVE = "active",
    RETIRED = "retired",
    UNKNOWN = "unknown"
}
/**
 * grouped-by | is-a | part-of | classified-with
 * The meaning of the hierarchy of concepts as represented in this resource.
 * Note that other representations might have a different hierarchy or none at all, and represent the information using properties.
 */
export declare enum CodeSystemHierarchyMeaning {
    GROUPED_BY = "grouped-by",
    IS_A = "is-a",
    PART_OF = "part-of",
    CLASSIFIED_WITH = "classified-with"
}
/**
 * not-present | example | fragment | complete | supplement
 * The extent of the content of the code system (the concepts and codes it defines) are represented in this resource instance.
 */
export declare enum CodeSystemContentMode {
    NOT_PRESENT = "not-present",
    EXAMPLE = "example",
    FRAGMENT = "fragment",
    COMPLETE = "complete",
    SUPPLEMENT = "supplement"
}
/**
 * = | is-a | descendent-of | is-not-a | regex | in | not-in | generalizes | exists
 * A list of operators that can be used with the filter.
 */
export declare enum CodeSystemFilterOperator {
    E = "=",
    IS_A = "is-a",
    DESCENDENT_OF = "descendent-of",
    IS_NOT_A = "is-not-a",
    REGEX = "regex",
    IN = "in",
    NOT_IN = "not-in",
    GENERALIZES = "generalizes",
    EXISTS = "exists"
}
/**
 * code | Coding | string | integer | boolean | dateTime | decimal
 * The type of the property value. Properties of type "code" contain a code defined by the code system (e.g. a reference to another defined concept).
 */
export declare enum CodeSystemPropertyType {
    CODE = "code",
    CODING = "Coding",
    STRING = "string",
    INTEGER = "integer",
    BOOLEAN = "boolean",
    DATETIME = "dateTime",
    DECIMAL = "decimal"
}
/**
 * preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown
 * The status of the transmission.
 * This element is labeled as a modifier because the status contains the codes aborted and entered-in-error that mark the communication as not currently valid.
 */
export declare enum CommunicationStatus {
    PREPARATION = "preparation",
    IN_PROGRESS = "in-progress",
    NOT_DONE = "not-done",
    ON_HOLD = "on-hold",
    STOPPED = "stopped",
    COMPLETED = "completed",
    ENTERED_IN_ERROR = "entered-in-error",
    UNKNOWN = "unknown"
}
/**
 * routine | urgent | asap | stat
 * Characterizes how quickly the planned or in progress communication must be addressed. Includes concepts such as stat, urgent, routine.
 * Used to prioritize workflow (such as which communication to read first) when the communication is planned or in progress.
 */
export declare enum CommunicationPriority {
    ROUTINE = "routine",
    URGENT = "urgent",
    ASAP = "asap",
    STAT = "stat"
}
/**
 * draft | active | on-hold | revoked | completed | entered-in-error | unknown
 * The status of the proposal or order.
 */
export declare enum CommunicationRequestStatus {
    DRAFT = "draft",
    ACTIVE = "active",
    ON_HOLD = "on-hold",
    REVOKED = "revoked",
    COMPLETED = "completed",
    ENTERED_IN_ERROR = "entered-in-error",
    UNKNOWN = "unknown"
}
/**
 * routine | urgent | asap | stat
 * Characterizes how quickly the proposed act must be initiated. Includes concepts such as stat, urgent, routine.
 */
export declare enum CommunicationRequestCommunicationPriority {
    ROUTINE = "routine",
    URGENT = "urgent",
    ASAP = "asap",
    STAT = "stat"
}
/**
 * draft | active | retired | unknown
 * The status of this compartment definition. Enables tracking the life-cycle of the content.
 * Allows filtering of compartment definitions that are appropriate for use versus not.
 */
export declare enum CompartmentDefinitionPublicationStatus {
    DRAFT = "draft",
    ACTIVE = "active",
    RETIRED = "retired",
    UNKNOWN = "unknown"
}
/**
 * Patient | Encounter | RelatedPerson | Practitioner | Device
 * Which compartment this definition describes.
 * Only the specification can define the compartments that can exist. Servers can choose to support them.
 */
export declare enum CompartmentDefinitionCompartmentType {
    PATIENT = "Patient",
    ENCOUNTER = "Encounter",
    RELATEDPERSON = "RelatedPerson",
    PRACTITIONER = "Practitioner",
    DEVICE = "Device"
}
/**
 * preliminary | final | amended | entered-in-error
 * The workflow/clinical status of this composition. The status is a marker for the clinical standing of the document.
 * If a composition is marked as withdrawn, the compositions/documents in the series, or data from the composition or document series, should never be displayed to a user without being clearly marked as untrustworthy. The flag "entered-in-error" is why this element is labeled as a modifier of other elements.

Some reporting work flows require that the original narrative of a final document never be altered; instead, only new narrative can be added. The composition resource has no explicit status for explicitly noting whether this business rule is in effect. This would be handled by an extension if required.
 */
export declare enum CompositionStatus {
    PRELIMINARY = "preliminary",
    FINAL = "final",
    AMENDED = "amended",
    ENTERED_IN_ERROR = "entered-in-error"
}
/**
 * personal | professional | legal | official
 * The type of attestation the authenticator offers.
 */
export declare enum CompositionAttestationMode {
    PERSONAL = "personal",
    PROFESSIONAL = "professional",
    LEGAL = "legal",
    OFFICIAL = "official"
}
/**
 * replaces | transforms | signs | appends
 * The type of relationship that this composition has with anther composition or document.
 * If this document appends another document, then the document cannot be fully understood without also accessing the referenced document.
 */
export declare enum CompositionDocumentRelationshipType {
    REPLACES = "replaces",
    TRANSFORMS = "transforms",
    SIGNS = "signs",
    APPENDS = "appends"
}
/**
 * working | snapshot | changes
 * How the entry list was prepared - whether it is a working list that is suitable for being maintained on an ongoing basis, or if it represents a snapshot of a list of items from another source, or whether it is a prepared list where items may be marked as added, modified or deleted.
 * This element is labeled as a modifier because a change list must not be misunderstood as a complete list.
 */
export declare enum CompositionSectionMode {
    WORKING = "working",
    SNAPSHOT = "snapshot",
    CHANGES = "changes"
}
/**
 * draft | active | retired | unknown
 * The status of this concept map. Enables tracking the life-cycle of the content.
 * Allows filtering of concept maps that are appropriate for use versus not.
 */
export declare enum ConceptMapPublicationStatus {
    DRAFT = "draft",
    ACTIVE = "active",
    RETIRED = "retired",
    UNKNOWN = "unknown"
}
/**
 * relatedto | equivalent | equal | wider | subsumes | narrower | specializes | inexact | unmatched | disjoint
 * The equivalence between the source and target concepts (counting for the dependencies and products). The equivalence is read from target to source (e.g. the target is 'wider' than the source).
 * This element is labeled as a modifier because it may indicate that a target does not apply.
 */
export declare enum ConceptMapEquivalence {
    RELATEDTO = "relatedto",
    EQUIVALENT = "equivalent",
    EQUAL = "equal",
    WIDER = "wider",
    SUBSUMES = "subsumes",
    NARROWER = "narrower",
    SPECIALIZES = "specializes",
    INEXACT = "inexact",
    UNMATCHED = "unmatched",
    DISJOINT = "disjoint"
}
/**
 * provided | fixed | other-map
 * Defines which action to take if there is no match for the source concept in the target system designated for the group. One of 3 actions are possible: use the unmapped code (this is useful when doing a mapping between versions, and only a few codes have changed), use a fixed code (a default code), or alternatively, a reference to a different concept map can be provided (by canonical URL).
 */
export declare enum ConceptMapGroupUnmappedMode {
    PROVIDED = "provided",
    FIXED = "fixed",
    OTHER_MAP = "other-map"
}
/**
 * draft | proposed | active | rejected | inactive | entered-in-error
 * Indicates the current state of this consent.
 * This element is labeled as a modifier because the status contains the codes rejected and entered-in-error that mark the Consent as not currently valid.
 */
export declare enum ConsentState {
    DRAFT = "draft",
    PROPOSED = "proposed",
    ACTIVE = "active",
    REJECTED = "rejected",
    INACTIVE = "inactive",
    ENTERED_IN_ERROR = "entered-in-error"
}
/**
 * deny | permit
 * Action  to take - permit or deny - when the rule conditions are met.  Not permitted in root rule, required in all nested rules.
 */
export declare enum ConsentProvisionType {
    DENY = "deny",
    PERMIT = "permit"
}
/**
 * instance | related | dependents | authoredby
 * How the resource reference is interpreted when testing consent restrictions.
 */
export declare enum ConsentDataMeaning {
    INSTANCE = "instance",
    RELATED = "related",
    DEPENDENTS = "dependents",
    AUTHOREDBY = "authoredby"
}
/**
 * amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated
 * The status of the resource instance.
 * This element is labeled as a modifier because the status contains codes that mark the contract as not currently valid or active.
 */
export declare enum ContractStatus {
    AMENDED = "amended",
    APPENDED = "appended",
    CANCELLED = "cancelled",
    DISPUTED = "disputed",
    ENTERED_IN_ERROR = "entered-in-error",
    EXECUTABLE = "executable",
    EXECUTED = "executed",
    NEGOTIABLE = "negotiable",
    OFFERED = "offered",
    POLICY = "policy",
    REJECTED = "rejected",
    RENEWED = "renewed",
    REVOKED = "revoked",
    RESOLVED = "resolved",
    TERMINATED = "terminated"
}
/**
 * amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated
 * amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated.
 */
export declare enum ContractPublicationStatus {
    AMENDED = "amended",
    APPENDED = "appended",
    CANCELLED = "cancelled",
    DISPUTED = "disputed",
    ENTERED_IN_ERROR = "entered-in-error",
    EXECUTABLE = "executable",
    EXECUTED = "executed",
    NEGOTIABLE = "negotiable",
    OFFERED = "offered",
    POLICY = "policy",
    REJECTED = "rejected",
    RENEWED = "renewed",
    REVOKED = "revoked",
    RESOLVED = "resolved",
    TERMINATED = "terminated"
}
/**
 * active | cancelled | draft | entered-in-error
 * The status of the resource instance.
 * This element is labeled as a modifier because the status contains the code entered-in-error that marks the coverage as not currently valid.
 */
export declare enum CoverageStatus {
    ACTIVE = "active",
    CANCELLED = "cancelled",
    DRAFT = "draft",
    ENTERED_IN_ERROR = "entered-in-error"
}
/**
 * active | cancelled | draft | entered-in-error
 * The status of the resource instance.
 * This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.
 */
export declare enum CoverageEligibilityRequestEligibilityRequestStatus {
    A