@medplum/fhirtypes

Version:

Medplum FHIR Type Definitions

www.medplum.com

3,080 lines • 117 kB

TypeScript

/*
* This is a generated file
* Do not edit manually.
*/

import { Address } from './Address';
import { Age } from './Age';
import { Annotation } from './Annotation';
import { Attachment } from './Attachment';
import { CodeableConcept } from './CodeableConcept';
import { Coding } from './Coding';
import { ContactDetail } from './ContactDetail';
import { ContactPoint } from './ContactPoint';
import { Contributor } from './Contributor';
import { Count } from './Count';
import { DataRequirement } from './DataRequirement';
import { Distance } from './Distance';
import { Dosage } from './Dosage';
import { Duration } from './Duration';
import { Expression } from './Expression';
import { Extension } from './Extension';
import { HumanName } from './HumanName';
import { Identifier } from './Identifier';
import { Meta } from './Meta';
import { Money } from './Money';
import { ParameterDefinition } from './ParameterDefinition';
import { Period } from './Period';
import { Quantity } from './Quantity';
import { Range } from './Range';
import { Ratio } from './Ratio';
import { Reference } from './Reference';
import { RelatedArtifact } from './RelatedArtifact';
import { SampledData } from './SampledData';
import { Signature } from './Signature';
import { Timing } from './Timing';
import { TriggerDefinition } from './TriggerDefinition';
import { UsageContext } from './UsageContext';

