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,
- FhirInteger64? defaultValueInteger64,
- @JsonKey(name: '_defaultValueInteger64') Element? defaultValueInteger64Element,
- FhirMarkdown? defaultValueMarkdown,
- @JsonKey(name: '_defaultValueMarkdown') Element? defaultValueMarkdownElement,
- FhirId? 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,
- FhirId? 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,
- DataRequirement? defaultValueDataRequirement,
- FhirExpression? defaultValueExpression,
- ParameterDefinition? defaultValueParameterDefinition,
- RelatedArtifact? defaultValueRelatedArtifact,
- TriggerDefinition? defaultValueTriggerDefinition,
- UsageContext? defaultValueUsageContext,
- Availability? defaultValueAvailability,
- ExtendedContactDetail? defaultValueExtendedContactDetail,
- Dosage? defaultValueDosage,
- FhirMeta? defaultValueMeta,
- 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,
- FhirInteger64? fixedInteger64,
- @JsonKey(name: '_fixedInteger64') Element? fixedInteger64Element,
- FhirMarkdown? fixedMarkdown,
- @JsonKey(name: '_fixedMarkdown') Element? fixedMarkdownElement,
- FhirId? 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,
- FhirId? 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,
- DataRequirement? fixedDataRequirement,
- FhirExpression? fixedExpression,
- ParameterDefinition? fixedParameterDefinition,
- RelatedArtifact? fixedRelatedArtifact,
- TriggerDefinition? fixedTriggerDefinition,
- UsageContext? fixedUsageContext,
- Availability? fixedAvailability,
- ExtendedContactDetail? fixedExtendedContactDetail,
- Dosage? fixedDosage,
- FhirMeta? fixedMeta,
- 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,
- FhirInteger64? patternInteger64,
- @JsonKey(name: '_patternInteger64') Element? patternInteger64Element,
- FhirMarkdown? patternMarkdown,
- @JsonKey(name: '_patternMarkdown') Element? patternMarkdownElement,
- FhirId? 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,
- FhirId? 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,
- DataRequirement? patternDataRequirement,
- FhirExpression? patternExpression,
- ParameterDefinition? patternParameterDefinition,
- RelatedArtifact? patternRelatedArtifact,
- TriggerDefinition? patternTriggerDefinition,
- UsageContext? patternUsageContext,
- Availability? patternAvailability,
- ExtendedContactDetail? patternExtendedContactDetail,
- Dosage? patternDosage,
- FhirMeta? patternMeta,
- 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,
- FhirInteger64? minValueInteger64,
- @JsonKey(name: '_minValueInteger64') Element? minValueInteger64Element,
- 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,
- FhirInteger64? maxValueInteger64,
- @JsonKey(name: '_maxValueInteger64') Element? maxValueInteger64Element,
- 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? mustHaveValue,
- @JsonKey(name: '_mustHaveValue') Element? mustHaveValueElement,
- List<
FhirCanonical> ? valueAlternatives, - 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_
("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 managable, 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 managable, 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
("_path") Extensions for path
representation
Codes that define how this element is represented in
instances, when the deviation varies from the normal case. No extensions
are allowed on elements with a representation of 'xmlAttr', no matter
what FHIR serialization format is used.
representationElement
("_representation") 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
("_sliceName") 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
("_sliceIsConstraining") 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
("_label") 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
("_short") 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
("_definition") 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
("_comment") 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
("_requirements") Extensions for requirements
alias
Identifies additional names by which this element might also be
known.
aliasElement
("_alias") Extensions for alias
min
The minimum number of times this element SHALL appear in the
instance.
minElement
("_min") Extensions for min
max
The maximum number of times this element is permitted to appear in
the instance.
maxElement
("_max") 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 - e.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
("_contentReference") 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
("_defaultValueBase64Binary")
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
("_defaultValueBoolean") 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
("_defaultValueCanonical") 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
("_defaultValueCode") 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
("_defaultValueDate") 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
("_defaultValueDateTime") 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
("_defaultValueDecimal") 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
("_defaultValueId") 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
("_defaultValueInstant") 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
("_defaultValueInteger") Extensions for
defaultValueInteger
defaultValueInteger64
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').
defaultValueInteger64Element
("_defaultValueInteger64") Extensions for
defaultValueInteger64
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
("_defaultValueMarkdown") 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
("_defaultValueOid") 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
("_defaultValuePositiveInt") 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
("_defaultValueString") 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
("_defaultValueTime") 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
("_defaultValueUnsignedInt") 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
("_defaultValueUri") 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
("_defaultValueUrl") 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
("_defaultValueUuid") 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').
defaultValueCodeableReference
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').
defaultValueRatioRange
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').
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').
defaultValueAvailability
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').
defaultValueExtendedContactDetail
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').
defaultValueMeta
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
("_meaningWhenMissing") 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
("_orderMeaning") Extensions for orderMeaning
fixedBase64Binary
Specifies a value that SHALL be exactly the value
for this element in the instance, if present. 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
("_fixedBase64Binary") Extensions for
fixedBase64Binary
fixedBoolean
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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
("_fixedBoolean") Extensions for fixedBoolean
fixedCanonical
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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
("_fixedCanonical") Extensions for fixedCanonical
fixedCode
Specifies a value that SHALL be exactly the value for this
element in the instance, if present. 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
("_fixedCode") Extensions for fixedCode
fixedDate
Specifies a value that SHALL be exactly the value for this
element in the instance, if present. 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
("_fixedDate") Extensions for fixedDate
fixedDateTime
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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
("_fixedDateTime") Extensions for fixedDateTime
fixedDecimal
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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
("_fixedDecimal") Extensions for fixedDecimal
fixedId
Specifies a value that SHALL be exactly the value for this
element in the instance, if present. 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
("_fixedId") Extensions for fixedId
fixedInstant
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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
("_fixedInstant") Extensions for fixedInstant
fixedInteger
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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
("_fixedInteger") Extensions for fixedInteger
fixedInteger64
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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.
fixedInteger64Element
("_fixedInteger64") Extensions for fixedInteger64
fixedMarkdown
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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
("_fixedMarkdown") Extensions for fixedMarkdown
fixedOid
Specifies a value that SHALL be exactly the value for this
element in the instance, if present. 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
("_fixedOid") Extensions for fixedOid
fixedPositiveInt
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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
("_fixedPositiveInt") Extensions for
fixedPositiveInt
fixedString
Specifies a value that SHALL be exactly the value for this
element in the instance, if present. 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
("_fixedString") Extensions for fixedString
fixedTime
Specifies a value that SHALL be exactly the value for this
element in the instance, if present. 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
("_fixedTime") Extensions for fixedTime
fixedUnsignedInt
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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
("_fixedUnsignedInt") Extensions for
fixedUnsignedInt
fixedUri
Specifies a value that SHALL be exactly the value for this
element in the instance, if present. 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
("_fixedUri") Extensions for fixedUri
fixedUrl
Specifies a value that SHALL be exactly the value for this
element in the instance, if present. 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
("_fixedUrl") Extensions for fixedUrl
fixedUuid
Specifies a value that SHALL be exactly the value for this
element in the instance, if present. 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
("_fixedUuid") Extensions for fixedUuid
fixedAddress
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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.
fixedCodeableReference
Specifies a value that SHALL be exactly the
value for this element in the instance, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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.
fixedRatioRange
Specifies a value that SHALL be exactly the value for
this element in the instance, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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.
fixedAvailability
Specifies a value that SHALL be exactly the value
for this element in the instance, if present. 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.
fixedExtendedContactDetail
Specifies a value that SHALL be exactly the
value for this element in the instance, if present. 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, if present. 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.
fixedMeta
Specifies a value that SHALL be exactly the value for this
element in the instance, if present. 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 each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternBase64BinaryElement
("_patternBase64Binary") Extensions for
patternBase64Binary
patternBoolean
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternBooleanElement
("_patternBoolean") Extensions for patternBoolean
patternCanonical
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternCanonicalElement
("_patternCanonical") Extensions for
patternCanonical
patternCode
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternCodeElement
("_patternCode") Extensions for patternCode
patternDate
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternDateElement
("_patternDate") Extensions for patternDate
patternDateTime
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternDateTimeElement
("_patternDateTime") Extensions for
patternDateTime
patternDecimal
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternDecimalElement
("_patternDecimal") Extensions for patternDecimal
patternId
Specifies a value that each occurrence of the element in the
instance SHALL follow - that is, any value in the pattern must be found
in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternIdElement
("_patternId") Extensions for patternId
patternInstant
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternInstantElement
("_patternInstant") Extensions for patternInstant
patternInteger
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternIntegerElement
("_patternInteger") Extensions for patternInteger
patternInteger64
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternInteger64Element
("_patternInteger64") Extensions for
patternInteger64
patternMarkdown
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternMarkdownElement
("_patternMarkdown") Extensions for
patternMarkdown
patternOid
Specifies a value that each occurrence of the element in the
instance SHALL follow - that is, any value in the pattern must be found
in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternOidElement
("_patternOid") Extensions for patternOid
patternPositiveInt
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternPositiveIntElement
("_patternPositiveInt") Extensions for
patternPositiveInt
patternString
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternStringElement
("_patternString") Extensions for patternString
patternTime
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternTimeElement
("_patternTime") Extensions for patternTime
patternUnsignedInt
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternUnsignedIntElement
("_patternUnsignedInt") Extensions for
patternUnsignedInt
patternUri
Specifies a value that each occurrence of the element in the
instance SHALL follow - that is, any value in the pattern must be found
in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternUriElement
("_patternUri") Extensions for patternUri
patternUrl
Specifies a value that each occurrence of the element in the
instance SHALL follow - that is, any value in the pattern must be found
in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternUrlElement
("_patternUrl") Extensions for patternUrl
patternUuid
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternUuidElement
("_patternUuid") Extensions for patternUuid
patternAddress
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternAge
Specifies a value that each occurrence of the element in the
instance SHALL follow - that is, any value in the pattern must be found
in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternAnnotation
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternAttachment
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternCodeableConcept
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternCodeableReference
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternCoding
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternContactPoint
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternCount
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternDistance
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternDuration
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternHumanName
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternIdentifier
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternMoney
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternPeriod
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternQuantity
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternRange
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternRatio
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternRatioRange
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternReference
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternSampledData
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternSignature
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternTiming
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternContactDetail
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternDataRequirement
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternExpression
Specifies a value that each occurrence of the element
in the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternParameterDefinition
Specifies a value that each occurrence of
the element in the instance SHALL follow - that is, any value in the
pattern must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternRelatedArtifact
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternTriggerDefinition
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternUsageContext
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternAvailability
Specifies a value that each occurrence of the
element in the instance SHALL follow - that is, any value in the pattern
must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternExtendedContactDetail
Specifies a value that each occurrence of
the element in the instance SHALL follow - that is, any value in the
pattern must be found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternDosage
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
patternMeta
Specifies a value that each occurrence of the element in
the instance SHALL follow - that is, any value in the pattern must be
found in the instance, if the element has a value. 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 an element within a patternx
is used to constrain an array, it
means that each element provided in the patternx
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
If a patternx
is declared on a repeating element, the pattern applies
to all repetitions. If the desire is for a pattern to apply to only one
element or a subset of elements, slicing must be used. See Examples of
Patterns for examples
of pattern usage and the effect it will have.
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
("_minValueDate") 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
("_minValueDateTime") 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
("_minValueInstant") 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
("_minValueTime") 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
("_minValueDecimal") 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
("_minValueInteger") Extensions for
minValueInteger
minValueInteger64
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.
minValueInteger64Element
("_minValueInteger64") Extensions for
minValueInteger64
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
("_minValuePositiveInt") 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
("_minValueUnsignedInt") 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
("_maxValueDate") 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
("_maxValueDateTime") 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
("_maxValueInstant") 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
("_maxValueTime") 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
("_maxValueDecimal") 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
("_maxValueInteger") Extensions for
maxValueInteger
maxValueInteger64
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.
maxValueInteger64Element
("_maxValueInteger64") Extensions for
maxValueInteger64
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
("_maxValuePositiveInt") 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
("_maxValueUnsignedInt") 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.
maxLength
SHOULD only be used on primitive data types that have a
string representation (see
[[http://hl7.org/fhir/StructureDefinition/structuredefinition-type-characteristics
]]).
maxLengthElement
("_maxLength") Extensions for maxLength
condition
A reference to an invariant that may make additional
statements about the cardinality or value in the instance.
conditionElement
("_condition") Extensions for condition
constraint
Formal constraints such as co-occurrence and other
constraints that can be computationally evaluated within the context of
the instance.
mustHaveValue
Specifies for a primitive data type that the value of the
data type cannot be replaced by an extension.
mustHaveValueElement
("_mustHaveValue") Extensions for mustHaveValue
valueAlternatives
Specifies a list of extensions that can appear in
place of a primitive value.
mustSupport
If true, implementations that produce or consume resources
SHALL provide "support" for the element in some meaningful way. Note
that this is being phased out and replaced by obligations (see below).
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
("_mustSupport") 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. When used on the root
element in an extension definition, this indicates whether or not the
extension is a modifier extension.
isModifierElement
("_isModifier") Extensions for isModifier
isModifierReason
Explains how that element affects the interpretation
of the resource or element that contains it.
isModifierReasonElement
("_isModifierReason") Extensions for
isModifierReason
isSummary
Whether the element should be included if a client requests a
search with the parameter _summary=true.
isSummaryElement
("_isSummary") 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
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternBase64BinaryElement] ("_patternBase64Binary") Extensions for
/// patternBase64Binary
///
/// [patternBoolean] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternBooleanElement] ("_patternBoolean") Extensions for patternBoolean
///
/// [patternCanonical] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternCanonicalElement] ("_patternCanonical") Extensions for
/// patternCanonical
///
/// [patternCode] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternCodeElement] ("_patternCode") Extensions for patternCode
///
/// [patternDate] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternDateElement] ("_patternDate") Extensions for patternDate
///
/// [patternDateTime] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternDateTimeElement] ("_patternDateTime") Extensions for
/// patternDateTime
///
/// [patternDecimal] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternDecimalElement] ("_patternDecimal") Extensions for patternDecimal
///
/// [patternId] Specifies a value that each occurrence of the element in the
/// instance SHALL follow - that is, any value in the pattern must be found
/// in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternIdElement] ("_patternId") Extensions for patternId
///
/// [patternInstant] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternInstantElement] ("_patternInstant") Extensions for patternInstant
///
/// [patternInteger] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternIntegerElement] ("_patternInteger") Extensions for patternInteger
///
/// [patternInteger64] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternInteger64Element] ("_patternInteger64") Extensions for
/// patternInteger64
///
/// [patternMarkdown] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternMarkdownElement] ("_patternMarkdown") Extensions for
/// patternMarkdown
///
/// [patternOid] Specifies a value that each occurrence of the element in the
/// instance SHALL follow - that is, any value in the pattern must be found
/// in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternOidElement] ("_patternOid") Extensions for patternOid
///
/// [patternPositiveInt] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternPositiveIntElement] ("_patternPositiveInt") Extensions for
/// patternPositiveInt
///
/// [patternString] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternStringElement] ("_patternString") Extensions for patternString
///
/// [patternTime] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternTimeElement] ("_patternTime") Extensions for patternTime
///
/// [patternUnsignedInt] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternUnsignedIntElement] ("_patternUnsignedInt") Extensions for
/// patternUnsignedInt
///
/// [patternUri] Specifies a value that each occurrence of the element in the
/// instance SHALL follow - that is, any value in the pattern must be found
/// in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternUriElement] ("_patternUri") Extensions for patternUri
///
/// [patternUrl] Specifies a value that each occurrence of the element in the
/// instance SHALL follow - that is, any value in the pattern must be found
/// in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternUrlElement] ("_patternUrl") Extensions for patternUrl
///
/// [patternUuid] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternUuidElement] ("_patternUuid") Extensions for patternUuid
///
/// [patternAddress] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternAge] Specifies a value that each occurrence of the element in the
/// instance SHALL follow - that is, any value in the pattern must be found
/// in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternAnnotation] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternAttachment] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternCodeableConcept] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternCodeableReference] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternCoding] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternContactPoint] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternCount] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternDistance] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternDuration] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternHumanName] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternIdentifier] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternMoney] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternPeriod] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternQuantity] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternRange] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternRatio] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternRatioRange] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternReference] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternSampledData] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternSignature] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternTiming] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternContactDetail] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternDataRequirement] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternExpression] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternParameterDefinition] Specifies a value that each occurrence of
/// the element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternRelatedArtifact] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternTriggerDefinition] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternUsageContext] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternAvailability] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the pattern
/// must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternExtendedContactDetail] Specifies a value that each occurrence of
/// the element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternDosage] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [patternMeta] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only one
/// element or a subset of elements, slicing must be used. See [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for examples
/// of pattern usage and the effect it will have.
///
/// [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] ("_minValueDate") 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] ("_minValueDateTime") 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] ("_minValueInstant") 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] ("_minValueTime") 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] ("_minValueDecimal") 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] ("_minValueInteger") Extensions for
/// minValueInteger
///
/// [minValueInteger64] 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.
///
/// [minValueInteger64Element] ("_minValueInteger64") Extensions for
/// minValueInteger64
///
/// [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] ("_minValuePositiveInt") 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] ("_minValueUnsignedInt") 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] ("_maxValueDate") 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] ("_maxValueDateTime") 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] ("_maxValueInstant") 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] ("_maxValueTime") 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] ("_maxValueDecimal") 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] ("_maxValueInteger") Extensions for
/// maxValueInteger
///
/// [maxValueInteger64] 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.
///
/// [maxValueInteger64Element] ("_maxValueInteger64") Extensions for
/// maxValueInteger64
///
/// [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] ("_maxValuePositiveInt") 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] ("_maxValueUnsignedInt") 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.
/// ```maxLength``` SHOULD only be used on primitive data types that have a
/// string representation (see
/// [[[http://hl7.org/fhir/StructureDefinition/structuredefinition-type-characteristics]]]).
///
///
/// [maxLengthElement] ("_maxLength") Extensions for maxLength
///
/// [condition] A reference to an invariant that may make additional
/// statements about the cardinality or value in the instance.
///
/// [conditionElement] ("_condition") Extensions for condition
///
/// [constraint] Formal constraints such as co-occurrence and other
/// constraints that can be computationally evaluated within the context of
/// the instance.
///
/// [mustHaveValue] Specifies for a primitive data type that the value of the
/// data type cannot be replaced by an extension.
///
/// [mustHaveValueElement] ("_mustHaveValue") Extensions for mustHaveValue
///
/// [valueAlternatives] Specifies a list of extensions that can appear in
/// place of a primitive value.
///
/// [mustSupport] If true, implementations that produce or consume resources
/// SHALL provide "support" for the element in some meaningful way. Note
/// that this is being phased out and replaced by obligations (see below).
/// 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] ("_mustSupport") 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. When used on the root
/// element in an extension definition, this indicates whether or not the
/// extension is a modifier extension.
///
/// [isModifierElement] ("_isModifier") Extensions for isModifier
///
/// [isModifierReason] Explains how that element affects the interpretation
/// of the resource or element that contains it.
///
/// [isModifierReasonElement] ("_isModifierReason") Extensions for
/// isModifierReason
///
/// [isSummary] Whether the element should be included if a client requests a
/// search with the parameter _summary=true.
///
/// [isSummaryElement] ("_isSummary") 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.
///
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_] ("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 managable, 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 managable, 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] ("_path") 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. No
/// extensions are allowed on elements with a representation of 'xmlAttr',
/// no matter what FHIR serialization format is used.
List<ElementDefinitionRepresentation>? representation,
/// [representationElement] ("_representation") 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] ("_sliceName") 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] ("_sliceIsConstraining") 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] ("_label") 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] ("_short") 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] ("_definition") 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] ("_comment") 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] ("_requirements") Extensions for requirements
@JsonKey(name: '_requirements') Element? requirementsElement,
/// [alias] Identifies additional names by which this element might also be
/// known.
List<String>? alias,
/// [aliasElement] ("_alias") 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] ("_min") 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] ("_max") 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 - e.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] ("_contentReference") 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,
/// [defaultValueBase64BinaryElement] ("_defaultValueBase64Binary")
/// Extensions for defaultValueBase64Binary
@JsonKey(name: '_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] ("_defaultValueBoolean") 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,
/// [defaultValueCanonicalElement] ("_defaultValueCanonical") Extensions
/// for defaultValueCanonical
@JsonKey(name: '_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] ("_defaultValueCode") 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] ("_defaultValueDate") 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,
/// [defaultValueDateTimeElement] ("_defaultValueDateTime") Extensions for
/// defaultValueDateTime
@JsonKey(name: '_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] ("_defaultValueDecimal") 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] ("_defaultValueId") 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] ("_defaultValueInstant") 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] ("_defaultValueInteger") Extensions for
/// defaultValueInteger
@JsonKey(name: '_defaultValueInteger') Element? defaultValueIntegerElement,
/// [defaultValueInteger64] 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').
FhirInteger64? defaultValueInteger64,
/// [defaultValueInteger64Element] ("_defaultValueInteger64") Extensions
/// for defaultValueInteger64
@JsonKey(name: '_defaultValueInteger64')
Element? defaultValueInteger64Element,
/// [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,
/// [defaultValueMarkdownElement] ("_defaultValueMarkdown") Extensions for
/// defaultValueMarkdown
@JsonKey(name: '_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').
FhirId? defaultValueOid,
/// [defaultValueOidElement] ("_defaultValueOid") 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,
/// [defaultValuePositiveIntElement] ("_defaultValuePositiveInt")
/// Extensions for defaultValuePositiveInt
@JsonKey(name: '_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] ("_defaultValueString") 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] ("_defaultValueTime") 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,
/// [defaultValueUnsignedIntElement] ("_defaultValueUnsignedInt")
/// Extensions for defaultValueUnsignedInt
@JsonKey(name: '_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] ("_defaultValueUri") 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] ("_defaultValueUrl") 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').
FhirId? defaultValueUuid,
/// [defaultValueUuidElement] ("_defaultValueUuid") 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,
/// [defaultValueCodeableReference] 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').
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,
/// [defaultValueRatioRange] 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').
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,
/// [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,
/// [defaultValueAvailability] 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').
Availability? defaultValueAvailability,
/// [defaultValueExtendedContactDetail] 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').
ExtendedContactDetail? defaultValueExtendedContactDetail,
/// [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,
/// [defaultValueMeta] 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').
FhirMeta? defaultValueMeta,
/// [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] ("_meaningWhenMissing") 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] ("_orderMeaning") Extensions for orderMeaning
@JsonKey(name: '_orderMeaning') Element? orderMeaningElement,
/// [fixedBase64Binary] Specifies a value that SHALL be exactly the value
/// for this element in the instance, if present. 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] ("_fixedBase64Binary") Extensions for
/// fixedBase64Binary
@JsonKey(name: '_fixedBase64Binary') Element? fixedBase64BinaryElement,
/// [fixedBoolean] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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] ("_fixedBoolean") Extensions for fixedBoolean
@JsonKey(name: '_fixedBoolean') Element? fixedBooleanElement,
/// [fixedCanonical] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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] ("_fixedCanonical") Extensions for
/// fixedCanonical
@JsonKey(name: '_fixedCanonical') Element? fixedCanonicalElement,
/// [fixedCode] Specifies a value that SHALL be exactly the value for this
/// element in the instance, if present. 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] ("_fixedCode") Extensions for fixedCode
@JsonKey(name: '_fixedCode') Element? fixedCodeElement,
/// [fixedDate] Specifies a value that SHALL be exactly the value for this
/// element in the instance, if present. 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] ("_fixedDate") Extensions for fixedDate
@JsonKey(name: '_fixedDate') Element? fixedDateElement,
/// [fixedDateTime] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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] ("_fixedDateTime") Extensions for fixedDateTime
@JsonKey(name: '_fixedDateTime') Element? fixedDateTimeElement,
/// [fixedDecimal] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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] ("_fixedDecimal") Extensions for fixedDecimal
@JsonKey(name: '_fixedDecimal') Element? fixedDecimalElement,
/// [fixedId] Specifies a value that SHALL be exactly the value for this
/// element in the instance, if present. 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] ("_fixedId") Extensions for fixedId
@JsonKey(name: '_fixedId') Element? fixedIdElement,
/// [fixedInstant] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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] ("_fixedInstant") Extensions for fixedInstant
@JsonKey(name: '_fixedInstant') Element? fixedInstantElement,
/// [fixedInteger] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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] ("_fixedInteger") Extensions for fixedInteger
@JsonKey(name: '_fixedInteger') Element? fixedIntegerElement,
/// [fixedInteger64] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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.
FhirInteger64? fixedInteger64,
/// [fixedInteger64Element] ("_fixedInteger64") Extensions for
/// fixedInteger64
@JsonKey(name: '_fixedInteger64') Element? fixedInteger64Element,
/// [fixedMarkdown] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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] ("_fixedMarkdown") Extensions for fixedMarkdown
@JsonKey(name: '_fixedMarkdown') Element? fixedMarkdownElement,
/// [fixedOid] Specifies a value that SHALL be exactly the value for this
/// element in the instance, if present. 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? fixedOid,
/// [fixedOidElement] ("_fixedOid") Extensions for fixedOid
@JsonKey(name: '_fixedOid') Element? fixedOidElement,
/// [fixedPositiveInt] Specifies a value that SHALL be exactly the value
/// for this element in the instance, if present. 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] ("_fixedPositiveInt") Extensions for
/// fixedPositiveInt
@JsonKey(name: '_fixedPositiveInt') Element? fixedPositiveIntElement,
/// [fixedString] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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] ("_fixedString") Extensions for fixedString
@JsonKey(name: '_fixedString') Element? fixedStringElement,
/// [fixedTime] Specifies a value that SHALL be exactly the value for this
/// element in the instance, if present. 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] ("_fixedTime") Extensions for fixedTime
@JsonKey(name: '_fixedTime') Element? fixedTimeElement,
/// [fixedUnsignedInt] Specifies a value that SHALL be exactly the value
/// for this element in the instance, if present. 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] ("_fixedUnsignedInt") Extensions for
/// fixedUnsignedInt
@JsonKey(name: '_fixedUnsignedInt') Element? fixedUnsignedIntElement,
/// [fixedUri] Specifies a value that SHALL be exactly the value for this
/// element in the instance, if present. 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] ("_fixedUri") Extensions for fixedUri
@JsonKey(name: '_fixedUri') Element? fixedUriElement,
/// [fixedUrl] Specifies a value that SHALL be exactly the value for this
/// element in the instance, if present. 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] ("_fixedUrl") Extensions for fixedUrl
@JsonKey(name: '_fixedUrl') Element? fixedUrlElement,
/// [fixedUuid] Specifies a value that SHALL be exactly the value for this
/// element in the instance, if present. 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? fixedUuid,
/// [fixedUuidElement] ("_fixedUuid") Extensions for fixedUuid
@JsonKey(name: '_fixedUuid') Element? fixedUuidElement,
/// [fixedAddress] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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,
/// [fixedCodeableReference] Specifies a value that SHALL be exactly the
/// value for this element in the instance, if present. 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.
CodeableReference? fixedCodeableReference,
/// [fixedCoding] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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,
/// [fixedRatioRange] Specifies a value that SHALL be exactly the value
/// for this element in the instance, if present. 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.
RatioRange? fixedRatioRange,
/// [fixedReference] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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,
/// [fixedDataRequirement] Specifies a value that SHALL be exactly the
/// value for this element in the instance, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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, if present. 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,
/// [fixedAvailability] Specifies a value that SHALL be exactly the value
/// for this element in the instance, if present. 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.
Availability? fixedAvailability,
/// [fixedExtendedContactDetail] Specifies a value that SHALL be exactly
/// the value for this element in the instance, if present. 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.
ExtendedContactDetail? fixedExtendedContactDetail,
/// [fixedDosage] Specifies a value that SHALL be exactly the value for
/// this element in the instance, if present. 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,
/// [fixedMeta] Specifies a value that SHALL be exactly the value for this
/// element in the instance, if present. 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.
FhirMeta? fixedMeta,
/// [patternBase64Binary] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirBase64Binary? patternBase64Binary,
/// [patternBase64BinaryElement] ("_patternBase64Binary") Extensions for
/// patternBase64Binary
@JsonKey(name: '_patternBase64Binary') Element? patternBase64BinaryElement,
/// [patternBoolean] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirBoolean? patternBoolean,
/// [patternBooleanElement] ("_patternBoolean") Extensions for
/// patternBoolean
@JsonKey(name: '_patternBoolean') Element? patternBooleanElement,
/// [patternCanonical] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirCanonical? patternCanonical,
/// [patternCanonicalElement] ("_patternCanonical") Extensions for
/// patternCanonical
@JsonKey(name: '_patternCanonical') Element? patternCanonicalElement,
/// [patternCode] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirCode? patternCode,
/// [patternCodeElement] ("_patternCode") Extensions for patternCode
@JsonKey(name: '_patternCode') Element? patternCodeElement,
/// [patternDate] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirDate? patternDate,
/// [patternDateElement] ("_patternDate") Extensions for patternDate
@JsonKey(name: '_patternDate') Element? patternDateElement,
/// [patternDateTime] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirDateTime? patternDateTime,
/// [patternDateTimeElement] ("_patternDateTime") Extensions for
/// patternDateTime
@JsonKey(name: '_patternDateTime') Element? patternDateTimeElement,
/// [patternDecimal] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirDecimal? patternDecimal,
/// [patternDecimalElement] ("_patternDecimal") Extensions for
/// patternDecimal
@JsonKey(name: '_patternDecimal') Element? patternDecimalElement,
/// [patternId] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirId? patternId,
/// [patternIdElement] ("_patternId") Extensions for patternId
@JsonKey(name: '_patternId') Element? patternIdElement,
/// [patternInstant] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirInstant? patternInstant,
/// [patternInstantElement] ("_patternInstant") Extensions for
/// patternInstant
@JsonKey(name: '_patternInstant') Element? patternInstantElement,
/// [patternInteger] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirInteger? patternInteger,
/// [patternIntegerElement] ("_patternInteger") Extensions for
/// patternInteger
@JsonKey(name: '_patternInteger') Element? patternIntegerElement,
/// [patternInteger64] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirInteger64? patternInteger64,
/// [patternInteger64Element] ("_patternInteger64") Extensions for
/// patternInteger64
@JsonKey(name: '_patternInteger64') Element? patternInteger64Element,
/// [patternMarkdown] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirMarkdown? patternMarkdown,
/// [patternMarkdownElement] ("_patternMarkdown") Extensions for
/// patternMarkdown
@JsonKey(name: '_patternMarkdown') Element? patternMarkdownElement,
/// [patternOid] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirId? patternOid,
/// [patternOidElement] ("_patternOid") Extensions for patternOid
@JsonKey(name: '_patternOid') Element? patternOidElement,
/// [patternPositiveInt] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirPositiveInt? patternPositiveInt,
/// [patternPositiveIntElement] ("_patternPositiveInt") Extensions for
/// patternPositiveInt
@JsonKey(name: '_patternPositiveInt') Element? patternPositiveIntElement,
/// [patternString] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
String? patternString,
/// [patternStringElement] ("_patternString") Extensions for patternString
@JsonKey(name: '_patternString') Element? patternStringElement,
/// [patternTime] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirTime? patternTime,
/// [patternTimeElement] ("_patternTime") Extensions for patternTime
@JsonKey(name: '_patternTime') Element? patternTimeElement,
/// [patternUnsignedInt] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirUnsignedInt? patternUnsignedInt,
/// [patternUnsignedIntElement] ("_patternUnsignedInt") Extensions for
/// patternUnsignedInt
@JsonKey(name: '_patternUnsignedInt') Element? patternUnsignedIntElement,
/// [patternUri] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirUri? patternUri,
/// [patternUriElement] ("_patternUri") Extensions for patternUri
@JsonKey(name: '_patternUri') Element? patternUriElement,
/// [patternUrl] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirUrl? patternUrl,
/// [patternUrlElement] ("_patternUrl") Extensions for patternUrl
@JsonKey(name: '_patternUrl') Element? patternUrlElement,
/// [patternUuid] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirId? patternUuid,
/// [patternUuidElement] ("_patternUuid") Extensions for patternUuid
@JsonKey(name: '_patternUuid') Element? patternUuidElement,
/// [patternAddress] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Address? patternAddress,
/// [patternAge] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Age? patternAge,
/// [patternAnnotation] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Annotation? patternAnnotation,
/// [patternAttachment] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Attachment? patternAttachment,
/// [patternCodeableConcept] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
CodeableConcept? patternCodeableConcept,
/// [patternCodeableReference] Specifies a value that each occurrence of
/// the element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
CodeableReference? patternCodeableReference,
/// [patternCoding] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Coding? patternCoding,
/// [patternContactPoint] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
ContactPoint? patternContactPoint,
/// [patternCount] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Count? patternCount,
/// [patternDistance] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Distance? patternDistance,
/// [patternDuration] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirDuration? patternDuration,
/// [patternHumanName] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
HumanName? patternHumanName,
/// [patternIdentifier] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Identifier? patternIdentifier,
/// [patternMoney] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Money? patternMoney,
/// [patternPeriod] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Period? patternPeriod,
/// [patternQuantity] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Quantity? patternQuantity,
/// [patternRange] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Range? patternRange,
/// [patternRatio] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Ratio? patternRatio,
/// [patternRatioRange] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
RatioRange? patternRatioRange,
/// [patternReference] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Reference? patternReference,
/// [patternSampledData] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
SampledData? patternSampledData,
/// [patternSignature] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Signature? patternSignature,
/// [patternTiming] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Timing? patternTiming,
/// [patternContactDetail] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
ContactDetail? patternContactDetail,
/// [patternDataRequirement] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
DataRequirement? patternDataRequirement,
/// [patternExpression] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirExpression? patternExpression,
/// [patternParameterDefinition] Specifies a value that each occurrence of
/// the element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
ParameterDefinition? patternParameterDefinition,
/// [patternRelatedArtifact] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
RelatedArtifact? patternRelatedArtifact,
/// [patternTriggerDefinition] Specifies a value that each occurrence of
/// the element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
TriggerDefinition? patternTriggerDefinition,
/// [patternUsageContext] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
UsageContext? patternUsageContext,
/// [patternAvailability] Specifies a value that each occurrence of the
/// element in the instance SHALL follow - that is, any value in the
/// pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Availability? patternAvailability,
/// [patternExtendedContactDetail] Specifies a value that each occurrence
/// of the element in the instance SHALL follow - that is, any value in
/// the pattern must be found in the instance, if the element has a value.
/// 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
ExtendedContactDetail? patternExtendedContactDetail,
/// [patternDosage] Specifies a value that each occurrence of the element
/// in the instance SHALL follow - that is, any value in the pattern must
/// be found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
Dosage? patternDosage,
/// [patternMeta] Specifies a value that each occurrence of the element in
/// the instance SHALL follow - that is, any value in the pattern must be
/// found in the instance, if the element has a value. 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 an element within a pattern[x] is used to constrain an array, it
/// means that each element provided in the pattern[x] 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
///
/// If a pattern[x] is declared on a repeating element, the pattern applies
/// to all repetitions. If the desire is for a pattern to apply to only
/// one element or a subset of elements, slicing must be used. See
/// [Examples of
/// Patterns](elementdefinition-examples.html#pattern-examples) for
/// examples of pattern usage and the effect it will have.
FhirMeta? patternMeta,
/// [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] ("_minValueDate") 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] ("_minValueDateTime") 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] ("_minValueInstant") 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] ("_minValueTime") 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] ("_minValueDecimal") 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] ("_minValueInteger") Extensions for
/// minValueInteger
@JsonKey(name: '_minValueInteger') Element? minValueIntegerElement,
/// [minValueInteger64] 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.
FhirInteger64? minValueInteger64,
/// [minValueInteger64Element] ("_minValueInteger64") Extensions for
/// minValueInteger64
@JsonKey(name: '_minValueInteger64') Element? minValueInteger64Element,
/// [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] ("_minValuePositiveInt") 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] ("_minValueUnsignedInt") 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] ("_maxValueDate") 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] ("_maxValueDateTime") 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] ("_maxValueInstant") 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] ("_maxValueTime") 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] ("_maxValueDecimal") 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] ("_maxValueInteger") Extensions for
/// maxValueInteger
@JsonKey(name: '_maxValueInteger') Element? maxValueIntegerElement,
/// [maxValueInteger64] 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.
FhirInteger64? maxValueInteger64,
/// [maxValueInteger64Element] ("_maxValueInteger64") Extensions for
/// maxValueInteger64
@JsonKey(name: '_maxValueInteger64') Element? maxValueInteger64Element,
/// [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] ("_maxValuePositiveInt") 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] ("_maxValueUnsignedInt") 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.
/// ```maxLength``` SHOULD only be used on primitive data types that have
/// a string representation (see
/// [[[http://hl7.org/fhir/StructureDefinition/structuredefinition-type-characteristics]]]).
///
FhirInteger? maxLength,
/// [maxLengthElement] ("_maxLength") 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] ("_condition") 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,
/// [mustHaveValue] Specifies for a primitive data type that the value of
/// the data type cannot be replaced by an extension.
FhirBoolean? mustHaveValue,
/// [mustHaveValueElement] ("_mustHaveValue") Extensions for mustHaveValue
@JsonKey(name: '_mustHaveValue') Element? mustHaveValueElement,
/// [valueAlternatives] Specifies a list of extensions that can appear in
/// place of a primitive value.
List<FhirCanonical>? valueAlternatives,
/// [mustSupport] If true, implementations that produce or consume
/// resources SHALL provide "support" for the element in some meaningful
/// way. Note that this is being phased out and replaced by obligations
/// (see below). 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] ("_mustSupport") 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. When used on the
/// root element in an extension definition, this indicates whether or not
/// the extension is a modifier extension.
FhirBoolean? isModifier,
/// [isModifierElement] ("_isModifier") 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] ("_isModifierReason") 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] ("_isSummary") 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;