ElementDefinition

Captures constraints on each element within the resource, profile, or extension. If the element is present, it must have a value for at least one of the defined elements, an @id referenced from the Narrative, or extensions

type ElementDefinition implements Element {
  path: String
  representation: [String]
  sliceName: String
  sliceIsConstraining: Boolean
  label: String
  code: [Coding]
  slicing: ElementDefinitionSlicing
  short: String
  definition: String
  comment: String
  requirements: String
  alias: [String]
  min: Int
  max: String
  base: ElementDefinitionBase
  contentReference: Uri
  type: [ElementDefinitionType]
  defaultValueBase64Binary: String
  defaultValueBoolean: Boolean
  defaultValueCanonical: Uri
  defaultValueCode: String
  defaultValueDate: Date
  defaultValueDateTime: Date
  defaultValueDecimal: String
  defaultValueId: String
  defaultValueInstant: String
  defaultValueInteger: Int
  defaultValueMarkdown: String
  defaultValueOid: String
  defaultValuePositiveInt: Int
  defaultValueString: String
  defaultValueTime: String
  defaultValueUnsignedInt: Int
  defaultValueUri: Uri
  defaultValueUrl: Uri
  defaultValueUuid: String
  defaultValueAddress: Address
  defaultValueAge: Age
  defaultValueAnnotation: Annotation
  defaultValueAttachment: Attachment
  defaultValueCodeableConcept: CodeableConcept
  defaultValueCodeableReference: CodeableReference
  defaultValueCoding: Coding
  defaultValueContactPoint: ContactPoint
  defaultValueCount: Count
  defaultValueDistance: Distance
  defaultValueDuration: Duration
  defaultValueHumanName: HumanName
  defaultValueIdentifier: Identifier
  defaultValueMoney: Money
  defaultValuePeriod: Period
  defaultValueQuantity: Quantity
  defaultValueRange: Range
  defaultValueRatio: Ratio
  defaultValueRatioRange: RatioRange
  defaultValueReference: Reference
  defaultValueSampledData: SampledData
  defaultValueSignature: Signature
  defaultValueTiming: Timing
  defaultValueContactDetail: ContactDetail
  defaultValueContributor: Contributor
  defaultValueDataRequirement: DataRequirement
  defaultValueExpression: Expression
  defaultValueParameterDefinition: ParameterDefinition
  defaultValueRelatedArtifact: RelatedArtifact
  defaultValueTriggerDefinition: TriggerDefinition
  defaultValueUsageContext: UsageContext
  defaultValueDosage: Dosage
  meaningWhenMissing: String
  orderMeaning: String
  fixedBase64Binary: String
  fixedBoolean: Boolean
  fixedCanonical: Uri
  fixedCode: String
  fixedDate: Date
  fixedDateTime: Date
  fixedDecimal: String
  fixedId: String
  fixedInstant: String
  fixedInteger: Int
  fixedMarkdown: String
  fixedOid: String
  fixedPositiveInt: Int
  fixedString: String
  fixedTime: String
  fixedUnsignedInt: Int
  fixedUri: Uri
  fixedUrl: Uri
  fixedUuid: String
  fixedAddress: Address
  fixedAge: Age
  fixedAnnotation: Annotation
  fixedAttachment: Attachment
  fixedCodeableConcept: CodeableConcept
  fixedCodeableReference: CodeableReference
  fixedCoding: Coding
  fixedContactPoint: ContactPoint
  fixedCount: Count
  fixedDistance: Distance
  fixedDuration: Duration
  fixedHumanName: HumanName
  fixedIdentifier: Identifier
  fixedMoney: Money
  fixedPeriod: Period
  fixedQuantity: Quantity
  fixedRange: Range
  fixedRatio: Ratio
  fixedRatioRange: RatioRange
  fixedReference: Reference
  fixedSampledData: SampledData
  fixedSignature: Signature
  fixedTiming: Timing
  fixedContactDetail: ContactDetail
  fixedContributor: Contributor
  fixedDataRequirement: DataRequirement
  fixedExpression: Expression
  fixedParameterDefinition: ParameterDefinition
  fixedRelatedArtifact: RelatedArtifact
  fixedTriggerDefinition: TriggerDefinition
  fixedUsageContext: UsageContext
  fixedDosage: Dosage
  patternBase64Binary: String
  patternBoolean: Boolean
  patternCanonical: Uri
  patternCode: String
  patternDate: Date
  patternDateTime: Date
  patternDecimal: String
  patternId: String
  patternInstant: String
  patternInteger: Int
  patternMarkdown: String
  patternOid: String
  patternPositiveInt: Int
  patternString: String
  patternTime: String
  patternUnsignedInt: Int
  patternUri: Uri
  patternUrl: Uri
  patternUuid: String
  patternAddress: Address
  patternAge: Age
  patternAnnotation: Annotation
  patternAttachment: Attachment
  patternCodeableConcept: CodeableConcept
  patternCodeableReference: CodeableReference
  patternCoding: Coding
  patternContactPoint: ContactPoint
  patternCount: Count
  patternDistance: Distance
  patternDuration: Duration
  patternHumanName: HumanName
  patternIdentifier: Identifier
  patternMoney: Money
  patternPeriod: Period
  patternQuantity: Quantity
  patternRange: Range
  patternRatio: Ratio
  patternRatioRange: RatioRange
  patternReference: Reference
  patternSampledData: SampledData
  patternSignature: Signature
  patternTiming: Timing
  patternContactDetail: ContactDetail
  patternContributor: Contributor
  patternDataRequirement: DataRequirement
  patternExpression: Expression
  patternParameterDefinition: ParameterDefinition
  patternRelatedArtifact: RelatedArtifact
  patternTriggerDefinition: TriggerDefinition
  patternUsageContext: UsageContext
  patternDosage: Dosage
  example: [ElementDefinitionExample]
  minValueDate: Date
  minValueDateTime: Date
  minValueInstant: String
  minValueTime: String
  minValueDecimal: String
  minValueInteger: Int
  minValuePositiveInt: Int
  minValueUnsignedInt: Int
  minValueQuantity: Quantity
  maxValueDate: Date
  maxValueDateTime: Date
  maxValueInstant: String
  maxValueTime: String
  maxValueDecimal: String
  maxValueInteger: Int
  maxValuePositiveInt: Int
  maxValueUnsignedInt: Int
  maxValueQuantity: Quantity
  maxLength: Int
  condition: [String]
  constraint: [ElementDefinitionConstraint]
  mustSupport: Boolean
  isModifier: Boolean
  isModifierReason: String
  isSummary: Boolean
  binding: ElementDefinitionBinding
  mapping: [ElementDefinitionMapping]
  modifierExtension: [Extension]
  extension: [Extension]
  id: String
}