/**
* Captures constraints on each element within the resource, profile, or
* extension.
*/
export interface ElementDefinition {

/**
* Unique id for the element within a resource (for internal references).
* This may be any string value that does not contain spaces.
*/
id?: string;

/**
* May be used to represent additional information that is not part of
* the basic definition of the element. To make the use of extensions
* safe and manageable, there is a strict set of governance applied to
* the definition and use of extensions. Though any implementer can
* define an extension, there is a set of requirements that SHALL be met
* as part of the definition of the extension.
*/
extension?: Extension[];

/**
* May be used to represent additional information that is not part of
* the basic definition of the element and that modifies the
* understanding of the element in which it is contained and/or the
* understanding of the containing element's descendants. Usually
* modifier elements provide negation or qualification. To make the use
* of extensions safe and manageable, there is a strict set of governance
* applied to the definition and use of extensions. Though any
* implementer can define an extension, there is a set of requirements
* that SHALL be met as part of the definition of the extension.
* Applications processing a resource are required to check for modifier
* extensions.
*
* Modifier extensions SHALL NOT change the meaning of any elements on
* Resource or DomainResource (including cannot change the meaning of
* modifierExtension itself).
*/
modifierExtension?: Extension[];

/**
* The path identifies the element and is expressed as a &quot;.&quot;-separated
* list of ancestor elements, beginning with the name of the resource or
* extension.
*/
path: string;

/**
* Codes that define how this element is represented in instances, when
* the deviation varies from the normal case.
*/
representation?: ('xmlAttr' | 'xmlText' | 'typeAttr' | 'cdaText' | 'xhtml')[];

/**
* The name of this element definition slice, when slicing is working.
* The name must be a token with no dots or spaces. This is a unique name
* referring to a specific set of constraints applied to this element,
* used to provide a name to different slices of the same element.
*/
sliceName?: string;

/**
* If true, indicates that this slice definition is constraining a slice
* definition with the same name in an inherited profile. If false, the
* slice is not overriding any slice in an inherited profile. If missing,
* the slice might or might not be overriding a slice in an inherited
* profile, depending on the sliceName.
*/
sliceIsConstraining?: boolean;

/**
* A single preferred label which is the text to display beside the
* element indicating its meaning or to use to prompt for the element in
* a user display or form.
*/
label?: string;

/**
* A code that has the same meaning as the element in a particular
* terminology.
*/
code?: Coding[];

/**
* Indicates that the element is sliced into a set of alternative
* definitions (i.e. in a structure definition, there are multiple
* different constraints on a single element in the base resource).
* Slicing can be used in any resource that has cardinality ..* on the
* base resource, or any resource with a choice of types. The set of
* slices is any elements that come after this in the element sequence
* that have the same path, until a shorter path occurs (the shorter path
* terminates the set).
*/
slicing?: ElementDefinitionSlicing;

/**
* A concise description of what this element means (e.g. for use in
* autogenerated summaries).
*/
short?: string;

/**
* Provides a complete explanation of the meaning of the data element for
* human readability. For the case of elements derived from existing
* elements (e.g. constraints), the definition SHALL be consistent with
* the base definition, but convey the meaning of the element in the
* particular context of use of the resource. (Note: The text you are
* reading is specified in ElementDefinition.definition).
*/
definition?: string;

/**
* Explanatory notes and implementation guidance about the data element,
* including notes about how to use the data properly, exceptions to
* proper use, etc. (Note: The text you are reading is specified in
* ElementDefinition.comment).
*/
comment?: string;

/**
* This element is for traceability of why the element was created and
* why the constraints exist as they do. This may be used to point to
* source materials or specifications that drove the structure of this
* element.
*/
requirements?: string;

/**
* Identifies additional names by which this element might also be known.
*/
alias?: string[];

/**
* The minimum number of times this element SHALL appear in the instance.
*/
min?: number;

/**
* The maximum number of times this element is permitted to appear in the
* instance.
*/
max?: string;

/**
* Information about the base definition of the element, provided to make
* it unnecessary for tools to trace the deviation of the element through
* the derived and related profiles. When the element definition is not
* the original definition of an element - i.g. either in a constraint on
* another type, or for elements from a super type in a snap shot - then
* the information in provided in the element definition may be different
* to the base definition. On the original definition of the element, it
* will be same.
*/
base?: ElementDefinitionBase;

/**
* Identifies an element defined elsewhere in the definition whose
* content rules should be applied to the current element.
* ContentReferences bring across all the rules that are in the
* ElementDefinition for the element, including definitions, cardinality
* constraints, bindings, invariants etc.
*/
contentReference?: string;

/**
* The data type or resource that the value of this element is permitted
* to be.
*/
type?: ElementDefinitionType[];

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueBase64Binary?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueBoolean?: boolean;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueCanonical?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueCode?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueDate?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueDateTime?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueDecimal?: number;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueId?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueInstant?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueInteger?: number;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueMarkdown?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueOid?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValuePositiveInt?: number;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueString?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueTime?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueUnsignedInt?: number;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueUri?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueUrl?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueUuid?: string;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueAddress?: Address;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueAge?: Age;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueAnnotation?: Annotation;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueAttachment?: Attachment;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueCodeableConcept?: CodeableConcept;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueCoding?: Coding;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueContactPoint?: ContactPoint;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueCount?: Count;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueDistance?: Distance;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueDuration?: Duration;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueHumanName?: HumanName;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueIdentifier?: Identifier;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueMoney?: Money;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValuePeriod?: Period;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueQuantity?: Quantity;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueRange?: Range;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueRatio?: Ratio;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueReference?: Reference;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueSampledData?: SampledData;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueSignature?: Signature;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueTiming?: Timing;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueContactDetail?: ContactDetail;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueContributor?: Contributor;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueDataRequirement?: DataRequirement;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueExpression?: Expression;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueParameterDefinition?: ParameterDefinition;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueRelatedArtifact?: RelatedArtifact;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueTriggerDefinition?: TriggerDefinition;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueUsageContext?: UsageContext;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueDosage?: Dosage;

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
defaultValueMeta?: Meta;

/**
* The Implicit meaning that is to be understood when this element is
* missing (e.g. 'when this element is missing, the period is ongoing').
*/
meaningWhenMissing?: string;

/**
* If present, indicates that the order of the repeating element has
* meaning and describes what that meaning is. If absent, it means that
* the order of the element has no meaning.
*/
orderMeaning?: string;

/**
* Specifies a value that the value in the instance SHALL follow - that
* is, any value in the pattern must be found in the instance. Other
* additional values may be found too. This is effectively constraint by
* example.
*
* When pattern[x] is used to constrain a primitive, it means that the
* value provided in the pattern[x] must match the instance value
* exactly.
*
* When pattern[x] is used to constrain an array, it means that each
* element provided in the pattern[x] array must (recursively) match at
* least one element from the instance array.
*
* When pattern[x] is used to constrain a complex object, it means that
* each property in the pattern must be present in the complex object,
* and its value must recursively match -- i.e.,
*
* 1. If primitive: it must match exactly the pattern value
* 2. If a complex object: it must match (recursively) the pattern value
* 3. If an array: it must match (recursively) the pattern value.
*/
patternBase64Binary?: string;

/**
* A sample value for this element demonstrating the type of information
* that would typically be found in the element.
*/
example?: ElementDefinitionExample[];

/**
* The minimum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
minValueDate?: string;

/**
* The minimum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
minValueDateTime?: string;

/**
* The minimum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
minValueInstant?: string;

/**
* The minimum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
minValueTime?: string;

/**
* The minimum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
minValueDecimal?: number;

/**
* The minimum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
minValueInteger?: number;

/**
* The minimum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
minValuePositiveInt?: number;

/**
* The maximum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
maxValueDate?: string;

/**
* The maximum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
maxValueDateTime?: string;

/**
* The maximum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
maxValueInstant?: string;

/**
* The maximum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
maxValueTime?: string;

/**
* The maximum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
maxValueDecimal?: number;

/**
* The maximum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
maxValueInteger?: number;

/**
* The maximum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
maxValuePositiveInt?: number;

/**
* Indicates the maximum length in characters that is permitted to be
* present in conformant instances and which is expected to be supported
* by conformant consumers that support the element.
*/
maxLength?: number;

/**
* A reference to an invariant that may make additional statements about
* the cardinality or value in the instance.
*/
condition?: string[];

/**
* Formal constraints such as co-occurrence and other constraints that
* can be computationally evaluated within the context of the instance.
*/
constraint?: ElementDefinitionConstraint[];

/**
* If true, implementations that produce or consume resources SHALL
* provide &quot;support&quot; for the element in some meaningful way. If false,
* the element may be ignored and not supported. If false, whether to
* populate or use the data element in any way is at the discretion of
* the implementation.
*/
mustSupport?: boolean;

/**
* If true, the value of this element affects the interpretation of the
* element or resource that contains it, and the value of the element
* cannot be ignored. Typically, this is used for status, negation and
* qualification codes. The effect of this is that the element cannot be
* ignored by systems: they SHALL either recognize the element and
* process it, and/or a pre-determination has been made that it is not
* relevant to their particular system.
*/
isModifier?: boolean;

/**
* Explains how that element affects the interpretation of the resource
* or element that contains it.
*/
isModifierReason?: string;

/**
* Whether the element should be included if a client requests a search
* with the parameter _summary=true.
*/
isSummary?: boolean;

/**
* Binds to a value set if this element is coded (code, Coding,
* CodeableConcept, Quantity), or the data types (string, uri).
*/
binding?: ElementDefinitionBinding;

/**
* Identifies a concept from an external specification that roughly
* corresponds to this element.
*/
mapping?: ElementDefinitionMapping[];
}

