ElementDefinition constructor
- @JsonKey(name: 'id') String? fhirId,
- @JsonKey(name: 'extension') List<
FhirExtension> ? extension_, - List<
FhirExtension> ? modifierExtension, - String? path,
- @JsonKey(name: '_path') Element? pathElement,
- List<
ElementDefinitionRepresentation> ? representation, - @JsonKey(name: '_representation') List<
Element?> ? representationElement, - String? sliceName,
- @JsonKey(name: '_sliceName') Element? sliceNameElement,
- FhirBoolean? sliceIsConstraining,
- @JsonKey(name: '_sliceIsConstraining') Element? sliceIsConstrainingElement,
- String? label,
- @JsonKey(name: '_label') Element? labelElement,
- List<
Coding> ? code, - ElementDefinitionSlicing? slicing,
- String? short,
- @JsonKey(name: '_short') Element? shortElement,
- FhirMarkdown? definition,
- @JsonKey(name: '_definition') Element? definitionElement,
- FhirMarkdown? comment,
- @JsonKey(name: '_comment') Element? commentElement,
- FhirMarkdown? requirements,
- @JsonKey(name: '_requirements') Element? requirementsElement,
- List<
String> ? alias, - @JsonKey(name: '_alias') List<
Element?> ? aliasElement, - FhirUnsignedInt? min,
- @JsonKey(name: '_min') Element? minElement,
- String? max,
- @JsonKey(name: '_max') Element? maxElement,
- ElementDefinitionBase? base,
- FhirUri? contentReference,
- @JsonKey(name: '_contentReference') Element? contentReferenceElement,
- List<
ElementDefinitionType> ? type, - FhirBase64Binary? defaultValueBase64Binary,
- @JsonKey(name: '_defaultValueBase64Binary') Element? defaultValueBase64BinaryElement,
- FhirBoolean? defaultValueBoolean,
- @JsonKey(name: '_defaultValueBoolean') Element? defaultValueBooleanElement,
- FhirCanonical? defaultValueCanonical,
- @JsonKey(name: '_defaultValueCanonical') Element? defaultValueCanonicalElement,
- FhirCode? defaultValueCode,
- @JsonKey(name: '_defaultValueCode') Element? defaultValueCodeElement,
- FhirDate? defaultValueDate,
- @JsonKey(name: '_defaultValueDate') Element? defaultValueDateElement,
- FhirDateTime? defaultValueDateTime,
- @JsonKey(name: '_defaultValueDateTime') Element? defaultValueDateTimeElement,
- FhirDecimal? defaultValueDecimal,
- @JsonKey(name: '_defaultValueDecimal') Element? defaultValueDecimalElement,
- FhirId? defaultValueId,
- @JsonKey(name: '_defaultValueId') Element? defaultValueIdElement,
- FhirInstant? defaultValueInstant,
- @JsonKey(name: '_defaultValueInstant') Element? defaultValueInstantElement,
- FhirInteger? defaultValueInteger,
- @JsonKey(name: '_defaultValueInteger') Element? defaultValueIntegerElement,
- FhirMarkdown? defaultValueMarkdown,
- @JsonKey(name: '_defaultValueMarkdown') Element? defaultValueMarkdownElement,
- FhirOid? defaultValueOid,
- @JsonKey(name: '_defaultValueOid') Element? defaultValueOidElement,
- FhirPositiveInt? defaultValuePositiveInt,
- @JsonKey(name: '_defaultValuePositiveInt') Element? defaultValuePositiveIntElement,
- String? defaultValueString,
- @JsonKey(name: '_defaultValueString') Element? defaultValueStringElement,
- FhirTime? defaultValueTime,
- @JsonKey(name: '_defaultValueTime') Element? defaultValueTimeElement,
- FhirUnsignedInt? defaultValueUnsignedInt,
- @JsonKey(name: '_defaultValueUnsignedInt') Element? defaultValueUnsignedIntElement,
- FhirUri? defaultValueUri,
- @JsonKey(name: '_defaultValueUri') Element? defaultValueUriElement,
- FhirUrl? defaultValueUrl,
- @JsonKey(name: '_defaultValueUrl') Element? defaultValueUrlElement,
- FhirUuid? defaultValueUuid,
- @JsonKey(name: '_defaultValueUuid') Element? defaultValueUuidElement,
- Address? defaultValueAddress,
- Age? defaultValueAge,
- Annotation? defaultValueAnnotation,
- Attachment? defaultValueAttachment,
- CodeableConcept? defaultValueCodeableConcept,
- CodeableReference? defaultValueCodeableReference,
- Coding? defaultValueCoding,
- ContactPoint? defaultValueContactPoint,
- Count? defaultValueCount,
- Distance? defaultValueDistance,
- FhirDuration? defaultValueDuration,
- HumanName? defaultValueHumanName,
- Identifier? defaultValueIdentifier,
- Money? defaultValueMoney,
- Period? defaultValuePeriod,
- Quantity? defaultValueQuantity,
- Range? defaultValueRange,
- Ratio? defaultValueRatio,
- RatioRange? defaultValueRatioRange,
- Reference? defaultValueReference,
- SampledData? defaultValueSampledData,
- Signature? defaultValueSignature,
- Timing? defaultValueTiming,
- ContactDetail? defaultValueContactDetail,
- Contributor? defaultValueContributor,
- DataRequirement? defaultValueDataRequirement,
- FhirExpression? defaultValueExpression,
- ParameterDefinition? defaultValueParameterDefinition,
- RelatedArtifact? defaultValueRelatedArtifact,
- TriggerDefinition? defaultValueTriggerDefinition,
- UsageContext? defaultValueUsageContext,
- Dosage? defaultValueDosage,
- FhirMarkdown? meaningWhenMissing,
- @JsonKey(name: '_meaningWhenMissing') Element? meaningWhenMissingElement,
- String? orderMeaning,
- @JsonKey(name: '_orderMeaning') Element? orderMeaningElement,
- FhirBase64Binary? fixedBase64Binary,
- @JsonKey(name: '_fixedBase64Binary') Element? fixedBase64BinaryElement,
- FhirBoolean? fixedBoolean,
- @JsonKey(name: '_fixedBoolean') Element? fixedBooleanElement,
- FhirCanonical? fixedCanonical,
- @JsonKey(name: '_fixedCanonical') Element? fixedCanonicalElement,
- FhirCode? fixedCode,
- @JsonKey(name: '_fixedCode') Element? fixedCodeElement,
- FhirDate? fixedDate,
- @JsonKey(name: '_fixedDate') Element? fixedDateElement,
- FhirDateTime? fixedDateTime,
- @JsonKey(name: '_fixedDateTime') Element? fixedDateTimeElement,
- FhirDecimal? fixedDecimal,
- @JsonKey(name: '_fixedDecimal') Element? fixedDecimalElement,
- FhirId? fixedId,
- @JsonKey(name: '_fixedId') Element? fixedIdElement,
- FhirInstant? fixedInstant,
- @JsonKey(name: '_fixedInstant') Element? fixedInstantElement,
- FhirInteger? fixedInteger,
- @JsonKey(name: '_fixedInteger') Element? fixedIntegerElement,
- FhirMarkdown? fixedMarkdown,
- @JsonKey(name: '_fixedMarkdown') Element? fixedMarkdownElement,
- FhirOid? fixedOid,
- @JsonKey(name: '_fixedOid') Element? fixedOidElement,
- FhirPositiveInt? fixedPositiveInt,
- @JsonKey(name: '_fixedPositiveInt') Element? fixedPositiveIntElement,
- String? fixedString,
- @JsonKey(name: '_fixedString') Element? fixedStringElement,
- FhirTime? fixedTime,
- @JsonKey(name: '_fixedTime') Element? fixedTimeElement,
- FhirUnsignedInt? fixedUnsignedInt,
- @JsonKey(name: '_fixedUnsignedInt') Element? fixedUnsignedIntElement,
- FhirUri? fixedUri,
- @JsonKey(name: '_fixedUri') Element? fixedUriElement,
- FhirUrl? fixedUrl,
- @JsonKey(name: '_fixedUrl') Element? fixedUrlElement,
- FhirUuid? fixedUuid,
- @JsonKey(name: '_fixedUuid') Element? fixedUuidElement,
- Address? fixedAddress,
- Age? fixedAge,
- Annotation? fixedAnnotation,
- Attachment? fixedAttachment,
- CodeableConcept? fixedCodeableConcept,
- CodeableReference? fixedCodeableReference,
- Coding? fixedCoding,
- ContactPoint? fixedContactPoint,
- Count? fixedCount,
- Distance? fixedDistance,
- FhirDuration? fixedDuration,
- HumanName? fixedHumanName,
- Identifier? fixedIdentifier,
- Money? fixedMoney,
- Period? fixedPeriod,
- Quantity? fixedQuantity,
- Range? fixedRange,
- Ratio? fixedRatio,
- RatioRange? fixedRatioRange,
- Reference? fixedReference,
- SampledData? fixedSampledData,
- Signature? fixedSignature,
- Timing? fixedTiming,
- ContactDetail? fixedContactDetail,
- Contributor? fixedContributor,
- DataRequirement? fixedDataRequirement,
- FhirExpression? fixedExpression,
- ParameterDefinition? fixedParameterDefinition,
- RelatedArtifact? fixedRelatedArtifact,
- TriggerDefinition? fixedTriggerDefinition,
- UsageContext? fixedUsageContext,
- Dosage? fixedDosage,
- FhirBase64Binary? patternBase64Binary,
- @JsonKey(name: '_patternBase64Binary') Element? patternBase64BinaryElement,
- FhirBoolean? patternBoolean,
- @JsonKey(name: '_patternBoolean') Element? patternBooleanElement,
- FhirCanonical? patternCanonical,
- @JsonKey(name: '_patternCanonical') Element? patternCanonicalElement,
- FhirCode? patternCode,
- @JsonKey(name: '_patternCode') Element? patternCodeElement,
- FhirDate? patternDate,
- @JsonKey(name: '_patternDate') Element? patternDateElement,
- FhirDateTime? patternDateTime,
- @JsonKey(name: '_patternDateTime') Element? patternDateTimeElement,
- FhirDecimal? patternDecimal,
- @JsonKey(name: '_patternDecimal') Element? patternDecimalElement,
- FhirId? patternId,
- @JsonKey(name: '_patternId') Element? patternIdElement,
- FhirInstant? patternInstant,
- @JsonKey(name: '_patternInstant') Element? patternInstantElement,
- FhirInteger? patternInteger,
- @JsonKey(name: '_patternInteger') Element? patternIntegerElement,
- FhirMarkdown? patternMarkdown,
- @JsonKey(name: '_patternMarkdown') Element? patternMarkdownElement,
- FhirOid? patternOid,
- @JsonKey(name: '_patternOid') Element? patternOidElement,
- FhirPositiveInt? patternPositiveInt,
- @JsonKey(name: '_patternPositiveInt') Element? patternPositiveIntElement,
- String? patternString,
- @JsonKey(name: '_patternString') Element? patternStringElement,
- FhirTime? patternTime,
- @JsonKey(name: '_patternTime') Element? patternTimeElement,
- FhirUnsignedInt? patternUnsignedInt,
- @JsonKey(name: '_patternUnsignedInt') Element? patternUnsignedIntElement,
- FhirUri? patternUri,
- @JsonKey(name: '_patternUri') Element? patternUriElement,
- FhirUrl? patternUrl,
- @JsonKey(name: '_patternUrl') Element? patternUrlElement,
- FhirUuid? patternUuid,
- @JsonKey(name: '_patternUuid') Element? patternUuidElement,
- Address? patternAddress,
- Age? patternAge,
- Annotation? patternAnnotation,
- Attachment? patternAttachment,
- CodeableConcept? patternCodeableConcept,
- CodeableReference? patternCodeableReference,
- Coding? patternCoding,
- ContactPoint? patternContactPoint,
- Count? patternCount,
- Distance? patternDistance,
- FhirDuration? patternDuration,
- HumanName? patternHumanName,
- Identifier? patternIdentifier,
- Money? patternMoney,
- Period? patternPeriod,
- Quantity? patternQuantity,
- Range? patternRange,
- Ratio? patternRatio,
- RatioRange? patternRatioRange,
- Reference? patternReference,
- SampledData? patternSampledData,
- Signature? patternSignature,
- Timing? patternTiming,
- ContactDetail? patternContactDetail,
- Contributor? patternContributor,
- DataRequirement? patternDataRequirement,
- FhirExpression? patternExpression,
- ParameterDefinition? patternParameterDefinition,
- RelatedArtifact? patternRelatedArtifact,
- TriggerDefinition? patternTriggerDefinition,
- UsageContext? patternUsageContext,
- Dosage? patternDosage,
- List<
ElementDefinitionExample> ? example, - FhirDate? minValueDate,
- @JsonKey(name: '_minValueDate') Element? minValueDateElement,
- FhirDateTime? minValueDateTime,
- @JsonKey(name: '_minValueDateTime') Element? minValueDateTimeElement,
- FhirInstant? minValueInstant,
- @JsonKey(name: '_minValueInstant') Element? minValueInstantElement,
- FhirTime? minValueTime,
- @JsonKey(name: '_minValueTime') Element? minValueTimeElement,
- FhirDecimal? minValueDecimal,
- @JsonKey(name: '_minValueDecimal') Element? minValueDecimalElement,
- FhirInteger? minValueInteger,
- @JsonKey(name: '_minValueInteger') Element? minValueIntegerElement,
- FhirPositiveInt? minValuePositiveInt,
- @JsonKey(name: '_minValuePositiveInt') Element? minValuePositiveIntElement,
- FhirUnsignedInt? minValueUnsignedInt,
- @JsonKey(name: '_minValueUnsignedInt') Element? minValueUnsignedIntElement,
- Quantity? minValueQuantity,
- FhirDate? maxValueDate,
- @JsonKey(name: '_maxValueDate') Element? maxValueDateElement,
- FhirDateTime? maxValueDateTime,
- @JsonKey(name: '_maxValueDateTime') Element? maxValueDateTimeElement,
- FhirInstant? maxValueInstant,
- @JsonKey(name: '_maxValueInstant') Element? maxValueInstantElement,
- FhirTime? maxValueTime,
- @JsonKey(name: '_maxValueTime') Element? maxValueTimeElement,
- FhirDecimal? maxValueDecimal,
- @JsonKey(name: '_maxValueDecimal') Element? maxValueDecimalElement,
- FhirInteger? maxValueInteger,
- @JsonKey(name: '_maxValueInteger') Element? maxValueIntegerElement,
- FhirPositiveInt? maxValuePositiveInt,
- @JsonKey(name: '_maxValuePositiveInt') Element? maxValuePositiveIntElement,
- FhirUnsignedInt? maxValueUnsignedInt,
- @JsonKey(name: '_maxValueUnsignedInt') Element? maxValueUnsignedIntElement,
- Quantity? maxValueQuantity,
- FhirInteger? maxLength,
- @JsonKey(name: '_maxLength') Element? maxLengthElement,
- List<
FhirId> ? condition, - @JsonKey(name: '_condition') List<
Element?> ? conditionElement, - List<
ElementDefinitionConstraint> ? constraint, - FhirBoolean? mustSupport,
- @JsonKey(name: '_mustSupport') Element? mustSupportElement,
- FhirBoolean? isModifier,
- @JsonKey(name: '_isModifier') Element? isModifierElement,
- String? isModifierReason,
- @JsonKey(name: '_isModifierReason') Element? isModifierReasonElement,
- FhirBoolean? isSummary,
- @JsonKey(name: '_isSummary') Element? isSummaryElement,
- ElementDefinitionBinding? binding,
- List<
ElementDefinitionMapping> ? mapping,
ElementDefinition Captures constraints on each element within the resource, profile, or extension.
id Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
extension_
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.
modifierExtension
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).
path
The path identifies the element and is expressed as a
"."-separated list of ancestor elements, beginning with the name of the
resource or extension.
pathElement
Extensions for path
representation
Codes that define how this element is represented in
instances, when the deviation varies from the normal case.
representationElement
Extensions for representation
sliceName
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.
sliceNameElement
Extensions for sliceName
sliceIsConstraining
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.
sliceIsConstrainingElement
Extensions for sliceIsConstraining
label
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.
labelElement
Extensions for label
code
A code that has the same meaning as the element in a particular
terminology.
slicing
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).
short
A concise description of what this element means (e.g. for use in
autogenerated summaries).
shortElement
Extensions for short
definition
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).
definitionElement
Extensions for definition
comment
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).
commentElement
Extensions for comment
requirements
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.
requirementsElement
Extensions for requirements
alias
Identifies additional names by which this element might also be
known.
aliasElement
Extensions for alias
min
The minimum number of times this element SHALL appear in the
instance.
minElement
Extensions for min
max
The maximum number of times this element is permitted to appear in
the instance.
maxElement
Extensions for max
base
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.
contentReference
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.
contentReferenceElement
Extensions for contentReference
type
The data type or resource that the value of this element is
permitted to be.
defaultValueBase64Binary
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').
defaultValueBase64BinaryElement
Extensions for defaultValueBase64Binary
defaultValueBoolean
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').
defaultValueBooleanElement
Extensions for defaultValueBoolean
defaultValueCanonical
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').
defaultValueCanonicalElement
Extensions for defaultValueCanonical
defaultValueCode
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').
defaultValueCodeElement
Extensions for defaultValueCode
defaultValueDate
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').
defaultValueDateElement
Extensions for defaultValueDate
defaultValueDateTime
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').
defaultValueDateTimeElement
Extensions for defaultValueDateTime
defaultValueDecimal
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').
defaultValueDecimalElement
Extensions for defaultValueDecimal
defaultValueId
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').
defaultValueIdElement
Extensions for defaultValueId
defaultValueInstant
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').
defaultValueInstantElement
Extensions for defaultValueInstant
defaultValueInteger
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').
defaultValueIntegerElement
Extensions for defaultValueInteger
defaultValueMarkdown
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').
defaultValueMarkdownElement
Extensions for defaultValueMarkdown
defaultValueOid
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').
defaultValueOidElement
Extensions for defaultValueOid
defaultValuePositiveInt
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').
defaultValuePositiveIntElement
Extensions for defaultValuePositiveInt
defaultValueString
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').
defaultValueStringElement
Extensions for defaultValueString
defaultValueTime
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').
defaultValueTimeElement
Extensions for defaultValueTime
defaultValueUnsignedInt
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').
defaultValueUnsignedIntElement
Extensions for defaultValueUnsignedInt
defaultValueUri
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').
defaultValueUriElement
Extensions for defaultValueUri
defaultValueUrl
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').
defaultValueUrlElement
Extensions for defaultValueUrl
defaultValueUuid
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').
defaultValueUuidElement
Extensions for defaultValueUuid
defaultValueAddress
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueAge
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueAnnotation
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueAttachment
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueCodeableConcept
The value that should be used if there is
no value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueCoding
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueContactPoint
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueCount
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueDistance
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueDuration
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueHumanName
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueIdentifier
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueMoney
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValuePeriod
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueQuantity
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueRange
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueRatio
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueReference
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueSampledData
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueSignature
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueTiming
The value that should be used if there is no value
stated in the instance (e.g. 'if not otherwise specified, the abstract is
false').
defaultValueContactDetail
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueContributor
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueDataRequirement
The value that should be used if there is
no value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueExpression
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueParameterDefinition
The value that should be used if there
is no value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueRelatedArtifact
The value that should be used if there is
no value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueTriggerDefinition
The value that should be used if there is
no value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueUsageContext
The value that should be used if there is no
value stated in the instance (e.g. 'if not otherwise specified, the
abstract is false').
defaultValueDosage
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').
meaningWhenMissing
The Implicit meaning that is to be understood when
this element is missing (e.g. 'when this element is missing, the period is
ongoing').
meaningWhenMissingElement
Extensions for meaningWhenMissing
orderMeaning
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.
orderMeaningElement
Extensions for orderMeaning
fixedBase64Binary
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.
fixedBase64BinaryElement
Extensions for fixedBase64Binary
fixedBoolean
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.
fixedBooleanElement
Extensions for fixedBoolean
fixedCanonical
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.
fixedCanonicalElement
Extensions for fixedCanonical
fixedCode
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.
fixedCodeElement
Extensions for fixedCode
fixedDate
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.
fixedDateElement
Extensions for fixedDate
fixedDateTime
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.
fixedDateTimeElement
Extensions for fixedDateTime
fixedDecimal
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.
fixedDecimalElement
Extensions for fixedDecimal
fixedId
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.
fixedIdElement
Extensions for fixedId
fixedInstant
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.
fixedInstantElement
Extensions for fixedInstant
fixedInteger
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.
fixedIntegerElement
Extensions for fixedInteger
fixedMarkdown
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.
fixedMarkdownElement
Extensions for fixedMarkdown
fixedOid
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.
fixedOidElement
Extensions for fixedOid
fixedPositiveInt
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.
fixedPositiveIntElement
Extensions for fixedPositiveInt
fixedString
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.
fixedStringElement
Extensions for fixedString
fixedTime
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.
fixedTimeElement
Extensions for fixedTime
fixedUnsignedInt
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.
fixedUnsignedIntElement
Extensions for fixedUnsignedInt
fixedUri
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.
fixedUriElement
Extensions for fixedUri
fixedUrl
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.
fixedUrlElement
Extensions for fixedUrl
fixedUuid
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.
fixedUuidElement
Extensions for fixedUuid
fixedAddress
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.
fixedAge
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.
fixedAnnotation
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.
fixedAttachment
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.
fixedCodeableConcept
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.
fixedCoding
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.
fixedContactPoint
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.
fixedCount
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.
fixedDistance
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.
fixedDuration
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.
fixedHumanName
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.
fixedIdentifier
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.
fixedMoney
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.
fixedPeriod
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.
fixedQuantity
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.
fixedRange
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.
fixedRatio
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.
fixedReference
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.
fixedSampledData
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.
fixedSignature
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.
fixedTiming
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.
fixedContactDetail
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.
fixedContributor
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.
fixedDataRequirement
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.
fixedExpression
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.
fixedParameterDefinition
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.
fixedRelatedArtifact
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.
fixedTriggerDefinition
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.
fixedUsageContext
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.
fixedDosage
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.
patternBase64Binary
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternBase64BinaryElement
Extensions for patternBase64Binary
patternBoolean
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternBooleanElement
Extensions for patternBoolean
patternCanonical
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternCanonicalElement
Extensions for patternCanonical
patternCode
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternCodeElement
Extensions for patternCode
patternDate
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternDateElement
Extensions for patternDate
patternDateTime
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternDateTimeElement
Extensions for patternDateTime
patternDecimal
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternDecimalElement
Extensions for patternDecimal
patternId
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 patternx
must match the instance value exactly. When patternx
is used to constrain an array, it means that each element provided in the patternx
array must (recursively) match at least one element from the instance array. When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternIdElement
Extensions for patternId
patternInstant
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternInstantElement
Extensions for patternInstant
patternInteger
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternIntegerElement
Extensions for patternInteger
patternMarkdown
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternMarkdownElement
Extensions for patternMarkdown
patternOid
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternOidElement
Extensions for patternOid
patternPositiveInt
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternPositiveIntElement
Extensions for patternPositiveInt
patternString
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternStringElement
Extensions for patternString
patternTime
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternTimeElement
Extensions for patternTime
patternUnsignedInt
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternUnsignedIntElement
Extensions for patternUnsignedInt
patternUri
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternUriElement
Extensions for patternUri
patternUrl
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternUrlElement
Extensions for patternUrl
patternUuid
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternUuidElement
Extensions for patternUuid
patternAddress
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternAge
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternAnnotation
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternAttachment
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternCodeableConcept
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternCoding
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternContactPoint
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternCount
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternDistance
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternDuration
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternHumanName
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternIdentifier
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternMoney
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternPeriod
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternQuantity
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternRange
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternRatio
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternReference
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternSampledData
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternSignature
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternTiming
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternContactDetail
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternContributor
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternDataRequirement
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternExpression
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternParameterDefinition
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternRelatedArtifact
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternTriggerDefinition
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternUsageContext
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
patternDosage
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 patternx
is used to constrain a primitive, it means that the value
provided in the patternx
must match the instance value exactly.
When patternx
is used to constrain an array, it means that each element
provided in the patternx
array must (recursively) match at least one
element from the instance array.
When patternx
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.,
- If primitive: it must match exactly the pattern value
- If a complex object: it must match (recursively) the pattern value
- If an array: it must match (recursively) the pattern value.
example
A sample value for this element demonstrating the type of
information that would typically be found in the element.
minValueDate
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.
minValueDateElement
Extensions for minValueDate
minValueDateTime
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.
minValueDateTimeElement
Extensions for minValueDateTime
minValueInstant
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.
minValueInstantElement
Extensions for minValueInstant
minValueTime
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.
minValueTimeElement
Extensions for minValueTime
minValueDecimal
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.
minValueDecimalElement
Extensions for minValueDecimal
minValueInteger
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.
minValueIntegerElement
Extensions for minValueInteger
minValuePositiveInt
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.
minValuePositiveIntElement
Extensions for minValuePositiveInt
minValueUnsignedInt
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.
minValueUnsignedIntElement
Extensions for minValueUnsignedInt
minValueQuantity
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.
maxValueDate
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.
maxValueDateElement
Extensions for maxValueDate
maxValueDateTime
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.
maxValueDateTimeElement
Extensions for maxValueDateTime
maxValueInstant
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.
maxValueInstantElement
Extensions for maxValueInstant
maxValueTime
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.
maxValueTimeElement
Extensions for maxValueTime
maxValueDecimal
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.
maxValueDecimalElement
Extensions for maxValueDecimal
maxValueInteger
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.
maxValueIntegerElement
Extensions for maxValueInteger
maxValuePositiveInt
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.
maxValuePositiveIntElement
Extensions for maxValuePositiveInt
maxValueUnsignedInt
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.
maxValueUnsignedIntElement
Extensions for maxValueUnsignedInt
maxValueQuantity
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.
maxLength
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.
maxLengthElement
Extensions for maxLength
condition
A reference to an invariant that may make additional
statements about the cardinality or value in the instance.
conditionElement
Extensions for condition
constraint
Formal constraints such as co-occurrence and other
constraints that can be computationally evaluated within the context of
the instance.
mustSupport
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.
mustSupportElement
Extensions for mustSupport
isModifier
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.
isModifierElement
Extensions for isModifier
isModifierReason
Explains how that element affects the interpretation
of the resource or element that contains it.
isModifierReasonElement
Extensions for isModifierReason
isSummary
Whether the element should be included if a client requests a
search with the parameter _summary=true.
isSummaryElement
Extensions for isSummary
binding
Binds to a value set if this element is coded (code, Coding,
CodeableConcept, Quantity), or the data types (string, uri).
mapping
Identifies a concept from an external specification that
roughly corresponds to this element.
Implementation
const factory ElementDefinition({
/// [id] Unique id for the element within a resource (for internal
/// references). This may be any string value that does not contain spaces.
@JsonKey(name: 'id') String? fhirId,
/// [extension_] 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.
@JsonKey(name: 'extension') List<FhirExtension>? extension_,
/// [modifierExtension] 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).
List<FhirExtension>? modifierExtension,
/// [path] The path identifies the element and is expressed as a
/// "."-separated list of ancestor elements, beginning with the name of the
/// resource or extension.
String? path,
/// [pathElement] Extensions for path
@JsonKey(name: '_path') Element? pathElement,
/// [representation] Codes that define how this element is represented in
/// instances, when the deviation varies from the normal case.
List<ElementDefinitionRepresentation>? representation,
/// [representationElement] Extensions for representation
@JsonKey(name: '_representation') List<Element?>? representationElement,
/// [sliceName] 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.
String? sliceName,
/// [sliceNameElement] Extensions for sliceName
@JsonKey(name: '_sliceName') Element? sliceNameElement,
/// [sliceIsConstraining] 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.
FhirBoolean? sliceIsConstraining,
/// [sliceIsConstrainingElement] Extensions for sliceIsConstraining
@JsonKey(name: '_sliceIsConstraining') Element? sliceIsConstrainingElement,
/// [label] 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.
String? label,
/// [labelElement] Extensions for label
@JsonKey(name: '_label') Element? labelElement,
/// [code] A code that has the same meaning as the element in a particular
/// terminology.
List<Coding>? code,
/// [slicing] 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).
ElementDefinitionSlicing? slicing,
/// [short] A concise description of what this element means (e.g. for use in
/// autogenerated summaries).
String? short,
/// [shortElement] Extensions for short
@JsonKey(name: '_short') Element? shortElement,
/// [definition] 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).
FhirMarkdown? definition,
/// [definitionElement] Extensions for definition
@JsonKey(name: '_definition') Element? definitionElement,
/// [comment] 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).
FhirMarkdown? comment,
/// [commentElement] Extensions for comment
@JsonKey(name: '_comment') Element? commentElement,
/// [requirements] 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.
FhirMarkdown? requirements,
/// [requirementsElement] Extensions for requirements
@JsonKey(name: '_requirements') Element? requirementsElement,
/// [alias] Identifies additional names by which this element might also be
/// known.
List<String>? alias,
/// [aliasElement] Extensions for alias
@JsonKey(name: '_alias') List<Element?>? aliasElement,
/// [min] The minimum number of times this element SHALL appear in the
/// instance.
FhirUnsignedInt? min,
/// [minElement] Extensions for min
@JsonKey(name: '_min') Element? minElement,
/// [max] The maximum number of times this element is permitted to appear in
/// the instance.
String? max,
/// [maxElement] Extensions for max
@JsonKey(name: '_max') Element? maxElement,
/// [base] 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.
ElementDefinitionBase? base,
/// [contentReference] 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.
FhirUri? contentReference,
/// [contentReferenceElement] Extensions for contentReference
@JsonKey(name: '_contentReference') Element? contentReferenceElement,
/// [type] The data type or resource that the value of this element is
/// permitted to be.
List<ElementDefinitionType>? type,
/// [defaultValueBase64Binary] 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').
FhirBase64Binary? defaultValueBase64Binary,
@JsonKey(name: '_defaultValueBase64Binary')
/// [defaultValueBase64BinaryElement] Extensions for defaultValueBase64Binary
Element? defaultValueBase64BinaryElement,
/// [defaultValueBoolean] 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').
FhirBoolean? defaultValueBoolean,
/// [defaultValueBooleanElement] Extensions for defaultValueBoolean
@JsonKey(name: '_defaultValueBoolean') Element? defaultValueBooleanElement,
/// [defaultValueCanonical] 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').
FhirCanonical? defaultValueCanonical,
@JsonKey(name: '_defaultValueCanonical')
/// [defaultValueCanonicalElement] Extensions for defaultValueCanonical
Element? defaultValueCanonicalElement,
/// [defaultValueCode] 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').
FhirCode? defaultValueCode,
/// [defaultValueCodeElement] Extensions for defaultValueCode
@JsonKey(name: '_defaultValueCode') Element? defaultValueCodeElement,
/// [defaultValueDate] 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').
FhirDate? defaultValueDate,
/// [defaultValueDateElement] Extensions for defaultValueDate
@JsonKey(name: '_defaultValueDate') Element? defaultValueDateElement,
/// [defaultValueDateTime] 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').
FhirDateTime? defaultValueDateTime,
@JsonKey(name: '_defaultValueDateTime')
/// [defaultValueDateTimeElement] Extensions for defaultValueDateTime
Element? defaultValueDateTimeElement,
/// [defaultValueDecimal] 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').
FhirDecimal? defaultValueDecimal,
/// [defaultValueDecimalElement] Extensions for defaultValueDecimal
@JsonKey(name: '_defaultValueDecimal') Element? defaultValueDecimalElement,
/// [defaultValueId] 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').
FhirId? defaultValueId,
/// [defaultValueIdElement] Extensions for defaultValueId
@JsonKey(name: '_defaultValueId') Element? defaultValueIdElement,
/// [defaultValueInstant] 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').
FhirInstant? defaultValueInstant,
/// [defaultValueInstantElement] Extensions for defaultValueInstant
@JsonKey(name: '_defaultValueInstant') Element? defaultValueInstantElement,
/// [defaultValueInteger] 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').
FhirInteger? defaultValueInteger,
/// [defaultValueIntegerElement] Extensions for defaultValueInteger
@JsonKey(name: '_defaultValueInteger') Element? defaultValueIntegerElement,
/// [defaultValueMarkdown] 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').
FhirMarkdown? defaultValueMarkdown,
@JsonKey(name: '_defaultValueMarkdown')
/// [defaultValueMarkdownElement] Extensions for defaultValueMarkdown
Element? defaultValueMarkdownElement,
/// [defaultValueOid] 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').
FhirOid? defaultValueOid,
/// [defaultValueOidElement] Extensions for defaultValueOid
@JsonKey(name: '_defaultValueOid') Element? defaultValueOidElement,
/// [defaultValuePositiveInt] 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').
FhirPositiveInt? defaultValuePositiveInt,
@JsonKey(name: '_defaultValuePositiveInt')
/// [defaultValuePositiveIntElement] Extensions for defaultValuePositiveInt
Element? defaultValuePositiveIntElement,
/// [defaultValueString] 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').
String? defaultValueString,
/// [defaultValueStringElement] Extensions for defaultValueString
@JsonKey(name: '_defaultValueString') Element? defaultValueStringElement,
/// [defaultValueTime] 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').
FhirTime? defaultValueTime,
/// [defaultValueTimeElement] Extensions for defaultValueTime
@JsonKey(name: '_defaultValueTime') Element? defaultValueTimeElement,
/// [defaultValueUnsignedInt] 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').
FhirUnsignedInt? defaultValueUnsignedInt,
@JsonKey(name: '_defaultValueUnsignedInt')
/// [defaultValueUnsignedIntElement] Extensions for defaultValueUnsignedInt
Element? defaultValueUnsignedIntElement,
/// [defaultValueUri] 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').
FhirUri? defaultValueUri,
/// [defaultValueUriElement] Extensions for defaultValueUri
@JsonKey(name: '_defaultValueUri') Element? defaultValueUriElement,
/// [defaultValueUrl] 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').
FhirUrl? defaultValueUrl,
/// [defaultValueUrlElement] Extensions for defaultValueUrl
@JsonKey(name: '_defaultValueUrl') Element? defaultValueUrlElement,
/// [defaultValueUuid] 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').
FhirUuid? defaultValueUuid,
/// [defaultValueUuidElement] Extensions for defaultValueUuid
@JsonKey(name: '_defaultValueUuid') Element? defaultValueUuidElement,
/// [defaultValueAddress] 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').
Address? defaultValueAddress,
/// [defaultValueAge] 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').
Age? defaultValueAge,
/// [defaultValueAnnotation] 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').
Annotation? defaultValueAnnotation,
/// [defaultValueAttachment] 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').
Attachment? defaultValueAttachment,
/// [defaultValueCodeableConcept] 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').
CodeableConcept? defaultValueCodeableConcept,
CodeableReference? defaultValueCodeableReference,
/// [defaultValueCoding] 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').
Coding? defaultValueCoding,
/// [defaultValueContactPoint] 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').
ContactPoint? defaultValueContactPoint,
/// [defaultValueCount] 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').
Count? defaultValueCount,
/// [defaultValueDistance] 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').
Distance? defaultValueDistance,
/// [defaultValueDuration] 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').
FhirDuration? defaultValueDuration,
/// [defaultValueHumanName] 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').
HumanName? defaultValueHumanName,
/// [defaultValueIdentifier] 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').
Identifier? defaultValueIdentifier,
/// [defaultValueMoney] 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').
Money? defaultValueMoney,
/// [defaultValuePeriod] 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').
Period? defaultValuePeriod,
/// [defaultValueQuantity] 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').
Quantity? defaultValueQuantity,
/// [defaultValueRange] 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').
Range? defaultValueRange,
/// [defaultValueRatio] 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').
Ratio? defaultValueRatio,
RatioRange? defaultValueRatioRange,
/// [defaultValueReference] 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').
Reference? defaultValueReference,
/// [defaultValueSampledData] 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').
SampledData? defaultValueSampledData,
/// [defaultValueSignature] 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').
Signature? defaultValueSignature,
/// [defaultValueTiming] 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').
Timing? defaultValueTiming,
/// [defaultValueContactDetail] 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').
ContactDetail? defaultValueContactDetail,
/// [defaultValueContributor] 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').
Contributor? defaultValueContributor,
/// [defaultValueDataRequirement] 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').
DataRequirement? defaultValueDataRequirement,
/// [defaultValueExpression] 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').
FhirExpression? defaultValueExpression,
/// [defaultValueParameterDefinition] 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').
ParameterDefinition? defaultValueParameterDefinition,
/// [defaultValueRelatedArtifact] 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').
RelatedArtifact? defaultValueRelatedArtifact,
/// [defaultValueTriggerDefinition] 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').
TriggerDefinition? defaultValueTriggerDefinition,
/// [defaultValueUsageContext] 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').
UsageContext? defaultValueUsageContext,
/// [defaultValueDosage] 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').
Dosage? defaultValueDosage,
/// [meaningWhenMissing] The Implicit meaning that is to be understood when
/// this element is missing (e.g. 'when this element is missing, the period is
/// ongoing').
FhirMarkdown? meaningWhenMissing,
/// [meaningWhenMissingElement] Extensions for meaningWhenMissing
@JsonKey(name: '_meaningWhenMissing') Element? meaningWhenMissingElement,
/// [orderMeaning] 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.
String? orderMeaning,
/// [orderMeaningElement] Extensions for orderMeaning
@JsonKey(name: '_orderMeaning') Element? orderMeaningElement,
/// [fixedBase64Binary] 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.
FhirBase64Binary? fixedBase64Binary,
/// [fixedBase64BinaryElement] Extensions for fixedBase64Binary
@JsonKey(name: '_fixedBase64Binary') Element? fixedBase64BinaryElement,
/// [fixedBoolean] 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.
FhirBoolean? fixedBoolean,
/// [fixedBooleanElement] Extensions for fixedBoolean
@JsonKey(name: '_fixedBoolean') Element? fixedBooleanElement,
/// [fixedCanonical] 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.
FhirCanonical? fixedCanonical,
/// [fixedCanonicalElement] Extensions for fixedCanonical
@JsonKey(name: '_fixedCanonical') Element? fixedCanonicalElement,
/// [fixedCode] 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.
FhirCode? fixedCode,
/// [fixedCodeElement] Extensions for fixedCode
@JsonKey(name: '_fixedCode') Element? fixedCodeElement,
/// [fixedDate] 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.
FhirDate? fixedDate,
/// [fixedDateElement] Extensions for fixedDate
@JsonKey(name: '_fixedDate') Element? fixedDateElement,
/// [fixedDateTime] 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.
FhirDateTime? fixedDateTime,
/// [fixedDateTimeElement] Extensions for fixedDateTime
@JsonKey(name: '_fixedDateTime') Element? fixedDateTimeElement,
/// [fixedDecimal] 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.
FhirDecimal? fixedDecimal,
/// [fixedDecimalElement] Extensions for fixedDecimal
@JsonKey(name: '_fixedDecimal') Element? fixedDecimalElement,
/// [fixedId] 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.
FhirId? fixedId,
/// [fixedIdElement] Extensions for fixedId
@JsonKey(name: '_fixedId') Element? fixedIdElement,
/// [fixedInstant] 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.
FhirInstant? fixedInstant,
/// [fixedInstantElement] Extensions for fixedInstant
@JsonKey(name: '_fixedInstant') Element? fixedInstantElement,
/// [fixedInteger] 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.
FhirInteger? fixedInteger,
/// [fixedIntegerElement] Extensions for fixedInteger
@JsonKey(name: '_fixedInteger') Element? fixedIntegerElement,
/// [fixedMarkdown] 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.
FhirMarkdown? fixedMarkdown,
/// [fixedMarkdownElement] Extensions for fixedMarkdown
@JsonKey(name: '_fixedMarkdown') Element? fixedMarkdownElement,
/// [fixedOid] 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.
FhirOid? fixedOid,
/// [fixedOidElement] Extensions for fixedOid
@JsonKey(name: '_fixedOid') Element? fixedOidElement,
/// [fixedPositiveInt] 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.
FhirPositiveInt? fixedPositiveInt,
/// [fixedPositiveIntElement] Extensions for fixedPositiveInt
@JsonKey(name: '_fixedPositiveInt') Element? fixedPositiveIntElement,
/// [fixedString] 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.
String? fixedString,
/// [fixedStringElement] Extensions for fixedString
@JsonKey(name: '_fixedString') Element? fixedStringElement,
/// [fixedTime] 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.
FhirTime? fixedTime,
/// [fixedTimeElement] Extensions for fixedTime
@JsonKey(name: '_fixedTime') Element? fixedTimeElement,
/// [fixedUnsignedInt] 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.
FhirUnsignedInt? fixedUnsignedInt,
/// [fixedUnsignedIntElement] Extensions for fixedUnsignedInt
@JsonKey(name: '_fixedUnsignedInt') Element? fixedUnsignedIntElement,
/// [fixedUri] 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.
FhirUri? fixedUri,
/// [fixedUriElement] Extensions for fixedUri
@JsonKey(name: '_fixedUri') Element? fixedUriElement,
/// [fixedUrl] 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.
FhirUrl? fixedUrl,
/// [fixedUrlElement] Extensions for fixedUrl
@JsonKey(name: '_fixedUrl') Element? fixedUrlElement,
/// [fixedUuid] 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.
FhirUuid? fixedUuid,
/// [fixedUuidElement] Extensions for fixedUuid
@JsonKey(name: '_fixedUuid') Element? fixedUuidElement,
/// [fixedAddress] 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.
Address? fixedAddress,
/// [fixedAge] 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.
Age? fixedAge,
/// [fixedAnnotation] 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.
Annotation? fixedAnnotation,
/// [fixedAttachment] 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.
Attachment? fixedAttachment,
/// [fixedCodeableConcept] 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.
CodeableConcept? fixedCodeableConcept,
CodeableReference? fixedCodeableReference,
/// [fixedCoding] 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.
Coding? fixedCoding,
/// [fixedContactPoint] 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.
ContactPoint? fixedContactPoint,
/// [fixedCount] 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.
Count? fixedCount,
/// [fixedDistance] 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.
Distance? fixedDistance,
/// [fixedDuration] 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.
FhirDuration? fixedDuration,
/// [fixedHumanName] 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.
HumanName? fixedHumanName,
/// [fixedIdentifier] 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.
Identifier? fixedIdentifier,
/// [fixedMoney] 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.
Money? fixedMoney,
/// [fixedPeriod] 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.
Period? fixedPeriod,
/// [fixedQuantity] 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.
Quantity? fixedQuantity,
/// [fixedRange] 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.
Range? fixedRange,
/// [fixedRatio] 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.
Ratio? fixedRatio,
RatioRange? fixedRatioRange,
/// [fixedReference] 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.
Reference? fixedReference,
/// [fixedSampledData] 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.
SampledData? fixedSampledData,
/// [fixedSignature] 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.
Signature? fixedSignature,
/// [fixedTiming] 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.
Timing? fixedTiming,
/// [fixedContactDetail] 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.
ContactDetail? fixedContactDetail,
/// [fixedContributor] 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.
Contributor? fixedContributor,
/// [fixedDataRequirement] 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.
DataRequirement? fixedDataRequirement,
/// [fixedExpression] 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.
FhirExpression? fixedExpression,
/// [fixedParameterDefinition] 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.
ParameterDefinition? fixedParameterDefinition,
/// [fixedRelatedArtifact] 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.
RelatedArtifact? fixedRelatedArtifact,
/// [fixedTriggerDefinition] 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.
TriggerDefinition? fixedTriggerDefinition,
/// [fixedUsageContext] 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.
UsageContext? fixedUsageContext,
/// [fixedDosage] 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.
Dosage? fixedDosage,
/// [patternBase64Binary] 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.
FhirBase64Binary? patternBase64Binary,
/// [patternBase64BinaryElement] Extensions for patternBase64Binary
@JsonKey(name: '_patternBase64Binary') Element? patternBase64BinaryElement,
/// [patternBoolean] 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.
FhirBoolean? patternBoolean,
/// [patternBooleanElement] Extensions for patternBoolean
@JsonKey(name: '_patternBoolean') Element? patternBooleanElement,
/// [patternCanonical] 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.
FhirCanonical? patternCanonical,
/// [patternCanonicalElement] Extensions for patternCanonical
@JsonKey(name: '_patternCanonical') Element? patternCanonicalElement,
/// [patternCode] 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.
FhirCode? patternCode,
/// [patternCodeElement] Extensions for patternCode
@JsonKey(name: '_patternCode') Element? patternCodeElement,
/// [patternDate] 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.
FhirDate? patternDate,
/// [patternDateElement] Extensions for patternDate
@JsonKey(name: '_patternDate') Element? patternDateElement,
/// [patternDateTime] 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.
FhirDateTime? patternDateTime,
/// [patternDateTimeElement] Extensions for patternDateTime
@JsonKey(name: '_patternDateTime') Element? patternDateTimeElement,
/// [patternDecimal] 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.
FhirDecimal? patternDecimal,
/// [patternDecimalElement] Extensions for patternDecimal
@JsonKey(name: '_patternDecimal') Element? patternDecimalElement,
/// [patternId] 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.
FhirId? patternId,
/// [patternIdElement] Extensions for patternId
@JsonKey(name: '_patternId') Element? patternIdElement,
/// [patternInstant] 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.
FhirInstant? patternInstant,
/// [patternInstantElement] Extensions for patternInstant
@JsonKey(name: '_patternInstant') Element? patternInstantElement,
/// [patternInteger] 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.
FhirInteger? patternInteger,
/// [patternIntegerElement] Extensions for patternInteger
@JsonKey(name: '_patternInteger') Element? patternIntegerElement,
/// [patternMarkdown] 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.
FhirMarkdown? patternMarkdown,
/// [patternMarkdownElement] Extensions for patternMarkdown
@JsonKey(name: '_patternMarkdown') Element? patternMarkdownElement,
/// [patternOid] 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.
FhirOid? patternOid,
/// [patternOidElement] Extensions for patternOid
@JsonKey(name: '_patternOid') Element? patternOidElement,
/// [patternPositiveInt] 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.
FhirPositiveInt? patternPositiveInt,
/// [patternPositiveIntElement] Extensions for patternPositiveInt
@JsonKey(name: '_patternPositiveInt') Element? patternPositiveIntElement,
/// [patternString] 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.
String? patternString,
/// [patternStringElement] Extensions for patternString
@JsonKey(name: '_patternString') Element? patternStringElement,
/// [patternTime] 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.
FhirTime? patternTime,
/// [patternTimeElement] Extensions for patternTime
@JsonKey(name: '_patternTime') Element? patternTimeElement,
/// [patternUnsignedInt] 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.
FhirUnsignedInt? patternUnsignedInt,
/// [patternUnsignedIntElement] Extensions for patternUnsignedInt
@JsonKey(name: '_patternUnsignedInt') Element? patternUnsignedIntElement,
/// [patternUri] 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.
FhirUri? patternUri,
/// [patternUriElement] Extensions for patternUri
@JsonKey(name: '_patternUri') Element? patternUriElement,
/// [patternUrl] 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.
FhirUrl? patternUrl,
/// [patternUrlElement] Extensions for patternUrl
@JsonKey(name: '_patternUrl') Element? patternUrlElement,
/// [patternUuid] 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.
FhirUuid? patternUuid,
/// [patternUuidElement] Extensions for patternUuid
@JsonKey(name: '_patternUuid') Element? patternUuidElement,
/// [patternAddress] 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.
Address? patternAddress,
/// [patternAge] 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.
Age? patternAge,
/// [patternAnnotation] 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.
Annotation? patternAnnotation,
/// [patternAttachment] 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.
Attachment? patternAttachment,
/// [patternCodeableConcept] 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.
CodeableConcept? patternCodeableConcept,
CodeableReference? patternCodeableReference,
/// [patternCoding] 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.
Coding? patternCoding,
/// [patternContactPoint] 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.
ContactPoint? patternContactPoint,
/// [patternCount] 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.
Count? patternCount,
/// [patternDistance] 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.
Distance? patternDistance,
/// [patternDuration] 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.
FhirDuration? patternDuration,
/// [patternHumanName] 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.
HumanName? patternHumanName,
/// [patternIdentifier] 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.
Identifier? patternIdentifier,
/// [patternMoney] 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.
Money? patternMoney,
/// [patternPeriod] 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.
Period? patternPeriod,
/// [patternQuantity] 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.
Quantity? patternQuantity,
/// [patternRange] 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.
Range? patternRange,
/// [patternRatio] 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.
Ratio? patternRatio,
RatioRange? patternRatioRange,
/// [patternReference] 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.
Reference? patternReference,
/// [patternSampledData] 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.
SampledData? patternSampledData,
/// [patternSignature] 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.
Signature? patternSignature,
/// [patternTiming] 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.
Timing? patternTiming,
/// [patternContactDetail] 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.
ContactDetail? patternContactDetail,
/// [patternContributor] 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.
Contributor? patternContributor,
/// [patternDataRequirement] 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.
DataRequirement? patternDataRequirement,
/// [patternExpression] 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.
FhirExpression? patternExpression,
/// [patternParameterDefinition] 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.
ParameterDefinition? patternParameterDefinition,
/// [patternRelatedArtifact] 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.
RelatedArtifact? patternRelatedArtifact,
/// [patternTriggerDefinition] 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.
TriggerDefinition? patternTriggerDefinition,
/// [patternUsageContext] 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.
UsageContext? patternUsageContext,
/// [patternDosage] 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.
Dosage? patternDosage,
/// [example] A sample value for this element demonstrating the type of
/// information that would typically be found in the element.
List<ElementDefinitionExample>? example,
/// [minValueDate] 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.
FhirDate? minValueDate,
/// [minValueDateElement] Extensions for minValueDate
@JsonKey(name: '_minValueDate') Element? minValueDateElement,
/// [minValueDateTime] 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.
FhirDateTime? minValueDateTime,
/// [minValueDateTimeElement] Extensions for minValueDateTime
@JsonKey(name: '_minValueDateTime') Element? minValueDateTimeElement,
/// [minValueInstant] 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.
FhirInstant? minValueInstant,
/// [minValueInstantElement] Extensions for minValueInstant
@JsonKey(name: '_minValueInstant') Element? minValueInstantElement,
/// [minValueTime] 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.
FhirTime? minValueTime,
/// [minValueTimeElement] Extensions for minValueTime
@JsonKey(name: '_minValueTime') Element? minValueTimeElement,
/// [minValueDecimal] 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.
FhirDecimal? minValueDecimal,
/// [minValueDecimalElement] Extensions for minValueDecimal
@JsonKey(name: '_minValueDecimal') Element? minValueDecimalElement,
/// [minValueInteger] 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.
FhirInteger? minValueInteger,
/// [minValueIntegerElement] Extensions for minValueInteger
@JsonKey(name: '_minValueInteger') Element? minValueIntegerElement,
/// [minValuePositiveInt] 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.
FhirPositiveInt? minValuePositiveInt,
/// [minValuePositiveIntElement] Extensions for minValuePositiveInt
@JsonKey(name: '_minValuePositiveInt') Element? minValuePositiveIntElement,
/// [minValueUnsignedInt] 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.
FhirUnsignedInt? minValueUnsignedInt,
/// [minValueUnsignedIntElement] Extensions for minValueUnsignedInt
@JsonKey(name: '_minValueUnsignedInt') Element? minValueUnsignedIntElement,
/// [minValueQuantity] 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.
Quantity? minValueQuantity,
/// [maxValueDate] 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.
FhirDate? maxValueDate,
/// [maxValueDateElement] Extensions for maxValueDate
@JsonKey(name: '_maxValueDate') Element? maxValueDateElement,
/// [maxValueDateTime] 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.
FhirDateTime? maxValueDateTime,
/// [maxValueDateTimeElement] Extensions for maxValueDateTime
@JsonKey(name: '_maxValueDateTime') Element? maxValueDateTimeElement,
/// [maxValueInstant] 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.
FhirInstant? maxValueInstant,
/// [maxValueInstantElement] Extensions for maxValueInstant
@JsonKey(name: '_maxValueInstant') Element? maxValueInstantElement,
/// [maxValueTime] 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.
FhirTime? maxValueTime,
/// [maxValueTimeElement] Extensions for maxValueTime
@JsonKey(name: '_maxValueTime') Element? maxValueTimeElement,
/// [maxValueDecimal] 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.
FhirDecimal? maxValueDecimal,
/// [maxValueDecimalElement] Extensions for maxValueDecimal
@JsonKey(name: '_maxValueDecimal') Element? maxValueDecimalElement,
/// [maxValueInteger] 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.
FhirInteger? maxValueInteger,
/// [maxValueIntegerElement] Extensions for maxValueInteger
@JsonKey(name: '_maxValueInteger') Element? maxValueIntegerElement,
/// [maxValuePositiveInt] 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.
FhirPositiveInt? maxValuePositiveInt,
/// [maxValuePositiveIntElement] Extensions for maxValuePositiveInt
@JsonKey(name: '_maxValuePositiveInt') Element? maxValuePositiveIntElement,
/// [maxValueUnsignedInt] 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.
FhirUnsignedInt? maxValueUnsignedInt,
/// [maxValueUnsignedIntElement] Extensions for maxValueUnsignedInt
@JsonKey(name: '_maxValueUnsignedInt') Element? maxValueUnsignedIntElement,
/// [maxValueQuantity] 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.
Quantity? maxValueQuantity,
/// [maxLength] 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.
FhirInteger? maxLength,
/// [maxLengthElement] Extensions for maxLength
@JsonKey(name: '_maxLength') Element? maxLengthElement,
/// [condition] A reference to an invariant that may make additional
/// statements about the cardinality or value in the instance.
List<FhirId>? condition,
/// [conditionElement] Extensions for condition
@JsonKey(name: '_condition') List<Element?>? conditionElement,
/// [constraint] Formal constraints such as co-occurrence and other
/// constraints that can be computationally evaluated within the context of
/// the instance.
List<ElementDefinitionConstraint>? constraint,
/// [mustSupport] 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.
FhirBoolean? mustSupport,
/// [mustSupportElement] Extensions for mustSupport
@JsonKey(name: '_mustSupport') Element? mustSupportElement,
/// [isModifier] 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.
FhirBoolean? isModifier,
/// [isModifierElement] Extensions for isModifier
@JsonKey(name: '_isModifier') Element? isModifierElement,
/// [isModifierReason] Explains how that element affects the interpretation
/// of the resource or element that contains it.
String? isModifierReason,
/// [isModifierReasonElement] Extensions for isModifierReason
@JsonKey(name: '_isModifierReason') Element? isModifierReasonElement,
/// [isSummary] Whether the element should be included if a client requests a
/// search with the parameter _summary=true.
FhirBoolean? isSummary,
/// [isSummaryElement] Extensions for isSummary
@JsonKey(name: '_isSummary') Element? isSummaryElement,
/// [binding] Binds to a value set if this element is coded (code, Coding,
/// CodeableConcept, Quantity), or the data types (string, uri).
ElementDefinitionBinding? binding,
/// [mapping] Identifies a concept from an external specification that
/// roughly corresponds to this element.
List<ElementDefinitionMapping>? mapping,
}) = _ElementDefinition;