Fields

ElementDefinition.path ● String scalar

The path identifies the element and is expressed as a . -separated list of ancestor elements, beginning with the name of the resource or extension.

ElementDefinition.representation ● [String] list scalar

Codes that define how this element is represented in instances, when the deviation varies from the normal case.

ElementDefinition.sliceName ● String scalar

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.

ElementDefinition.sliceIsConstraining ● Boolean scalar

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.

ElementDefinition.label ● String scalar

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.

ElementDefinition.code ● [Coding] list object

A code that has the same meaning as the element in a particular terminology.

ElementDefinition.slicing ● ElementDefinitionSlicing object

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).

ElementDefinition.short ● String scalar

A concise description of what this element means (e.g. for use in autogenerated summaries).

ElementDefinition.definition ● String scalar

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).

ElementDefinition.comment ● String scalar

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).

ElementDefinition.requirements ● String scalar

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.

ElementDefinition.alias ● [String] list scalar

Identifies additional names by which this element might also be known.

ElementDefinition.min ● Int scalar

The minimum number of times this element SHALL appear in the instance.

ElementDefinition.max ● String scalar

The maximum number of times this element is permitted to appear in the instance.

ElementDefinition.base ● ElementDefinitionBase object

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.

ElementDefinition.contentReference ● Uri scalar

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.

ElementDefinition.type ● [ElementDefinitionType] list object

The data type or resource that the value of this element is permitted to be.

ElementDefinition.defaultValueBase64Binary ● String scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueBoolean ● Boolean scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueCanonical ● Uri scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueCode ● String scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueDate ● Date scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueDateTime ● Date scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueDecimal ● String scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueId ● String scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueInstant ● String scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueInteger ● Int scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueMarkdown ● String scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueOid ● String scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValuePositiveInt ● Int scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueString ● String scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueTime ● String scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueUnsignedInt ● Int scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueUri ● Uri scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueUrl ● Uri scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueUuid ● String scalar

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueAddress ● Address object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueAge ● Age object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueAnnotation ● Annotation object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueAttachment ● Attachment object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueCodeableConcept ● CodeableConcept object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueCodeableReference ● CodeableReference object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueCoding ● Coding object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueContactPoint ● ContactPoint object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueCount ● Count object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueDistance ● Distance object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueDuration ● Duration object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueHumanName ● HumanName object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueIdentifier ● Identifier object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueMoney ● Money object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValuePeriod ● Period object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueQuantity ● Quantity object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueRange ● Range object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueRatio ● Ratio object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueRatioRange ● RatioRange object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueReference ● Reference object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueSampledData ● SampledData object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueSignature ● Signature object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueTiming ● Timing object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueContactDetail ● ContactDetail object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueContributor ● Contributor object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueDataRequirement ● DataRequirement object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueExpression ● Expression object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueParameterDefinition ● ParameterDefinition object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueRelatedArtifact ● RelatedArtifact object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueTriggerDefinition ● TriggerDefinition object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueUsageContext ● UsageContext object

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 ). (choose any one of the elements, but only one)