/**
* The value that should be used if there is no value stated in the
* instance (e.g. 'if not otherwise specified, the abstract is false').
*/
export type ElementDefinitionDefaultValue = Address | Age | Annotation | Attachment | boolean | CodeableConcept | Coding
| ContactDetail | ContactPoint | Contributor | Count | DataRequirement | Distance | Dosage | Duration | Expression |
HumanName | Identifier | Meta | Money | number | ParameterDefinition | Period | Quantity | Range | Ratio | Reference |
RelatedArtifact | SampledData | Signature | string | Timing | TriggerDefinition | UsageContext;

/**
* Specifies a value that SHALL be exactly the value for this element in
* the instance. For purposes of comparison, non-significant whitespace
* is ignored, and all values must be an exact match (case and accent
* sensitive). Missing elements/attributes must also be missing.
*/
export type ElementDefinitionFixed = Address | Age | Annotation | Attachment | boolean | CodeableConcept | Coding |
ContactDetail | ContactPoint | Contributor | Count | DataRequirement | Distance | Dosage | Duration | Expression |
HumanName | Identifier | Meta | Money | number | ParameterDefinition | Period | Quantity | Range | Ratio | Reference |
RelatedArtifact | SampledData | Signature | string | Timing | TriggerDefinition | UsageContext;

/**
* The minimum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
export type ElementDefinitionMinValue = number | Quantity | string;

/**
* The maximum allowed value for the element. The value is inclusive.
* This is allowed for the types date, dateTime, instant, time, decimal,
* integer, and Quantity.
*/
export type ElementDefinitionMaxValue = number | Quantity | string;

