Class ElementDefinition

All Implemented Interfaces:
ca.uhn.fhir.model.api.IElement, Serializable, org.hl7.fhir.instance.model.api.IBase, org.hl7.fhir.instance.model.api.IBaseBackboneElement, org.hl7.fhir.instance.model.api.IBaseDatatype, org.hl7.fhir.instance.model.api.IBaseElement, org.hl7.fhir.instance.model.api.IBaseHasExtensions, org.hl7.fhir.instance.model.api.IBaseHasModifierExtensions, org.hl7.fhir.instance.model.api.ICompositeType

public class ElementDefinition extends BackboneType implements org.hl7.fhir.instance.model.api.ICompositeType
ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension.
See Also:
  • Field Details

    • path

      protected StringType 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.
    • 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.
    • sliceName

      protected StringType 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.
    • 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.
    • label

      protected StringType 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.
    • code

      protected List<Coding> 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_

      protected StringType short_
      A concise description of what this element means (e.g. for use in autogenerated summaries).
    • 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).
    • comment

      protected MarkdownType 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).
    • 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.
    • alias

      protected List<StringType> alias
      Identifies additional names by which this element might also be known.
    • min

      protected UnsignedIntType min
      The minimum number of times this element SHALL appear in the instance.
    • max

      protected StringType max
      The maximum number of times this element is permitted to appear in the instance.
    • base

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

      Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc.
    • type

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

      The 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').
    • 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.
    • fixed

      protected DataType fixed
      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.
    • pattern

      protected DataType pattern
      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.
    • minValue

      protected DataType minValue
      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.
    • maxValue

      protected DataType maxValue
      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 [Datatype characteristics](extension-structuredefinition-type-characteristics.html)).
    • condition

      protected List<IdType> condition
      A reference to an invariant that may make additional statements about the cardinality or value in the instance.
    • constraint

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

      If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.
    • 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.
    • isModifierReason

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

      Whether the element should be included if a client requests a search with the parameter _summary=true.
    • 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.
    • NOT_MODIFIER

      public static final boolean NOT_MODIFIER
      See Also:
    • NOT_IN_SUMMARY

      public static final boolean NOT_IN_SUMMARY
      See Also:
    • IS_MODIFIER

      public static final boolean IS_MODIFIER
      See Also:
    • IS_IN_SUMMARY

      public static final boolean IS_IN_SUMMARY
      See Also:
  • Constructor Details

  • Method Details

    • getPathElement

      Returns:
      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.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
    • hasPathElement

      public boolean hasPathElement()
    • hasPath

      public boolean hasPath()
    • setPathElement

      Parameters:
      value - 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.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
    • getPath

      public String getPath()
      Returns:
      The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension.
    • setPath

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

      Returns:
      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.)
    • setRepresentation

      Returns:
      Returns a reference to this for easy method chaining
    • hasRepresentation

      public boolean hasRepresentation()
    • addRepresentationElement

      Returns:
      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.)
    • addRepresentation

      Parameters:
      value - 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.)
    • hasRepresentation

      Parameters:
      value - 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.)
    • getSliceNameElement

      Returns:
      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.). This is the underlying object with id, value and extensions. The accessor "getSliceName" gives direct access to the value
    • hasSliceNameElement

      public boolean hasSliceNameElement()
    • hasSliceName

      public boolean hasSliceName()
    • setSliceNameElement

      Parameters:
      value - 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.). This is the underlying object with id, value and extensions. The accessor "getSliceName" gives direct access to the value
    • getSliceName

      public String getSliceName()
      Returns:
      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.
    • setSliceName

      Parameters:
      value - 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.
    • getSliceIsConstrainingElement

      Returns:
      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.). This is the underlying object with id, value and extensions. The accessor "getSliceIsConstraining" gives direct access to the value
    • hasSliceIsConstrainingElement

    • hasSliceIsConstraining

      public boolean hasSliceIsConstraining()
    • setSliceIsConstrainingElement

      Parameters:
      value - 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.). This is the underlying object with id, value and extensions. The accessor "getSliceIsConstraining" gives direct access to the value
    • getSliceIsConstraining

      public boolean getSliceIsConstraining()
      Returns:
      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.
    • setSliceIsConstraining

      public ElementDefinition setSliceIsConstraining(boolean value)
      Parameters:
      value - 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.
    • getLabelElement

      Returns:
      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.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
    • hasLabelElement

      public boolean hasLabelElement()
    • hasLabel

      public boolean hasLabel()
    • setLabelElement

      Parameters:
      value - 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.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
    • getLabel

      public String getLabel()
      Returns:
      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.
    • setLabel

      Parameters:
      value - 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.
    • getCode

      public List<Coding> getCode()
      Returns:
      code (A code that has the same meaning as the element in a particular terminology.)
    • setCode

      public ElementDefinition setCode(List<Coding> theCode)
      Returns:
      Returns a reference to this for easy method chaining
    • hasCode

      public boolean hasCode()
    • addCode

      public Coding addCode()
    • addCode

    • getCodeFirstRep

      Returns:
      The first repetition of repeating field code, creating it if it does not already exist {3}
    • getSlicing

      Returns:
      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).)
    • hasSlicing

      public boolean hasSlicing()
    • setSlicing

      Parameters:
      value - 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).)
    • getShortElement

      Returns:
      short_ (A concise description of what this element means (e.g. for use in autogenerated summaries).). This is the underlying object with id, value and extensions. The accessor "getShort" gives direct access to the value
    • hasShortElement

      public boolean hasShortElement()
    • hasShort

      public boolean hasShort()
    • setShortElement

      Parameters:
      value - short_ (A concise description of what this element means (e.g. for use in autogenerated summaries).). This is the underlying object with id, value and extensions. The accessor "getShort" gives direct access to the value
    • getShort

      public String getShort()
      Returns:
      A concise description of what this element means (e.g. for use in autogenerated summaries).
    • setShort

      Parameters:
      value - A concise description of what this element means (e.g. for use in autogenerated summaries).
    • getDefinitionElement

      Returns:
      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).). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value
    • hasDefinitionElement

      public boolean hasDefinitionElement()
    • hasDefinition

      public boolean hasDefinition()
    • setDefinitionElement

      Parameters:
      value - 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).). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value
    • getDefinition

      Returns:
      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).
    • setDefinition

      Parameters:
      value - 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).
    • getCommentElement

      Returns:
      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).). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value
    • hasCommentElement

      public boolean hasCommentElement()
    • hasComment

      public boolean hasComment()
    • setCommentElement

      Parameters:
      value - 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).). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value
    • getComment

      public String getComment()
      Returns:
      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).
    • setComment

      Parameters:
      value - 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).
    • getRequirementsElement

      Returns:
      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.). This is the underlying object with id, value and extensions. The accessor "getRequirements" gives direct access to the value
    • hasRequirementsElement

      public boolean hasRequirementsElement()
    • hasRequirements

      public boolean hasRequirements()
    • setRequirementsElement

      Parameters:
      value - 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.). This is the underlying object with id, value and extensions. The accessor "getRequirements" gives direct access to the value
    • getRequirements

      Returns:
      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.
    • setRequirements

      Parameters:
      value - 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.
    • getAlias

      Returns:
      alias (Identifies additional names by which this element might also be known.)
    • setAlias

      Returns:
      Returns a reference to this for easy method chaining
    • hasAlias

      public boolean hasAlias()
    • addAliasElement

      Returns:
      alias (Identifies additional names by which this element might also be known.)
    • addAlias

      Parameters:
      value - alias (Identifies additional names by which this element might also be known.)
    • hasAlias

      public boolean hasAlias(String value)
      Parameters:
      value - alias (Identifies additional names by which this element might also be known.)
    • getMinElement

      Returns:
      min (The minimum number of times this element SHALL appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value
    • hasMinElement

      public boolean hasMinElement()
    • hasMin

      public boolean hasMin()
    • setMinElement

      Parameters:
      value - min (The minimum number of times this element SHALL appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value
    • getMin

      public int getMin()
      Returns:
      The minimum number of times this element SHALL appear in the instance.
    • setMin

      public ElementDefinition setMin(int value)
      Parameters:
      value - The minimum number of times this element SHALL appear in the instance.
    • getMaxElement

      Returns:
      max (The maximum number of times this element is permitted to appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value
    • hasMaxElement

      public boolean hasMaxElement()
    • hasMax

      public boolean hasMax()
    • setMaxElement

      Parameters:
      value - max (The maximum number of times this element is permitted to appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value
    • getMax

      public String getMax()
      Returns:
      The maximum number of times this element is permitted to appear in the instance.
    • setMax

      Parameters:
      value - The maximum number of times this element is permitted to appear in the instance.
    • getBase

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

      public boolean hasBase()
    • setBase

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

      Returns:
      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.). This is the underlying object with id, value and extensions. The accessor "getContentReference" gives direct access to the value
    • hasContentReferenceElement

      public boolean hasContentReferenceElement()
    • hasContentReference

      public boolean hasContentReference()
    • setContentReferenceElement

      Parameters:
      value - 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.). This is the underlying object with id, value and extensions. The accessor "getContentReference" gives direct access to the value
    • getContentReference

      Returns:
      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.
    • setContentReference

      Parameters:
      value - 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.
    • getType

      Returns:
      type (The data type or resource that the value of this element is permitted to be.)
    • setType

      Returns:
      Returns a reference to this for easy method chaining
    • hasType

      public boolean hasType()
    • addType

    • addType

    • getTypeFirstRep

      Returns:
      The first repetition of repeating field type, creating it if it does not already exist {3}
    • getDefaultValue

      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
    • getDefaultValueBase64BinaryType

      public Base64BinaryType getDefaultValueBase64BinaryType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueBase64BinaryType

    • getDefaultValueBooleanType

      public BooleanType getDefaultValueBooleanType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueBooleanType

      public boolean hasDefaultValueBooleanType()
    • getDefaultValueCanonicalType

      public CanonicalType getDefaultValueCanonicalType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueCanonicalType

      public boolean hasDefaultValueCanonicalType()
    • getDefaultValueCodeType

      public CodeType getDefaultValueCodeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueCodeType

      public boolean hasDefaultValueCodeType()
    • getDefaultValueDateType

      public DateType getDefaultValueDateType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueDateType

      public boolean hasDefaultValueDateType()
    • getDefaultValueDateTimeType

      public DateTimeType getDefaultValueDateTimeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueDateTimeType

      public boolean hasDefaultValueDateTimeType()
    • getDefaultValueDecimalType

      public DecimalType getDefaultValueDecimalType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueDecimalType

      public boolean hasDefaultValueDecimalType()
    • getDefaultValueIdType

      public IdType getDefaultValueIdType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueIdType

      public boolean hasDefaultValueIdType()
    • getDefaultValueInstantType

      public InstantType getDefaultValueInstantType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueInstantType

      public boolean hasDefaultValueInstantType()
    • getDefaultValueIntegerType

      public IntegerType getDefaultValueIntegerType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueIntegerType

      public boolean hasDefaultValueIntegerType()
    • getDefaultValueInteger64Type

      public Integer64Type getDefaultValueInteger64Type() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueInteger64Type

      public boolean hasDefaultValueInteger64Type()
    • getDefaultValueMarkdownType

      public MarkdownType getDefaultValueMarkdownType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueMarkdownType

      public boolean hasDefaultValueMarkdownType()
    • getDefaultValueOidType

      public OidType getDefaultValueOidType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueOidType

      public boolean hasDefaultValueOidType()
    • getDefaultValuePositiveIntType

      public PositiveIntType getDefaultValuePositiveIntType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValuePositiveIntType

    • getDefaultValueStringType

      public StringType getDefaultValueStringType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueStringType

      public boolean hasDefaultValueStringType()
    • getDefaultValueTimeType

      public TimeType getDefaultValueTimeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueTimeType

      public boolean hasDefaultValueTimeType()
    • getDefaultValueUnsignedIntType

      public UnsignedIntType getDefaultValueUnsignedIntType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueUnsignedIntType

    • getDefaultValueUriType

      public UriType getDefaultValueUriType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueUriType

      public boolean hasDefaultValueUriType()
    • getDefaultValueUrlType

      public UrlType getDefaultValueUrlType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueUrlType

      public boolean hasDefaultValueUrlType()
    • getDefaultValueUuidType

      public UuidType getDefaultValueUuidType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueUuidType

      public boolean hasDefaultValueUuidType()
    • getDefaultValueAddress

      public Address getDefaultValueAddress() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueAddress

      public boolean hasDefaultValueAddress()
    • getDefaultValueAge

      public Age getDefaultValueAge() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueAge

      public boolean hasDefaultValueAge()
    • getDefaultValueAnnotation

      public Annotation getDefaultValueAnnotation() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueAnnotation

      public boolean hasDefaultValueAnnotation()
    • getDefaultValueAttachment

      public Attachment getDefaultValueAttachment() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueAttachment

      public boolean hasDefaultValueAttachment()
    • getDefaultValueCodeableConcept

      public CodeableConcept getDefaultValueCodeableConcept() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueCodeableConcept

    • getDefaultValueCodeableReference

      public CodeableReference getDefaultValueCodeableReference() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueCodeableReference

    • getDefaultValueCoding

      public Coding getDefaultValueCoding() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueCoding

      public boolean hasDefaultValueCoding()
    • getDefaultValueContactPoint

      public ContactPoint getDefaultValueContactPoint() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueContactPoint

      public boolean hasDefaultValueContactPoint()
    • getDefaultValueCount

      public Count getDefaultValueCount() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueCount

      public boolean hasDefaultValueCount()
    • getDefaultValueDistance

      public Distance getDefaultValueDistance() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueDistance

      public boolean hasDefaultValueDistance()
    • getDefaultValueDuration

      public Duration getDefaultValueDuration() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueDuration

      public boolean hasDefaultValueDuration()
    • getDefaultValueHumanName

      public HumanName getDefaultValueHumanName() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueHumanName

      public boolean hasDefaultValueHumanName()
    • getDefaultValueIdentifier

      public Identifier getDefaultValueIdentifier() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueIdentifier

      public boolean hasDefaultValueIdentifier()
    • getDefaultValueMoney

      public Money getDefaultValueMoney() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueMoney

      public boolean hasDefaultValueMoney()
    • getDefaultValuePeriod

      public Period getDefaultValuePeriod() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValuePeriod

      public boolean hasDefaultValuePeriod()
    • getDefaultValueQuantity

      public Quantity getDefaultValueQuantity() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueQuantity

      public boolean hasDefaultValueQuantity()
    • getDefaultValueRange

      public Range getDefaultValueRange() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueRange

      public boolean hasDefaultValueRange()
    • getDefaultValueRatio

      public Ratio getDefaultValueRatio() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueRatio

      public boolean hasDefaultValueRatio()
    • getDefaultValueRatioRange

      public RatioRange getDefaultValueRatioRange() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueRatioRange

      public boolean hasDefaultValueRatioRange()
    • getDefaultValueReference

      public Reference getDefaultValueReference() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueReference

      public boolean hasDefaultValueReference()
    • getDefaultValueSampledData

      public SampledData getDefaultValueSampledData() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueSampledData

      public boolean hasDefaultValueSampledData()
    • getDefaultValueSignature

      public Signature getDefaultValueSignature() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueSignature

      public boolean hasDefaultValueSignature()
    • getDefaultValueTiming

      public Timing getDefaultValueTiming() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueTiming

      public boolean hasDefaultValueTiming()
    • getDefaultValueContactDetail

      public ContactDetail getDefaultValueContactDetail() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueContactDetail

      public boolean hasDefaultValueContactDetail()
    • getDefaultValueDataRequirement

      public DataRequirement getDefaultValueDataRequirement() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueDataRequirement

    • getDefaultValueExpression

      public Expression getDefaultValueExpression() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueExpression

      public boolean hasDefaultValueExpression()
    • getDefaultValueParameterDefinition

      public ParameterDefinition getDefaultValueParameterDefinition() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueParameterDefinition

    • getDefaultValueRelatedArtifact

      public RelatedArtifact getDefaultValueRelatedArtifact() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueRelatedArtifact

    • getDefaultValueTriggerDefinition

      public TriggerDefinition getDefaultValueTriggerDefinition() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueTriggerDefinition

    • getDefaultValueUsageContext

      public UsageContext getDefaultValueUsageContext() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueUsageContext

      public boolean hasDefaultValueUsageContext()
    • getDefaultValueAvailability

      public Availability getDefaultValueAvailability() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueAvailability

      public boolean hasDefaultValueAvailability()
    • getDefaultValueExtendedContactDetail

      public ExtendedContactDetail getDefaultValueExtendedContactDetail() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueExtendedContactDetail

    • getDefaultValueDosage

      public Dosage getDefaultValueDosage() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueDosage

      public boolean hasDefaultValueDosage()
    • getDefaultValueMeta

      public Meta getDefaultValueMeta() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasDefaultValueMeta

      public boolean hasDefaultValueMeta()
    • hasDefaultValue

      public boolean hasDefaultValue()
    • setDefaultValue

      Parameters:
      value - defaultValue (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
    • getMeaningWhenMissingElement

      Returns:
      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').). This is the underlying object with id, value and extensions. The accessor "getMeaningWhenMissing" gives direct access to the value
    • hasMeaningWhenMissingElement

      public boolean hasMeaningWhenMissingElement()
    • hasMeaningWhenMissing

      public boolean hasMeaningWhenMissing()
    • setMeaningWhenMissingElement

      Parameters:
      value - 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').). This is the underlying object with id, value and extensions. The accessor "getMeaningWhenMissing" gives direct access to the value
    • getMeaningWhenMissing

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

      Parameters:
      value - The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing').
    • getOrderMeaningElement

      Returns:
      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.). This is the underlying object with id, value and extensions. The accessor "getOrderMeaning" gives direct access to the value
    • hasOrderMeaningElement

      public boolean hasOrderMeaningElement()
    • hasOrderMeaning

      public boolean hasOrderMeaning()
    • setOrderMeaningElement

      Parameters:
      value - 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.). This is the underlying object with id, value and extensions. The accessor "getOrderMeaning" gives direct access to the value
    • getOrderMeaning

      Returns:
      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.
    • setOrderMeaning

      Parameters:
      value - 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.
    • getFixed

      public DataType getFixed()
      Returns:
      fixed (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.)
    • getFixedBase64BinaryType

      public Base64BinaryType getFixedBase64BinaryType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedBase64BinaryType

      public boolean hasFixedBase64BinaryType()
    • getFixedBooleanType

      public BooleanType getFixedBooleanType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedBooleanType

      public boolean hasFixedBooleanType()
    • getFixedCanonicalType

      public CanonicalType getFixedCanonicalType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedCanonicalType

      public boolean hasFixedCanonicalType()
    • getFixedCodeType

      public CodeType getFixedCodeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedCodeType

      public boolean hasFixedCodeType()
    • getFixedDateType

      public DateType getFixedDateType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedDateType

      public boolean hasFixedDateType()
    • getFixedDateTimeType

      public DateTimeType getFixedDateTimeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedDateTimeType

      public boolean hasFixedDateTimeType()
    • getFixedDecimalType

      public DecimalType getFixedDecimalType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedDecimalType

      public boolean hasFixedDecimalType()
    • getFixedIdType

      public IdType getFixedIdType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedIdType

      public boolean hasFixedIdType()
    • getFixedInstantType

      public InstantType getFixedInstantType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedInstantType

      public boolean hasFixedInstantType()
    • getFixedIntegerType

      public IntegerType getFixedIntegerType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedIntegerType

      public boolean hasFixedIntegerType()
    • getFixedInteger64Type

      public Integer64Type getFixedInteger64Type() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedInteger64Type

      public boolean hasFixedInteger64Type()
    • getFixedMarkdownType

      public MarkdownType getFixedMarkdownType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedMarkdownType

      public boolean hasFixedMarkdownType()
    • getFixedOidType

      public OidType getFixedOidType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedOidType

      public boolean hasFixedOidType()
    • getFixedPositiveIntType

      public PositiveIntType getFixedPositiveIntType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedPositiveIntType

      public boolean hasFixedPositiveIntType()
    • getFixedStringType

      public StringType getFixedStringType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedStringType

      public boolean hasFixedStringType()
    • getFixedTimeType

      public TimeType getFixedTimeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedTimeType

      public boolean hasFixedTimeType()
    • getFixedUnsignedIntType

      public UnsignedIntType getFixedUnsignedIntType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedUnsignedIntType

      public boolean hasFixedUnsignedIntType()
    • getFixedUriType

      public UriType getFixedUriType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedUriType

      public boolean hasFixedUriType()
    • getFixedUrlType

      public UrlType getFixedUrlType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedUrlType

      public boolean hasFixedUrlType()
    • getFixedUuidType

      public UuidType getFixedUuidType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedUuidType

      public boolean hasFixedUuidType()
    • getFixedAddress

      public Address getFixedAddress() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedAddress

      public boolean hasFixedAddress()
    • getFixedAge

      public Age getFixedAge() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedAge

      public boolean hasFixedAge()
    • getFixedAnnotation

      public Annotation getFixedAnnotation() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedAnnotation

      public boolean hasFixedAnnotation()
    • getFixedAttachment

      public Attachment getFixedAttachment() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedAttachment

      public boolean hasFixedAttachment()
    • getFixedCodeableConcept

      public CodeableConcept getFixedCodeableConcept() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedCodeableConcept

      public boolean hasFixedCodeableConcept()
    • getFixedCodeableReference

      public CodeableReference getFixedCodeableReference() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedCodeableReference

      public boolean hasFixedCodeableReference()
    • getFixedCoding

      public Coding getFixedCoding() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedCoding

      public boolean hasFixedCoding()
    • getFixedContactPoint

      public ContactPoint getFixedContactPoint() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedContactPoint

      public boolean hasFixedContactPoint()
    • getFixedCount

      public Count getFixedCount() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedCount

      public boolean hasFixedCount()
    • getFixedDistance

      public Distance getFixedDistance() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedDistance

      public boolean hasFixedDistance()
    • getFixedDuration

      public Duration getFixedDuration() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedDuration

      public boolean hasFixedDuration()
    • getFixedHumanName

      public HumanName getFixedHumanName() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedHumanName

      public boolean hasFixedHumanName()
    • getFixedIdentifier

      public Identifier getFixedIdentifier() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedIdentifier

      public boolean hasFixedIdentifier()
    • getFixedMoney

      public Money getFixedMoney() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedMoney

      public boolean hasFixedMoney()
    • getFixedPeriod

      public Period getFixedPeriod() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedPeriod

      public boolean hasFixedPeriod()
    • getFixedQuantity

      public Quantity getFixedQuantity() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedQuantity

      public boolean hasFixedQuantity()
    • getFixedRange

      public Range getFixedRange() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedRange

      public boolean hasFixedRange()
    • getFixedRatio

      public Ratio getFixedRatio() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedRatio

      public boolean hasFixedRatio()
    • getFixedRatioRange

      public RatioRange getFixedRatioRange() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedRatioRange

      public boolean hasFixedRatioRange()
    • getFixedReference

      public Reference getFixedReference() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedReference

      public boolean hasFixedReference()
    • getFixedSampledData

      public SampledData getFixedSampledData() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedSampledData

      public boolean hasFixedSampledData()
    • getFixedSignature

      public Signature getFixedSignature() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedSignature

      public boolean hasFixedSignature()
    • getFixedTiming

      public Timing getFixedTiming() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedTiming

      public boolean hasFixedTiming()
    • getFixedContactDetail

      public ContactDetail getFixedContactDetail() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedContactDetail

      public boolean hasFixedContactDetail()
    • getFixedDataRequirement

      public DataRequirement getFixedDataRequirement() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedDataRequirement

      public boolean hasFixedDataRequirement()
    • getFixedExpression

      public Expression getFixedExpression() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedExpression

      public boolean hasFixedExpression()
    • getFixedParameterDefinition

      public ParameterDefinition getFixedParameterDefinition() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedParameterDefinition

      public boolean hasFixedParameterDefinition()
    • getFixedRelatedArtifact

      public RelatedArtifact getFixedRelatedArtifact() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedRelatedArtifact

      public boolean hasFixedRelatedArtifact()
    • getFixedTriggerDefinition

      public TriggerDefinition getFixedTriggerDefinition() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedTriggerDefinition

      public boolean hasFixedTriggerDefinition()
    • getFixedUsageContext

      public UsageContext getFixedUsageContext() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedUsageContext

      public boolean hasFixedUsageContext()
    • getFixedAvailability

      public Availability getFixedAvailability() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedAvailability

      public boolean hasFixedAvailability()
    • getFixedExtendedContactDetail

      public ExtendedContactDetail getFixedExtendedContactDetail() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedExtendedContactDetail

    • getFixedDosage

      public Dosage getFixedDosage() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedDosage

      public boolean hasFixedDosage()
    • getFixedMeta

      public Meta getFixedMeta() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      fixed (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasFixedMeta

      public boolean hasFixedMeta()
    • hasFixed

      public boolean hasFixed()
    • setFixed

      Parameters:
      value - fixed (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.)
    • getPattern

      public DataType getPattern()
      Returns:
      pattern (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.)
    • getPatternBase64BinaryType

      public Base64BinaryType getPatternBase64BinaryType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternBase64BinaryType

      public boolean hasPatternBase64BinaryType()
    • getPatternBooleanType

      public BooleanType getPatternBooleanType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternBooleanType

      public boolean hasPatternBooleanType()
    • getPatternCanonicalType

      public CanonicalType getPatternCanonicalType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternCanonicalType

      public boolean hasPatternCanonicalType()
    • getPatternCodeType

      public CodeType getPatternCodeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternCodeType

      public boolean hasPatternCodeType()
    • getPatternDateType

      public DateType getPatternDateType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternDateType

      public boolean hasPatternDateType()
    • getPatternDateTimeType

      public DateTimeType getPatternDateTimeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternDateTimeType

      public boolean hasPatternDateTimeType()
    • getPatternDecimalType

      public DecimalType getPatternDecimalType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternDecimalType

      public boolean hasPatternDecimalType()
    • getPatternIdType

      public IdType getPatternIdType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternIdType

      public boolean hasPatternIdType()
    • getPatternInstantType

      public InstantType getPatternInstantType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternInstantType

      public boolean hasPatternInstantType()
    • getPatternIntegerType

      public IntegerType getPatternIntegerType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternIntegerType

      public boolean hasPatternIntegerType()
    • getPatternInteger64Type

      public Integer64Type getPatternInteger64Type() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternInteger64Type

      public boolean hasPatternInteger64Type()
    • getPatternMarkdownType

      public MarkdownType getPatternMarkdownType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternMarkdownType

      public boolean hasPatternMarkdownType()
    • getPatternOidType

      public OidType getPatternOidType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternOidType

      public boolean hasPatternOidType()
    • getPatternPositiveIntType

      public PositiveIntType getPatternPositiveIntType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternPositiveIntType

      public boolean hasPatternPositiveIntType()
    • getPatternStringType

      public StringType getPatternStringType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternStringType

      public boolean hasPatternStringType()
    • getPatternTimeType

      public TimeType getPatternTimeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternTimeType

      public boolean hasPatternTimeType()
    • getPatternUnsignedIntType

      public UnsignedIntType getPatternUnsignedIntType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternUnsignedIntType

      public boolean hasPatternUnsignedIntType()
    • getPatternUriType

      public UriType getPatternUriType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternUriType

      public boolean hasPatternUriType()
    • getPatternUrlType

      public UrlType getPatternUrlType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternUrlType

      public boolean hasPatternUrlType()
    • getPatternUuidType

      public UuidType getPatternUuidType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternUuidType

      public boolean hasPatternUuidType()
    • getPatternAddress

      public Address getPatternAddress() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternAddress

      public boolean hasPatternAddress()
    • getPatternAge

      public Age getPatternAge() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternAge

      public boolean hasPatternAge()
    • getPatternAnnotation

      public Annotation getPatternAnnotation() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternAnnotation

      public boolean hasPatternAnnotation()
    • getPatternAttachment

      public Attachment getPatternAttachment() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternAttachment

      public boolean hasPatternAttachment()
    • getPatternCodeableConcept

      public CodeableConcept getPatternCodeableConcept() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternCodeableConcept

      public boolean hasPatternCodeableConcept()
    • getPatternCodeableReference

      public CodeableReference getPatternCodeableReference() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternCodeableReference

      public boolean hasPatternCodeableReference()
    • getPatternCoding

      public Coding getPatternCoding() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternCoding

      public boolean hasPatternCoding()
    • getPatternContactPoint

      public ContactPoint getPatternContactPoint() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternContactPoint

      public boolean hasPatternContactPoint()
    • getPatternCount

      public Count getPatternCount() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternCount

      public boolean hasPatternCount()
    • getPatternDistance

      public Distance getPatternDistance() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternDistance

      public boolean hasPatternDistance()
    • getPatternDuration

      public Duration getPatternDuration() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternDuration

      public boolean hasPatternDuration()
    • getPatternHumanName

      public HumanName getPatternHumanName() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternHumanName

      public boolean hasPatternHumanName()
    • getPatternIdentifier

      public Identifier getPatternIdentifier() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternIdentifier

      public boolean hasPatternIdentifier()
    • getPatternMoney

      public Money getPatternMoney() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternMoney

      public boolean hasPatternMoney()
    • getPatternPeriod

      public Period getPatternPeriod() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternPeriod

      public boolean hasPatternPeriod()
    • getPatternQuantity

      public Quantity getPatternQuantity() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternQuantity

      public boolean hasPatternQuantity()
    • getPatternRange

      public Range getPatternRange() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternRange

      public boolean hasPatternRange()
    • getPatternRatio

      public Ratio getPatternRatio() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternRatio

      public boolean hasPatternRatio()
    • getPatternRatioRange

      public RatioRange getPatternRatioRange() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternRatioRange

      public boolean hasPatternRatioRange()
    • getPatternReference

      public Reference getPatternReference() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternReference

      public boolean hasPatternReference()
    • getPatternSampledData

      public SampledData getPatternSampledData() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternSampledData

      public boolean hasPatternSampledData()
    • getPatternSignature

      public Signature getPatternSignature() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternSignature

      public boolean hasPatternSignature()
    • getPatternTiming

      public Timing getPatternTiming() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternTiming

      public boolean hasPatternTiming()
    • getPatternContactDetail

      public ContactDetail getPatternContactDetail() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternContactDetail

      public boolean hasPatternContactDetail()
    • getPatternDataRequirement

      public DataRequirement getPatternDataRequirement() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternDataRequirement

      public boolean hasPatternDataRequirement()
    • getPatternExpression

      public Expression getPatternExpression() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternExpression

      public boolean hasPatternExpression()
    • getPatternParameterDefinition

      public ParameterDefinition getPatternParameterDefinition() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternParameterDefinition

    • getPatternRelatedArtifact

      public RelatedArtifact getPatternRelatedArtifact() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternRelatedArtifact

      public boolean hasPatternRelatedArtifact()
    • getPatternTriggerDefinition

      public TriggerDefinition getPatternTriggerDefinition() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternTriggerDefinition

      public boolean hasPatternTriggerDefinition()
    • getPatternUsageContext

      public UsageContext getPatternUsageContext() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternUsageContext

      public boolean hasPatternUsageContext()
    • getPatternAvailability

      public Availability getPatternAvailability() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternAvailability

      public boolean hasPatternAvailability()
    • getPatternExtendedContactDetail

      public ExtendedContactDetail getPatternExtendedContactDetail() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternExtendedContactDetail

    • getPatternDosage

      public Dosage getPatternDosage() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternDosage

      public boolean hasPatternDosage()
    • getPatternMeta

      public Meta getPatternMeta() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      pattern (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasPatternMeta

      public boolean hasPatternMeta()
    • hasPattern

      public boolean hasPattern()
    • setPattern

      Parameters:
      value - pattern (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.)
    • getExample

      Returns:
      example (A sample value for this element demonstrating the type of information that would typically be found in the element.)
    • setExample

      Returns:
      Returns a reference to this for easy method chaining
    • hasExample

      public boolean hasExample()
    • addExample

    • addExample

    • getExampleFirstRep

      Returns:
      The first repetition of repeating field example, creating it if it does not already exist {3}
    • getMinValue

      Returns:
      minValue (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.)
    • getMinValueDateType

      public DateType getMinValueDateType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      minValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMinValueDateType

      public boolean hasMinValueDateType()
    • getMinValueDateTimeType

      public DateTimeType getMinValueDateTimeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      minValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMinValueDateTimeType

      public boolean hasMinValueDateTimeType()
    • getMinValueInstantType

      public InstantType getMinValueInstantType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      minValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMinValueInstantType

      public boolean hasMinValueInstantType()
    • getMinValueTimeType

      public TimeType getMinValueTimeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      minValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMinValueTimeType

      public boolean hasMinValueTimeType()
    • getMinValueDecimalType

      public DecimalType getMinValueDecimalType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      minValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMinValueDecimalType

      public boolean hasMinValueDecimalType()
    • getMinValueIntegerType

      public IntegerType getMinValueIntegerType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      minValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMinValueIntegerType

      public boolean hasMinValueIntegerType()
    • getMinValueInteger64Type

      public Integer64Type getMinValueInteger64Type() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      minValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMinValueInteger64Type

      public boolean hasMinValueInteger64Type()
    • getMinValuePositiveIntType

      public PositiveIntType getMinValuePositiveIntType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      minValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMinValuePositiveIntType

      public boolean hasMinValuePositiveIntType()
    • getMinValueUnsignedIntType

      public UnsignedIntType getMinValueUnsignedIntType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      minValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMinValueUnsignedIntType

      public boolean hasMinValueUnsignedIntType()
    • getMinValueQuantity

      public Quantity getMinValueQuantity() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      minValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMinValueQuantity

      public boolean hasMinValueQuantity()
    • hasMinValue

      public boolean hasMinValue()
    • setMinValue

      Parameters:
      value - minValue (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.)
    • getMaxValue

      Returns:
      maxValue (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.)
    • getMaxValueDateType

      public DateType getMaxValueDateType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      maxValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMaxValueDateType

      public boolean hasMaxValueDateType()
    • getMaxValueDateTimeType

      public DateTimeType getMaxValueDateTimeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      maxValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMaxValueDateTimeType

      public boolean hasMaxValueDateTimeType()
    • getMaxValueInstantType

      public InstantType getMaxValueInstantType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      maxValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMaxValueInstantType

      public boolean hasMaxValueInstantType()
    • getMaxValueTimeType

      public TimeType getMaxValueTimeType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      maxValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMaxValueTimeType

      public boolean hasMaxValueTimeType()
    • getMaxValueDecimalType

      public DecimalType getMaxValueDecimalType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      maxValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMaxValueDecimalType

      public boolean hasMaxValueDecimalType()
    • getMaxValueIntegerType

      public IntegerType getMaxValueIntegerType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      maxValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMaxValueIntegerType

      public boolean hasMaxValueIntegerType()
    • getMaxValueInteger64Type

      public Integer64Type getMaxValueInteger64Type() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      maxValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMaxValueInteger64Type

      public boolean hasMaxValueInteger64Type()
    • getMaxValuePositiveIntType

      public PositiveIntType getMaxValuePositiveIntType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      maxValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMaxValuePositiveIntType

      public boolean hasMaxValuePositiveIntType()
    • getMaxValueUnsignedIntType

      public UnsignedIntType getMaxValueUnsignedIntType() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      maxValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMaxValueUnsignedIntType

      public boolean hasMaxValueUnsignedIntType()
    • getMaxValueQuantity

      public Quantity getMaxValueQuantity() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      maxValue (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.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • hasMaxValueQuantity

      public boolean hasMaxValueQuantity()
    • hasMaxValue

      public boolean hasMaxValue()
    • setMaxValue

      Parameters:
      value - maxValue (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.)
    • getMaxLengthElement

      Returns:
      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 [Datatype characteristics](extension-structuredefinition-type-characteristics.html)).). This is the underlying object with id, value and extensions. The accessor "getMaxLength" gives direct access to the value
    • hasMaxLengthElement

      public boolean hasMaxLengthElement()
    • hasMaxLength

      public boolean hasMaxLength()
    • setMaxLengthElement

      Parameters:
      value - 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 [Datatype characteristics](extension-structuredefinition-type-characteristics.html)).). This is the underlying object with id, value and extensions. The accessor "getMaxLength" gives direct access to the value
    • getMaxLength

      public int getMaxLength()
      Returns:
      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 [Datatype characteristics](extension-structuredefinition-type-characteristics.html)).
    • setMaxLength

      public ElementDefinition setMaxLength(int value)
      Parameters:
      value - 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 [Datatype characteristics](extension-structuredefinition-type-characteristics.html)).
    • getCondition

      Returns:
      condition (A reference to an invariant that may make additional statements about the cardinality or value in the instance.)
    • setCondition

      public ElementDefinition setCondition(List<IdType> theCondition)
      Returns:
      Returns a reference to this for easy method chaining
    • hasCondition

      public boolean hasCondition()
    • addConditionElement

      Returns:
      condition (A reference to an invariant that may make additional statements about the cardinality or value in the instance.)
    • addCondition

      Parameters:
      value - condition (A reference to an invariant that may make additional statements about the cardinality or value in the instance.)
    • hasCondition

      public boolean hasCondition(String value)
      Parameters:
      value - condition (A reference to an invariant that may make additional statements about the cardinality or value in the instance.)
    • getConstraint

      Returns:
      constraint (Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance.)
    • setConstraint

      Returns:
      Returns a reference to this for easy method chaining
    • hasConstraint

      public boolean hasConstraint()
    • addConstraint

    • addConstraint

    • getConstraintFirstRep

      Returns:
      The first repetition of repeating field constraint, creating it if it does not already exist {3}
    • getMustSupportElement

      Returns:
      mustSupport (If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.). This is the underlying object with id, value and extensions. The accessor "getMustSupport" gives direct access to the value
    • hasMustSupportElement

      public boolean hasMustSupportElement()
    • hasMustSupport

      public boolean hasMustSupport()
    • setMustSupportElement

      Parameters:
      value - mustSupport (If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.). This is the underlying object with id, value and extensions. The accessor "getMustSupport" gives direct access to the value
    • getMustSupport

      public boolean getMustSupport()
      Returns:
      If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.
    • setMustSupport

      public ElementDefinition setMustSupport(boolean value)
      Parameters:
      value - If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.
    • getIsModifierElement

      Returns:
      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.). This is the underlying object with id, value and extensions. The accessor "getIsModifier" gives direct access to the value
    • hasIsModifierElement

      public boolean hasIsModifierElement()
    • hasIsModifier

      public boolean hasIsModifier()
    • setIsModifierElement

      Parameters:
      value - 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.). This is the underlying object with id, value and extensions. The accessor "getIsModifier" gives direct access to the value
    • getIsModifier

      public boolean getIsModifier()
      Returns:
      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.
    • setIsModifier

      public ElementDefinition setIsModifier(boolean value)
      Parameters:
      value - 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.
    • getIsModifierReasonElement

      Returns:
      isModifierReason (Explains how that element affects the interpretation of the resource or element that contains it.). This is the underlying object with id, value and extensions. The accessor "getIsModifierReason" gives direct access to the value
    • hasIsModifierReasonElement

      public boolean hasIsModifierReasonElement()
    • hasIsModifierReason

      public boolean hasIsModifierReason()
    • setIsModifierReasonElement

      Parameters:
      value - isModifierReason (Explains how that element affects the interpretation of the resource or element that contains it.). This is the underlying object with id, value and extensions. The accessor "getIsModifierReason" gives direct access to the value
    • getIsModifierReason

      Returns:
      Explains how that element affects the interpretation of the resource or element that contains it.
    • setIsModifierReason

      Parameters:
      value - Explains how that element affects the interpretation of the resource or element that contains it.
    • getIsSummaryElement

      Returns:
      isSummary (Whether the element should be included if a client requests a search with the parameter _summary=true.). This is the underlying object with id, value and extensions. The accessor "getIsSummary" gives direct access to the value
    • hasIsSummaryElement

      public boolean hasIsSummaryElement()
    • hasIsSummary

      public boolean hasIsSummary()
    • setIsSummaryElement

      Parameters:
      value - isSummary (Whether the element should be included if a client requests a search with the parameter _summary=true.). This is the underlying object with id, value and extensions. The accessor "getIsSummary" gives direct access to the value
    • getIsSummary

      public boolean getIsSummary()
      Returns:
      Whether the element should be included if a client requests a search with the parameter _summary=true.
    • setIsSummary

      public ElementDefinition setIsSummary(boolean value)
      Parameters:
      value - Whether the element should be included if a client requests a search with the parameter _summary=true.
    • getBinding

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

      public boolean hasBinding()
    • setBinding

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

      Returns:
      mapping (Identifies a concept from an external specification that roughly corresponds to this element.)
    • setMapping

      Returns:
      Returns a reference to this for easy method chaining
    • hasMapping

      public boolean hasMapping()
    • addMapping

    • addMapping

    • getMappingFirstRep

      Returns:
      The first repetition of repeating field mapping, creating it if it does not already exist {3}
    • listChildren

      protected void listChildren(List<Property> children)
      Overrides:
      listChildren in class BackboneType
    • getNamedProperty

      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      getNamedProperty in class BackboneType
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • getProperty

      public Base[] getProperty(int hash, String name, boolean checkValid) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      getProperty in class BackboneType
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • setProperty

      public Base setProperty(int hash, String name, Base value) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      setProperty in class BackboneType
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • setProperty

      public Base setProperty(String name, Base value) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      setProperty in class BackboneType
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • makeProperty

      public Base makeProperty(int hash, String name) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      makeProperty in class BackboneType
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • getTypesForProperty

      public String[] getTypesForProperty(int hash, String name) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      getTypesForProperty in class BackboneType
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • addChild

      public Base addChild(String name) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      addChild in class BackboneType
      Throws:
      org.hl7.fhir.exceptions.FHIRException
    • fhirType

      public String fhirType()
      Specified by:
      fhirType in interface org.hl7.fhir.instance.model.api.IBase
      Overrides:
      fhirType in class BackboneType
    • copy

      Specified by:
      copy in class BackboneType
    • copyValues

      public void copyValues(ElementDefinition dst)
    • typedCopy

    • equalsDeep

      public boolean equalsDeep(Base other_)
      Overrides:
      equalsDeep in class BackboneType
    • equalsShallow

      public boolean equalsShallow(Base other_)
      Overrides:
      equalsShallow in class BackboneType
    • isEmpty

      public boolean isEmpty()
      Specified by:
      isEmpty in interface org.hl7.fhir.instance.model.api.IBase
      Overrides:
      isEmpty in class BackboneType
    • toString

      public String toString()
      Overrides:
      toString in class Object
    • makeBase

      public void makeBase(String path, int min, String max)
    • makeBase

      public void makeBase()
    • typeSummary

      public String typeSummary()
    • typeSummaryVB

    • getType

    • present

      public String present()
    • hasCondition

      public boolean hasCondition(IdType id)
    • hasConstraint

      public boolean hasConstraint(String key)
    • hasCode

      public boolean hasCode(Coding c)
    • isChoice

      public boolean isChoice()
    • getName

      public String getName()
    • unbounded

      public boolean unbounded()
    • isMandatory

      public boolean isMandatory()
    • isInlineType

      public boolean isInlineType()
    • prohibited

      public boolean prohibited()
    • hasFixedOrPattern

      public boolean hasFixedOrPattern()
    • getFixedOrPattern

    • isProhibited

      public boolean isProhibited()
    • isRequired

      public boolean isRequired()