ElementDefinition.defaultValueDosage ● Dosage object

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 ). (choose any one of the elements, but only one)

ElementDefinition.meaningWhenMissing ● String scalar

The Implicit meaning that is to be understood when this element is missing (e.g. when this element is missing, the period is ongoing ).

ElementDefinition.orderMeaning ● String scalar

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.

ElementDefinition.fixedBase64Binary ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedBoolean ● Boolean scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedCanonical ● Uri scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedCode ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedDate ● Date scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedDateTime ● Date scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedDecimal ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedId ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedInstant ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedInteger ● Int scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedMarkdown ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedOid ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedPositiveInt ● Int scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedString ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedTime ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedUnsignedInt ● Int scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedUri ● Uri scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedUrl ● Uri scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedUuid ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.fixedAddress ● Address object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedAge ● Age object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedAnnotation ● Annotation object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedAttachment ● Attachment object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedCodeableConcept ● CodeableConcept object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedCodeableReference ● CodeableReference object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedCoding ● Coding object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedContactPoint ● ContactPoint object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedCount ● Count object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedDistance ● Distance object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedDuration ● Duration object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedHumanName ● HumanName object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedIdentifier ● Identifier object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedMoney ● Money object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedPeriod ● Period object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedQuantity ● Quantity object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedRange ● Range object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedRatio ● Ratio object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedRatioRange ● RatioRange object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedReference ● Reference object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedSampledData ● SampledData object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedSignature ● Signature object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedTiming ● Timing object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedContactDetail ● ContactDetail object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedContributor ● Contributor object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedDataRequirement ● DataRequirement object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedExpression ● Expression object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedParameterDefinition ● ParameterDefinition object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedRelatedArtifact ● RelatedArtifact object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedTriggerDefinition ● TriggerDefinition object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedUsageContext ● UsageContext object

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. (choose any one of the elements, but only one)

ElementDefinition.fixedDosage ● Dosage object

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. (choose any one of the elements, but only one)

ElementDefinition.patternBase64Binary ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternBoolean ● Boolean scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternCanonical ● Uri scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternCode ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternDate ● Date scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternDateTime ● Date scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternDecimal ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternId ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternInstant ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternInteger ● Int scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternMarkdown ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternOid ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternPositiveInt ● Int scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternString ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternTime ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternUnsignedInt ● Int scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternUri ● Uri scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternUrl ● Uri scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternUuid ● String scalar

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. (choose any one of the elements, but only one)

ElementDefinition.patternAddress ● Address object

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. (choose any one of the elements, but only one)

ElementDefinition.patternAge ● Age object

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. (choose any one of the elements, but only one)

ElementDefinition.patternAnnotation ● Annotation object

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. (choose any one of the elements, but only one)

ElementDefinition.patternAttachment ● Attachment object

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. (choose any one of the elements, but only one)

ElementDefinition.patternCodeableConcept ● CodeableConcept object

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. (choose any one of the elements, but only one)

ElementDefinition.patternCodeableReference ● CodeableReference object

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. (choose any one of the elements, but only one)

ElementDefinition.patternCoding ● Coding object

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. (choose any one of the elements, but only one)

ElementDefinition.patternContactPoint ● ContactPoint object

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. (choose any one of the elements, but only one)

ElementDefinition.patternCount ● Count object

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. (choose any one of the elements, but only one)

ElementDefinition.patternDistance ● Distance object

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. (choose any one of the elements, but only one)

ElementDefinition.patternDuration ● Duration object

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. (choose any one of the elements, but only one)

ElementDefinition.patternHumanName ● HumanName object

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. (choose any one of the elements, but only one)

ElementDefinition.patternIdentifier ● Identifier object

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. (choose any one of the elements, but only one)

ElementDefinition.patternMoney ● Money object

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. (choose any one of the elements, but only one)

ElementDefinition.patternPeriod ● Period object

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. (choose any one of the elements, but only one)

ElementDefinition.patternQuantity ● Quantity object

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. (choose any one of the elements, but only one)

ElementDefinition.patternRange ● Range object

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. (choose any one of the elements, but only one)

ElementDefinition.patternRatio ● Ratio object

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. (choose any one of the elements, but only one)