/**
* Unique id for the element within a resource (for internal references).
* This may be any string value that does not contain spaces.
*/
id?: string;

/**
* The Path that identifies the base element - this matches the
* ElementDefinition.path for that element. Across FHIR, there is only
* one base definition of any element - that is, an element definition on
* a [StructureDefinition](structuredefinition.html#) without a
* StructureDefinition.base.
*/
path: string;

/**
* Minimum cardinality of the base element identified by the path.
*/
min: number;

/**
* Maximum cardinality of the base element identified by the path.
*/
max: string;
}

/**
* Binds to a value set if this element is coded (code, Coding,
* CodeableConcept, Quantity), or the data types (string, uri).
*/
export interface ElementDefinitionBinding {

/**
* Unique id for the element within a resource (for internal references).
* This may be any string value that does not contain spaces.
*/
id?: string;

/**
* 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.
*/
strength: 'required' | 'extensible' | 'preferred' | 'example';

/**
* Describes the intended use of this particular set of codes.
*/
description?: string;

/**
* Refers to the value set that identifies the set of codes the binding
* refers to.
*/
valueSet?: string;
}

/**
* Formal constraints such as co-occurrence and other constraints that
* can be computationally evaluated within the context of the instance.
*/
export interface ElementDefinitionConstraint {

/**
* Unique id for the element within a resource (for internal references).
* This may be any string value that does not contain spaces.
*/
id?: string;

/**
* Allows identification of which elements have their cardinalities
* impacted by the constraint. Will not be referenced for constraints
* that do not affect cardinality.
*/
key: string;

/**
* Description of why this constraint is necessary or appropriate.
*/
requirements?: string;

/**
* Identifies the impact constraint violation has on the conformance of
* the instance.
*/
severity: 'error' | 'warning';

/**
* Text that can be used to describe the constraint in messages
* identifying that the constraint has been violated.
*/
human: string;

/**
* A [FHIRPath](fhirpath.html) expression of constraint that can be
* executed to see if this constraint is met.
*/
expression?: string;

/**
* An XPath expression of constraint that can be executed to see if this
* constraint is met.
*/
xpath?: string;

/**
* A reference to the original source of the constraint, for traceability
* purposes.
*/
source?: string;
}

/**
* A sample value for this element demonstrating the type of information
* that would typically be found in the element.
*/
export interface ElementDefinitionExample {

/**
* Unique id for the element within a resource (for internal references).
* This may be any string value that does not contain spaces.
*/
id?: string;

/**
* Describes the purpose of this example amoung the set of examples.
*/
label: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueBase64Binary?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueBoolean?: boolean;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueCanonical?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueCode?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueDate?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueDateTime?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueDecimal?: number;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueId?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueInstant?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueInteger?: number;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueMarkdown?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueOid?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valuePositiveInt?: number;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueString?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueTime?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueUnsignedInt?: number;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueUri?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueUrl?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueUuid?: string;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueAddress?: Address;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueAge?: Age;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueAnnotation?: Annotation;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueAttachment?: Attachment;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueCodeableConcept?: CodeableConcept;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueCoding?: Coding;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueContactPoint?: ContactPoint;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueCount?: Count;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueDistance?: Distance;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueDuration?: Duration;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueHumanName?: HumanName;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueIdentifier?: Identifier;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueMoney?: Money;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valuePeriod?: Period;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueQuantity?: Quantity;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueRange?: Range;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueRatio?: Ratio;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueReference?: Reference;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueSampledData?: SampledData;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueSignature?: Signature;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueTiming?: Timing;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueContactDetail?: ContactDetail;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueContributor?: Contributor;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueDataRequirement?: DataRequirement;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueExpression?: Expression;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueParameterDefinition?: ParameterDefinition;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueRelatedArtifact?: RelatedArtifact;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueTriggerDefinition?: TriggerDefinition;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueUsageContext?: UsageContext;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueDosage?: Dosage;

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
valueMeta?: Meta;
}

/**
* The actual value for the element, which must be one of the types
* allowed for this element.
*/
export type ElementDefinitionExampleValue = Address | Age | Annotation | Attachment | boolean | CodeableConcept | Coding
| ContactDetail | ContactPoint | Contributor | Count | DataRequirement | Distance | Dosage | Duration | Expression |
HumanName | Identifier | Meta | Money | number | ParameterDefinition | Period | Quantity | Range | Ratio | Reference |
RelatedArtifact | SampledData | Signature | string | Timing | TriggerDefinition | UsageContext;

/**
* Identifies a concept from an external specification that roughly
* corresponds to this element.
*/
export interface ElementDefinitionMapping {

/**
* Unique id for the element within a resource (for internal references).
* This may be any string value that does not contain spaces.
*/
id?: string;

/**
* An internal reference to the definition of a mapping.
*/
identity: string;

/**
* Identifies the computable language in which mapping.map is expressed.
*/
language?: string;

/**
* Expresses what part of the target specification corresponds to this
* element.
*/
map: string;

/**
* Comments that provide information about the mapping or its use.
*/
comment?: string;
}

/**
* Unique id for the element within a resource (for internal references).
* This may be any string value that does not contain spaces.
*/
id?: string;

/**
* Designates which child elements are used to discriminate between the
* slices when processing an instance. If one or more discriminators are
* provided, the value of the child elements in the instance data SHALL
* completely distinguish which slice the element in the resource matches
* based on the allowed values for those elements in each of the slices.
*/
discriminator?: ElementDefinitionSlicingDiscriminator[];

/**
* A human-readable text description of how the slicing works. If there
* is no discriminator, this is required to be present to provide
* whatever information is possible about how the slices can be
* differentiated.
*/
description?: string;

/**
* If the matching elements have to occur in the same order as defined in
* the profile.
*/
ordered?: boolean;

/**
* 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.
*/
rules: 'closed' | 'open' | 'openAtEnd';
}

/**
* Designates which child elements are used to discriminate between the
* slices when processing an instance. If one or more discriminators are
* provided, the value of the child elements in the instance data SHALL
* completely distinguish which slice the element in the resource matches
* based on the allowed values for those elements in each of the slices.
*/
export interface ElementDefinitionSlicingDiscriminator {

/**
* Unique id for the element within a resource (for internal references).
* This may be any string value that does not contain spaces.
*/
id?: string;

/**
* How the element value is interpreted when discrimination is evaluated.
*/
type: 'value' | 'exists' | 'pattern' | 'type' | 'profile';

/**
* A FHIRPath expression, using [the simple subset of
* FHIRPath](fhirpath.html#simple), that is used to identify the element
* on which discrimination is based.
*/
path: string;
}

/**
* The data type or resource that the value of this element is permitted
* to be.
*/
export interface ElementDefinitionType {

/**
* Unique id for the element within a resource (for internal references).
* This may be any string value that does not contain spaces.
*/
id?: string;

/**
* URL of Data type or Resource that is a(or the) type used for this
* element. References are URLs that are relative to
* http://hl7.org/fhir/StructureDefinition e.g. &quot;string&quot; is a reference
* to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are
* only allowed in logical models.
*/
code: string;

/**
* Identifies a profile structure or implementation Guide that applies to
* the datatype this element refers to. If any profiles are specified,
* then the content must conform to at least one of them. The URL can be
* a local reference - to a contained StructureDefinition, or a reference
* to another StructureDefinition or Implementation Guide by a canonical
* URL. When an implementation guide is specified, the type SHALL conform
* to at least one profile defined in the implementation guide.
*/
profile?: string[];

/**
* Used when the type is &quot;Reference&quot; or &quot;canonical&quot;, and identifies a
* profile structure or implementation Guide that applies to the target
* of the reference this element refers to. If any profiles are
* specified, then the content must conform to at least one of them. The
* URL can be a local reference - to a contained StructureDefinition, or
* a reference to another StructureDefinition or Implementation Guide by
* a canonical URL. When an implementation guide is specified, the target
* resource SHALL conform to at least one profile defined in the
* implementation guide.
*/
targetProfile?: string[];

/**
* 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.
*/
aggregation?: ('contained' | 'referenced' | 'bundled')[];

/**
* Whether this reference needs to be version specific or version
* independent, or whether either can be used.
*/
versioning?: 'either' | 'independent' | 'specific';
}