ElementDefinition.patternRatioRange ● RatioRange object

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. (choose any one of the elements, but only one)

ElementDefinition.patternReference ● Reference object

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. (choose any one of the elements, but only one)

ElementDefinition.patternSampledData ● SampledData object

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. (choose any one of the elements, but only one)

ElementDefinition.patternSignature ● Signature object

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. (choose any one of the elements, but only one)

ElementDefinition.patternTiming ● Timing object

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. (choose any one of the elements, but only one)

ElementDefinition.patternContactDetail ● ContactDetail object

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. (choose any one of the elements, but only one)

ElementDefinition.patternContributor ● Contributor object

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. (choose any one of the elements, but only one)

ElementDefinition.patternDataRequirement ● DataRequirement object

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. (choose any one of the elements, but only one)

ElementDefinition.patternExpression ● Expression object

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. (choose any one of the elements, but only one)

ElementDefinition.patternParameterDefinition ● ParameterDefinition object

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. (choose any one of the elements, but only one)

ElementDefinition.patternRelatedArtifact ● RelatedArtifact object

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. (choose any one of the elements, but only one)

ElementDefinition.patternTriggerDefinition ● TriggerDefinition object

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. (choose any one of the elements, but only one)

ElementDefinition.patternUsageContext ● UsageContext object

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. (choose any one of the elements, but only one)

ElementDefinition.patternDosage ● Dosage object

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. (choose any one of the elements, but only one)

ElementDefinition.example ● [ElementDefinitionExample] list object

A sample value for this element demonstrating the type of information that would typically be found in the element.

ElementDefinition.minValueDate ● Date scalar

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. (choose any one of minValue*, but only one)

ElementDefinition.minValueDateTime ● Date scalar

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. (choose any one of minValue*, but only one)

ElementDefinition.minValueInstant ● String scalar

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. (choose any one of minValue*, but only one)

ElementDefinition.minValueTime ● String scalar

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. (choose any one of minValue*, but only one)

ElementDefinition.minValueDecimal ● String scalar

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. (choose any one of minValue*, but only one)

ElementDefinition.minValueInteger ● Int scalar

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. (choose any one of minValue*, but only one)

ElementDefinition.minValuePositiveInt ● Int scalar

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. (choose any one of minValue*, but only one)

ElementDefinition.minValueUnsignedInt ● Int scalar

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. (choose any one of minValue*, but only one)

ElementDefinition.minValueQuantity ● Quantity object

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. (choose any one of minValue*, but only one)

ElementDefinition.maxValueDate ● Date scalar

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. (choose any one of maxValue*, but only one)

ElementDefinition.maxValueDateTime ● Date scalar

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. (choose any one of maxValue*, but only one)

ElementDefinition.maxValueInstant ● String scalar

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. (choose any one of maxValue*, but only one)

ElementDefinition.maxValueTime ● String scalar

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. (choose any one of maxValue*, but only one)

ElementDefinition.maxValueDecimal ● String scalar

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. (choose any one of maxValue*, but only one)

ElementDefinition.maxValueInteger ● Int scalar

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. (choose any one of maxValue*, but only one)

ElementDefinition.maxValuePositiveInt ● Int scalar

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. (choose any one of maxValue*, but only one)

ElementDefinition.maxValueUnsignedInt ● Int scalar

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. (choose any one of maxValue*, but only one)

ElementDefinition.maxValueQuantity ● Quantity object

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. (choose any one of maxValue*, but only one)

ElementDefinition.maxLength ● Int scalar

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.

ElementDefinition.condition ● [String] list scalar

A reference to an invariant that may make additional statements about the cardinality or value in the instance.

ElementDefinition.constraint ● [ElementDefinitionConstraint] list object

Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance.

ElementDefinition.mustSupport ● Boolean scalar

If true, implementations that produce or consume resources SHALL provide support 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.

ElementDefinition.isModifier ● Boolean scalar

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.

ElementDefinition.isModifierReason ● String scalar

Explains how that element affects the interpretation of the resource or element that contains it.

ElementDefinition.isSummary ● Boolean scalar

Whether the element should be included if a client requests a search with the parameter _summary=true.

ElementDefinition.binding ● ElementDefinitionBinding object

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

ElementDefinition.mapping ● [ElementDefinitionMapping] list object

Identifies a concept from an external specification that roughly corresponds to this element.

ElementDefinition.modifierExtension ● [Extension] list object

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).

ElementDefinition.extension ● [Extension] list object

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.

ElementDefinition.id ● String scalar

Interfaces

Element interface

Base definition for all elements in a resource. If the element is present, it must have a value for at least one of the defined elements, an @id referenced from the Narrative, or extensions

Member Of

StructureDefinitionDifferential object ● StructureDefinitionSnapshot object