ElementDefinition (org.hl7.fhir.r4 5.4.0 API)

java.lang.Object
- org.hl7.fhir.r4.model.Base
- - org.hl7.fhir.r4.model.Element
  - - org.hl7.fhir.r4.model.Type
    - - org.hl7.fhir.r4.model.BackboneType
      - org.hl7.fhir.r4.model.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
```
Captures constraints on each element within the resource, profile, or extension.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ElementDefinition.AggregationMode`
`static class`	`ElementDefinition.AggregationModeEnumFactory`
`static class`	`ElementDefinition.ConstraintSeverity`
`static class`	`ElementDefinition.ConstraintSeverityEnumFactory`
`static class`	`ElementDefinition.DiscriminatorType`
`static class`	`ElementDefinition.DiscriminatorTypeEnumFactory`
`static class`	`ElementDefinition.ElementDefinitionBaseComponent`
`static class`	`ElementDefinition.ElementDefinitionBindingComponent`
`static class`	`ElementDefinition.ElementDefinitionConstraintComponent`
`static class`	`ElementDefinition.ElementDefinitionExampleComponent`
`static class`	`ElementDefinition.ElementDefinitionMappingComponent`
`static class`	`ElementDefinition.ElementDefinitionSlicingComponent`
`static class`	`ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent`
`static class`	`ElementDefinition.PropertyRepresentation`
`static class`	`ElementDefinition.PropertyRepresentationEnumFactory`
`static class`	`ElementDefinition.ReferenceVersionRules`
`static class`	`ElementDefinition.ReferenceVersionRulesEnumFactory`
`static class`	`ElementDefinition.SlicingRules`
`static class`	`ElementDefinition.SlicingRulesEnumFactory`
`static class`	`ElementDefinition.TypeRefComponent`

Field Summary

Fields
Modifier and Type	Field and Description
`protected List<StringType>`	`alias` Identifies additional names by which this element might also be known.
`protected ElementDefinition.ElementDefinitionBaseComponent`	`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.
`protected ElementDefinition.ElementDefinitionBindingComponent`	`binding` Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri).
`protected List<Coding>`	`code` A code that has the same meaning as the element in a particular terminology.
`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.
`protected List<IdType>`	`condition` A reference to an invariant that may make additional statements about the cardinality or value in the instance.
`protected List<ElementDefinition.ElementDefinitionConstraintComponent>`	`constraint` Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance.
`protected UriType`	`contentReference` Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element.
`protected Type`	`defaultValue` The value that should be used if there is no value stated in the instance (e.g.
`protected MarkdownType`	`definition` Provides a complete explanation of the meaning of the data element for human readability.
`protected List<ElementDefinition.ElementDefinitionExampleComponent>`	`example` A sample value for this element demonstrating the type of information that would typically be found in the element.
`protected Type`	`fixed` Specifies a value that SHALL be exactly the value for this element in the instance.
`static boolean`	`IS_IN_SUMMARY`
`static boolean`	`IS_MODIFIER`
`protected BooleanType`	`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.
`protected StringType`	`isModifierReason` Explains how that element affects the interpretation of the resource or element that contains it.
`protected BooleanType`	`isSummary` Whether the element should be included if a client requests a search with the parameter _summary=true.
`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.
`protected List<ElementDefinition.ElementDefinitionMappingComponent>`	`mapping` Identifies a concept from an external specification that roughly corresponds to this element.
`protected StringType`	`max` The maximum number of times this element is permitted to appear in the instance.
`protected IntegerType`	`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.
`protected Type`	`maxValue` The maximum allowed value for the element.
`protected MarkdownType`	`meaningWhenMissing` The Implicit meaning that is to be understood when this element is missing (e.g.
`protected UnsignedIntType`	`min` The minimum number of times this element SHALL appear in the instance.
`protected Type`	`minValue` The minimum allowed value for the element.
`protected BooleanType`	`mustSupport` If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way.
`static boolean`	`NOT_IN_SUMMARY`
`static boolean`	`NOT_MODIFIER`
`protected StringType`	`orderMeaning` If present, indicates that the order of the repeating element has meaning and describes what that meaning is.
`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.
`protected Type`	`pattern` Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance.
`protected List<Enumeration<ElementDefinition.PropertyRepresentation>>`	`representation` Codes that define how this element is represented in instances, when the deviation varies from the normal case.
`protected MarkdownType`	`requirements` This element is for traceability of why the element was created and why the constraints exist as they do.
`protected StringType`	`short_` A concise description of what this element means (e.g.
`protected BooleanType`	`sliceIsConstraining` If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile.
`protected StringType`	`sliceName` The name of this element definition slice, when slicing is working.
`protected ElementDefinition.ElementDefinitionSlicingComponent`	`slicing` Indicates that the element is sliced into a set of alternative definitions (i.e.
`protected List<ElementDefinition.TypeRefComponent>`	`type` The data type or resource that the value of this element is permitted to be.

Fields inherited from class org.hl7.fhir.r4.model.BackboneType
modifierExtension

Fields inherited from class org.hl7.fhir.r4.model.Element
extension, id

Constructor Summary

Constructors
Constructor and Description
`ElementDefinition()` Constructor
`ElementDefinition(boolean defaults, boolean modifier, boolean inSummary)`
`ElementDefinition(StringType path)` Constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ElementDefinition`	`addAlias(String value)`
`StringType`	`addAliasElement()`
`Base`	`addChild(String name)`
`Coding`	`addCode()`
`ElementDefinition`	`addCode(Coding t)`
`ElementDefinition`	`addCondition(String value)`
`IdType`	`addConditionElement()`
`ElementDefinition.ElementDefinitionConstraintComponent`	`addConstraint()`
`ElementDefinition`	`addConstraint(ElementDefinition.ElementDefinitionConstraintComponent t)`
`ElementDefinition.ElementDefinitionExampleComponent`	`addExample()`
`ElementDefinition`	`addExample(ElementDefinition.ElementDefinitionExampleComponent t)`
`ElementDefinition.ElementDefinitionMappingComponent`	`addMapping()`
`ElementDefinition`	`addMapping(ElementDefinition.ElementDefinitionMappingComponent t)`
`ElementDefinition`	`addRepresentation(ElementDefinition.PropertyRepresentation value)`
`Enumeration<ElementDefinition.PropertyRepresentation>`	`addRepresentationElement()`
`ElementDefinition.TypeRefComponent`	`addType()`
`ElementDefinition`	`addType(ElementDefinition.TypeRefComponent t)`
`ElementDefinition`	`copy()`
`void`	`copyValues(ElementDefinition dst)`
`boolean`	`equalsDeep(Base other_)`
`boolean`	`equalsShallow(Base other_)`
`String`	`fhirType()`
`List<StringType>`	`getAlias()`
`ElementDefinition.ElementDefinitionBaseComponent`	`getBase()`
`ElementDefinition.ElementDefinitionBindingComponent`	`getBinding()`
`List<Coding>`	`getCode()`
`Coding`	`getCodeFirstRep()`
`String`	`getComment()`
`MarkdownType`	`getCommentElement()`
`List<IdType>`	`getCondition()`
`List<ElementDefinition.ElementDefinitionConstraintComponent>`	`getConstraint()`
`ElementDefinition.ElementDefinitionConstraintComponent`	`getConstraintFirstRep()`
`String`	`getContentReference()`
`UriType`	`getContentReferenceElement()`
`Type`	`getDefaultValue()`
`String`	`getDefinition()`
`MarkdownType`	`getDefinitionElement()`
`List<ElementDefinition.ElementDefinitionExampleComponent>`	`getExample()`
`ElementDefinition.ElementDefinitionExampleComponent`	`getExampleFirstRep()`
`Type`	`getFixed()`
`boolean`	`getIsModifier()`
`BooleanType`	`getIsModifierElement()`
`String`	`getIsModifierReason()`
`StringType`	`getIsModifierReasonElement()`
`boolean`	`getIsSummary()`
`BooleanType`	`getIsSummaryElement()`
`String`	`getLabel()`
`StringType`	`getLabelElement()`
`List<ElementDefinition.ElementDefinitionMappingComponent>`	`getMapping()`
`ElementDefinition.ElementDefinitionMappingComponent`	`getMappingFirstRep()`
`String`	`getMax()`
`StringType`	`getMaxElement()`
`int`	`getMaxLength()`
`IntegerType`	`getMaxLengthElement()`
`Type`	`getMaxValue()`
`DateTimeType`	`getMaxValueDateTimeType()`
`DateType`	`getMaxValueDateType()`
`DecimalType`	`getMaxValueDecimalType()`
`InstantType`	`getMaxValueInstantType()`
`IntegerType`	`getMaxValueIntegerType()`
`PositiveIntType`	`getMaxValuePositiveIntType()`
`Quantity`	`getMaxValueQuantity()`
`TimeType`	`getMaxValueTimeType()`
`UnsignedIntType`	`getMaxValueUnsignedIntType()`
`String`	`getMeaningWhenMissing()`
`MarkdownType`	`getMeaningWhenMissingElement()`
`int`	`getMin()`
`UnsignedIntType`	`getMinElement()`
`Type`	`getMinValue()`
`DateTimeType`	`getMinValueDateTimeType()`
`DateType`	`getMinValueDateType()`
`DecimalType`	`getMinValueDecimalType()`
`InstantType`	`getMinValueInstantType()`
`IntegerType`	`getMinValueIntegerType()`
`PositiveIntType`	`getMinValuePositiveIntType()`
`Quantity`	`getMinValueQuantity()`
`TimeType`	`getMinValueTimeType()`
`UnsignedIntType`	`getMinValueUnsignedIntType()`
`boolean`	`getMustSupport()`
`BooleanType`	`getMustSupportElement()`
`Property`	`getNamedProperty(int _hash, String _name, boolean _checkValid)`
`String`	`getOrderMeaning()`
`StringType`	`getOrderMeaningElement()`
`String`	`getPath()`
`StringType`	`getPathElement()`
`Type`	`getPattern()`
`Base[]`	`getProperty(int hash, String name, boolean checkValid)`
`List<Enumeration<ElementDefinition.PropertyRepresentation>>`	`getRepresentation()`
`String`	`getRequirements()`
`MarkdownType`	`getRequirementsElement()`
`String`	`getShort()`
`StringType`	`getShortElement()`
`boolean`	`getSliceIsConstraining()`
`BooleanType`	`getSliceIsConstrainingElement()`
`String`	`getSliceName()`
`StringType`	`getSliceNameElement()`
`ElementDefinition.ElementDefinitionSlicingComponent`	`getSlicing()`
`List<ElementDefinition.TypeRefComponent>`	`getType()`
`ElementDefinition.TypeRefComponent`	`getType(String code)`
`ElementDefinition.TypeRefComponent`	`getTypeFirstRep()`
`String[]`	`getTypesForProperty(int hash, String name)`
`boolean`	`hasAlias()`
`boolean`	`hasAlias(String value)`
`boolean`	`hasBase()`
`boolean`	`hasBinding()`
`boolean`	`hasCode()`
`boolean`	`hasComment()`
`boolean`	`hasCommentElement()`
`boolean`	`hasCondition()`
`boolean`	`hasCondition(String value)`
`boolean`	`hasConstraint()`
`boolean`	`hasContentReference()`
`boolean`	`hasContentReferenceElement()`
`boolean`	`hasDefaultValue()`
`boolean`	`hasDefinition()`
`boolean`	`hasDefinitionElement()`
`boolean`	`hasExample()`
`boolean`	`hasFixed()`
`boolean`	`hasIsModifier()`
`boolean`	`hasIsModifierElement()`
`boolean`	`hasIsModifierReason()`
`boolean`	`hasIsModifierReasonElement()`
`boolean`	`hasIsSummary()`
`boolean`	`hasIsSummaryElement()`
`boolean`	`hasLabel()`
`boolean`	`hasLabelElement()`
`boolean`	`hasMapping()`
`boolean`	`hasMax()`
`boolean`	`hasMaxElement()`
`boolean`	`hasMaxLength()`
`boolean`	`hasMaxLengthElement()`
`boolean`	`hasMaxValue()`
`boolean`	`hasMaxValueDateTimeType()`
`boolean`	`hasMaxValueDateType()`
`boolean`	`hasMaxValueDecimalType()`
`boolean`	`hasMaxValueInstantType()`
`boolean`	`hasMaxValueIntegerType()`
`boolean`	`hasMaxValuePositiveIntType()`
`boolean`	`hasMaxValueQuantity()`
`boolean`	`hasMaxValueTimeType()`
`boolean`	`hasMaxValueUnsignedIntType()`
`boolean`	`hasMeaningWhenMissing()`
`boolean`	`hasMeaningWhenMissingElement()`
`boolean`	`hasMin()`
`boolean`	`hasMinElement()`
`boolean`	`hasMinValue()`
`boolean`	`hasMinValueDateTimeType()`
`boolean`	`hasMinValueDateType()`
`boolean`	`hasMinValueDecimalType()`
`boolean`	`hasMinValueInstantType()`
`boolean`	`hasMinValueIntegerType()`
`boolean`	`hasMinValuePositiveIntType()`
`boolean`	`hasMinValueQuantity()`
`boolean`	`hasMinValueTimeType()`
`boolean`	`hasMinValueUnsignedIntType()`
`boolean`	`hasMustSupport()`
`boolean`	`hasMustSupportElement()`
`boolean`	`hasOrderMeaning()`
`boolean`	`hasOrderMeaningElement()`
`boolean`	`hasPath()`
`boolean`	`hasPathElement()`
`boolean`	`hasPattern()`
`boolean`	`hasRepresentation()`
`boolean`	`hasRepresentation(ElementDefinition.PropertyRepresentation value)`
`boolean`	`hasRequirements()`
`boolean`	`hasRequirementsElement()`
`boolean`	`hasShort()`
`boolean`	`hasShortElement()`
`boolean`	`hasSliceIsConstraining()`
`boolean`	`hasSliceIsConstrainingElement()`
`boolean`	`hasSliceName()`
`boolean`	`hasSliceNameElement()`
`boolean`	`hasSlicing()`
`boolean`	`hasType()`
`boolean`	`isEmpty()`
`protected void`	`listChildren(List<Property> children)`
`void`	`makeBase()`
`void`	`makeBase(String path, int min, String max)`
`Base`	`makeProperty(int hash, String name)`
`String`	`present()`
`ElementDefinition`	`setAlias(List<StringType> theAlias)`
`ElementDefinition`	`setBase(ElementDefinition.ElementDefinitionBaseComponent value)`
`ElementDefinition`	`setBinding(ElementDefinition.ElementDefinitionBindingComponent value)`
`ElementDefinition`	`setCode(List<Coding> theCode)`
`ElementDefinition`	`setComment(String value)`
`ElementDefinition`	`setCommentElement(MarkdownType value)`
`ElementDefinition`	`setCondition(List<IdType> theCondition)`
`ElementDefinition`	`setConstraint(List<ElementDefinition.ElementDefinitionConstraintComponent> theConstraint)`
`ElementDefinition`	`setContentReference(String value)`
`ElementDefinition`	`setContentReferenceElement(UriType value)`
`ElementDefinition`	`setDefaultValue(Type value)`
`ElementDefinition`	`setDefinition(String value)`
`ElementDefinition`	`setDefinitionElement(MarkdownType value)`
`ElementDefinition`	`setExample(List<ElementDefinition.ElementDefinitionExampleComponent> theExample)`
`ElementDefinition`	`setFixed(Type value)`
`ElementDefinition`	`setIsModifier(boolean value)`
`ElementDefinition`	`setIsModifierElement(BooleanType value)`
`ElementDefinition`	`setIsModifierReason(String value)`
`ElementDefinition`	`setIsModifierReasonElement(StringType value)`
`ElementDefinition`	`setIsSummary(boolean value)`
`ElementDefinition`	`setIsSummaryElement(BooleanType value)`
`ElementDefinition`	`setLabel(String value)`
`ElementDefinition`	`setLabelElement(StringType value)`
`ElementDefinition`	`setMapping(List<ElementDefinition.ElementDefinitionMappingComponent> theMapping)`
`ElementDefinition`	`setMax(String value)`
`ElementDefinition`	`setMaxElement(StringType value)`
`ElementDefinition`	`setMaxLength(int value)`
`ElementDefinition`	`setMaxLengthElement(IntegerType value)`
`ElementDefinition`	`setMaxValue(Type value)`
`ElementDefinition`	`setMeaningWhenMissing(String value)`
`ElementDefinition`	`setMeaningWhenMissingElement(MarkdownType value)`
`ElementDefinition`	`setMin(int value)`
`ElementDefinition`	`setMinElement(UnsignedIntType value)`
`ElementDefinition`	`setMinValue(Type value)`
`ElementDefinition`	`setMustSupport(boolean value)`
`ElementDefinition`	`setMustSupportElement(BooleanType value)`
`ElementDefinition`	`setOrderMeaning(String value)`
`ElementDefinition`	`setOrderMeaningElement(StringType value)`
`ElementDefinition`	`setPath(String value)`
`ElementDefinition`	`setPathElement(StringType value)`
`ElementDefinition`	`setPattern(Type value)`
`Base`	`setProperty(int hash, String name, Base value)`
`Base`	`setProperty(String name, Base value)`
`ElementDefinition`	`setRepresentation(List<Enumeration<ElementDefinition.PropertyRepresentation>> theRepresentation)`
`ElementDefinition`	`setRequirements(String value)`
`ElementDefinition`	`setRequirementsElement(MarkdownType value)`
`ElementDefinition`	`setShort(String value)`
`ElementDefinition`	`setShortElement(StringType value)`
`ElementDefinition`	`setSliceIsConstraining(boolean value)`
`ElementDefinition`	`setSliceIsConstrainingElement(BooleanType value)`
`ElementDefinition`	`setSliceName(String value)`
`ElementDefinition`	`setSliceNameElement(StringType value)`
`ElementDefinition`	`setSlicing(ElementDefinition.ElementDefinitionSlicingComponent value)`
`ElementDefinition`	`setType(List<ElementDefinition.TypeRefComponent> theType)`
`String`	`toString()`
`protected ElementDefinition`	`typedCopy()`
`String`	`typeSummary()`

Methods inherited from class org.hl7.fhir.r4.model.BackboneType
addModifierExtension, addModifierExtension, checkNoModifiers, copyValues, getModifierExtension, getModifierExtensionFirstRep, hasModifierExtension, setModifierExtension

Methods inherited from class org.hl7.fhir.r4.model.Element
addExtension, addExtension, addExtension, copyValues, getExtension, getExtensionByUrl, getExtensionFirstRep, getExtensionsByUrl, getExtensionString, getId, getIdBase, getIdElement, hasExtension, hasExtension, hasId, hasIdElement, isDisallowExtensions, noExtensions, removeExtension, setDisallowExtensions, setExtension, setId, setIdBase, setIdElement

Methods inherited from class org.hl7.fhir.r4.model.Base
castToAddress, castToAnnotation, castToAttachment, castToBase64Binary, castToBoolean, castToCanonical, castToCode, castToCodeableConcept, castToCoding, castToContactDetail, castToContactPoint, castToContributor, castToDataRequirement, castToDate, castToDateTime, castToDecimal, castToDosage, castToDuration, castToElementDefinition, castToExpression, castToExtension, castToHumanName, castToId, castToIdentifier, castToInstant, castToInteger, castToMarkdown, castToMarketingStatus, castToMeta, castToMoney, castToNarrative, castToOid, castToParameterDefinition, castToPeriod, castToPopulation, castToPositiveInt, castToProdCharacteristic, castToProductShelfLife, castToQuantity, castToRange, castToRatio, castToReference, castToRelatedArtifact, castToResource, castToSampledData, castToSignature, castToSimpleQuantity, castToString, castToSubstanceAmount, castToTime, castToTiming, castToTriggerDefinition, castToType, castToUnsignedInt, castToUri, castToUrl, castToUsageContext, castToXhtml, castToXhtmlString, children, clearUserData, compareDeep, compareDeep, compareDeep, compareDeep, compareValues, compareValues, dateTimeValue, equals, getChildByName, getFormatCommentsPost, getFormatCommentsPre, getNamedProperty, getUserData, getUserInt, getUserString, hasFormatComment, hasPrimitiveValue, hasType, hasUserData, isBooleanPrimitive, isDateTime, isMetadataBased, isPrimitive, isResource, listChildrenByName, listChildrenByName, primitiveValue, setUserData, setUserDataINN

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.hl7.fhir.instance.model.api.IBase
getFormatCommentsPost, getFormatCommentsPre, getUserData, hasFormatComment, setUserData

Methods inherited from interface org.hl7.fhir.instance.model.api.IBaseHasExtensions
addExtension, getExtension, hasExtension

Methods inherited from interface org.hl7.fhir.instance.model.api.IBaseElement
getUserData, setUserData

- Field Detail
  - 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
```
protected List<Enumeration<ElementDefinition.PropertyRepresentation>> representation
```
    Codes that define how this element is represented in instances, when the deviation varies from the normal case.
  - 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
```
protected BooleanType 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
```
protected ElementDefinition.ElementDefinitionSlicingComponent 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
```
protected MarkdownType 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
```
protected MarkdownType 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
```
protected ElementDefinition.ElementDefinitionBaseComponent 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
```
protected UriType 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
```
protected List<ElementDefinition.TypeRefComponent> type
```
    The data type or resource that the value of this element is permitted to be.
  - defaultValue
```
protected Type 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
```
protected MarkdownType 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
```
protected StringType 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 Type fixed
```
    Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.
  - pattern
```
protected Type pattern
```
    Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 1. If primitive: it must match exactly the pattern value 2. If a complex object: it must match (recursively) the pattern value 3. If an array: it must match (recursively) the pattern value.
  - example
```
protected List<ElementDefinition.ElementDefinitionExampleComponent> example
```
    A sample value for this element demonstrating the type of information that would typically be found in the element.
  - minValue
```
protected Type 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 Type 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
```
protected IntegerType 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.
  - condition
```
protected List<IdType> condition
```
    A reference to an invariant that may make additional statements about the cardinality or value in the instance.
  - constraint
```
protected List<ElementDefinition.ElementDefinitionConstraintComponent> constraint
```
    Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance.
  - mustSupport
```
protected BooleanType 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
```
protected BooleanType 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
```
protected StringType isModifierReason
```
    Explains how that element affects the interpretation of the resource or element that contains it.
  - isSummary
```
protected BooleanType isSummary
```
    Whether the element should be included if a client requests a search with the parameter _summary=true.
  - binding
```
protected ElementDefinition.ElementDefinitionBindingComponent binding
```
    Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri).
  - mapping
```
protected List<ElementDefinition.ElementDefinitionMappingComponent> mapping
```
    Identifies a concept from an external specification that roughly corresponds to this element.
  - NOT_MODIFIER
```
public static final boolean NOT_MODIFIER
```
    See Also:
    
    Constant Field Values
  - NOT_IN_SUMMARY
```
public static final boolean NOT_IN_SUMMARY
```
    See Also:
    
    Constant Field Values
  - IS_MODIFIER
```
public static final boolean IS_MODIFIER
```
    See Also:
    
    Constant Field Values
  - IS_IN_SUMMARY
```
public static final boolean IS_IN_SUMMARY
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ElementDefinition
```
public ElementDefinition()
```
    Constructor
  - ElementDefinition
```
public ElementDefinition(StringType path)
```
    Constructor
  - ElementDefinition
```
public ElementDefinition(boolean defaults,
                         boolean modifier,
                         boolean inSummary)
```
- Method Detail
  - getPathElement
```
public StringType 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
```
public ElementDefinition setPathElement(StringType value)
```
    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
```
public ElementDefinition setPath(String value)
```
    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
```
public List<Enumeration<ElementDefinition.PropertyRepresentation>> getRepresentation()
```
    Returns:
    
    representation (Codes that define how this element is represented in instances, when the deviation varies from the normal case.)
  - setRepresentation
```
public ElementDefinition setRepresentation(List<Enumeration<ElementDefinition.PropertyRepresentation>> theRepresentation)
```
    Returns:
    
    Returns a reference to this for easy method chaining
  - hasRepresentation
```
public boolean hasRepresentation()
```
  - addRepresentationElement
```
public Enumeration<ElementDefinition.PropertyRepresentation> addRepresentationElement()
```
    Returns:
    
    representation (Codes that define how this element is represented in instances, when the deviation varies from the normal case.)
  - addRepresentation
```
public ElementDefinition addRepresentation(ElementDefinition.PropertyRepresentation value)
```
    Parameters:
    
    value - representation (Codes that define how this element is represented in instances, when the deviation varies from the normal case.)
  - hasRepresentation
```
public boolean hasRepresentation(ElementDefinition.PropertyRepresentation value)
```
    Parameters:
    
    value - representation (Codes that define how this element is represented in instances, when the deviation varies from the normal case.)
  - getSliceNameElement
```
public StringType 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
```
public ElementDefinition setSliceNameElement(StringType value)
```
    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
```
public ElementDefinition setSliceName(String value)
```
    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
```
public BooleanType 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
```
public boolean hasSliceIsConstrainingElement()
```
  - hasSliceIsConstraining
```
public boolean hasSliceIsConstraining()
```
  - setSliceIsConstrainingElement
```
public ElementDefinition setSliceIsConstrainingElement(BooleanType value)
```
    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
```
public StringType 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
```
public ElementDefinition setLabelElement(StringType value)
```
    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
```
public ElementDefinition setLabel(String value)
```
    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
```
public ElementDefinition addCode(Coding t)
```
  - getCodeFirstRep
```
public Coding getCodeFirstRep()
```
    Returns:
    
    The first repetition of repeating field code, creating it if it does not already exist
  - getSlicing
```
public ElementDefinition.ElementDefinitionSlicingComponent 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
```
public ElementDefinition setSlicing(ElementDefinition.ElementDefinitionSlicingComponent value)
```
    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
```
public StringType 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
```
public ElementDefinition setShortElement(StringType value)
```
    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
```
public ElementDefinition setShort(String value)
```
    Parameters:
    
    value - A concise description of what this element means (e.g. for use in autogenerated summaries).
  - getDefinitionElement
```
public MarkdownType 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
```
public ElementDefinition setDefinitionElement(MarkdownType value)
```
    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
```
public String 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
```
public ElementDefinition setDefinition(String value)
```
    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
```
public MarkdownType 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
```
public ElementDefinition setCommentElement(MarkdownType value)
```
    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
```
public ElementDefinition setComment(String value)
```
    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
```
public MarkdownType 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
```
public ElementDefinition setRequirementsElement(MarkdownType value)
```
    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
```
public String 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
```
public ElementDefinition setRequirements(String value)
```
    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
```
public List<StringType> getAlias()
```
    Returns:
    
    alias (Identifies additional names by which this element might also be known.)
  - setAlias
```
public ElementDefinition setAlias(List<StringType> theAlias)
```
    Returns:
    
    Returns a reference to this for easy method chaining
  - hasAlias
```
public boolean hasAlias()
```
  - addAliasElement
```
public StringType addAliasElement()
```
    Returns:
    
    alias (Identifies additional names by which this element might also be known.)
  - addAlias
```
public ElementDefinition addAlias(String value)
```
    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
```
public UnsignedIntType 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
```
public ElementDefinition setMinElement(UnsignedIntType value)
```
    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
```
public StringType 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
```
public ElementDefinition setMaxElement(StringType value)
```
    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
```
public ElementDefinition setMax(String value)
```
    Parameters:
    
    value - The maximum number of times this element is permitted to appear in the instance.
  - getBase
```
public ElementDefinition.ElementDefinitionBaseComponent 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
```
public ElementDefinition setBase(ElementDefinition.ElementDefinitionBaseComponent value)
```
    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
```
public UriType 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
```
public ElementDefinition setContentReferenceElement(UriType value)
```
    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
```
public String 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
```
public ElementDefinition setContentReference(String value)
```
    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
```
public List<ElementDefinition.TypeRefComponent> getType()
```
    Returns:
    
    type (The data type or resource that the value of this element is permitted to be.)
  - setType
```
public ElementDefinition setType(List<ElementDefinition.TypeRefComponent> theType)
```
    Returns:
    
    Returns a reference to this for easy method chaining
  - hasType
```
public boolean hasType()
```
  - addType
```
public ElementDefinition.TypeRefComponent addType()
```
  - addType
```
public ElementDefinition addType(ElementDefinition.TypeRefComponent t)
```
  - getTypeFirstRep
```
public ElementDefinition.TypeRefComponent getTypeFirstRep()
```
    Returns:
    
    The first repetition of repeating field type, creating it if it does not already exist
  - getDefaultValue
```
public Type 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').)
  - hasDefaultValue
```
public boolean hasDefaultValue()
```
  - setDefaultValue
```
public ElementDefinition setDefaultValue(Type value)
```
    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
```
public MarkdownType 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
```
public ElementDefinition setMeaningWhenMissingElement(MarkdownType value)
```
    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
```
public String 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
```
public ElementDefinition setMeaningWhenMissing(String value)
```
    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
```
public StringType 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
```
public ElementDefinition setOrderMeaningElement(StringType value)
```
    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
```
public String 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
```
public ElementDefinition setOrderMeaning(String value)
```
    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 Type getFixed()
```
    Returns:
    
    fixed (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
  - hasFixed
```
public boolean hasFixed()
```
  - setFixed
```
public ElementDefinition setFixed(Type value)
```
    Parameters:
    
    value - fixed (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
  - getPattern
```
public Type getPattern()
```
    Returns:
    
    pattern (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 1. If primitive: it must match exactly the pattern value 2. If a complex object: it must match (recursively) the pattern value 3. If an array: it must match (recursively) the pattern value.)
  - hasPattern
```
public boolean hasPattern()
```
  - setPattern
```
public ElementDefinition setPattern(Type value)
```
    Parameters:
    
    value - pattern (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 1. If primitive: it must match exactly the pattern value 2. If a complex object: it must match (recursively) the pattern value 3. If an array: it must match (recursively) the pattern value.)
  - getExample
```
public List<ElementDefinition.ElementDefinitionExampleComponent> getExample()
```
    Returns:
    
    example (A sample value for this element demonstrating the type of information that would typically be found in the element.)
  - setExample
```
public ElementDefinition setExample(List<ElementDefinition.ElementDefinitionExampleComponent> theExample)
```
    Returns:
    
    Returns a reference to this for easy method chaining
  - hasExample
```
public boolean hasExample()
```
  - addExample
```
public ElementDefinition.ElementDefinitionExampleComponent addExample()
```
  - addExample
```
public ElementDefinition addExample(ElementDefinition.ElementDefinitionExampleComponent t)
```
  - getExampleFirstRep
```
public ElementDefinition.ElementDefinitionExampleComponent getExampleFirstRep()
```
    Returns:
    
    The first repetition of repeating field example, creating it if it does not already exist
  - getMinValue
```
public Type 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()
```
  - 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
```
public ElementDefinition setMinValue(Type value)
```
    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
```
public Type 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()
```
  - 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
```
public ElementDefinition setMaxValue(Type value)
```
    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
```
public IntegerType 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.). 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
```
public ElementDefinition setMaxLengthElement(IntegerType value)
```
    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.). 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.
  - 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.
  - getCondition
```
public List<IdType> 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
```
public IdType addConditionElement()
```
    Returns:
    
    condition (A reference to an invariant that may make additional statements about the cardinality or value in the instance.)
  - addCondition
```
public ElementDefinition addCondition(String value)
```
    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
```
public List<ElementDefinition.ElementDefinitionConstraintComponent> getConstraint()
```
    Returns:
    
    constraint (Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance.)
  - setConstraint
```
public ElementDefinition setConstraint(List<ElementDefinition.ElementDefinitionConstraintComponent> theConstraint)
```
    Returns:
    
    Returns a reference to this for easy method chaining
  - hasConstraint
```
public boolean hasConstraint()
```
  - addConstraint
```
public ElementDefinition.ElementDefinitionConstraintComponent addConstraint()
```
  - addConstraint
```
public ElementDefinition addConstraint(ElementDefinition.ElementDefinitionConstraintComponent t)
```
  - getConstraintFirstRep
```
public ElementDefinition.ElementDefinitionConstraintComponent getConstraintFirstRep()
```
    Returns:
    
    The first repetition of repeating field constraint, creating it if it does not already exist
  - getMustSupportElement
```
public BooleanType 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
```
public ElementDefinition setMustSupportElement(BooleanType value)
```
    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
```
public BooleanType 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
```
public ElementDefinition setIsModifierElement(BooleanType value)
```
    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
```
public StringType 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
```
public ElementDefinition setIsModifierReasonElement(StringType value)
```
    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
```
public String getIsModifierReason()
```
    Returns:
    
    Explains how that element affects the interpretation of the resource or element that contains it.
  - setIsModifierReason
```
public ElementDefinition setIsModifierReason(String value)
```
    Parameters:
    
    value - Explains how that element affects the interpretation of the resource or element that contains it.
  - getIsSummaryElement
```
public BooleanType 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
```
public ElementDefinition setIsSummaryElement(BooleanType value)
```
    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
```
public ElementDefinition.ElementDefinitionBindingComponent 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
```
public ElementDefinition setBinding(ElementDefinition.ElementDefinitionBindingComponent value)
```
    Parameters:
    
    value - binding (Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri).)
  - getMapping
```
public List<ElementDefinition.ElementDefinitionMappingComponent> getMapping()
```
    Returns:
    
    mapping (Identifies a concept from an external specification that roughly corresponds to this element.)
  - setMapping
```
public ElementDefinition setMapping(List<ElementDefinition.ElementDefinitionMappingComponent> theMapping)
```
    Returns:
    
    Returns a reference to this for easy method chaining
  - hasMapping
```
public boolean hasMapping()
```
  - addMapping
```
public ElementDefinition.ElementDefinitionMappingComponent addMapping()
```
  - addMapping
```
public ElementDefinition addMapping(ElementDefinition.ElementDefinitionMappingComponent t)
```
  - getMappingFirstRep
```
public ElementDefinition.ElementDefinitionMappingComponent getMappingFirstRep()
```
    Returns:
    
    The first repetition of repeating field mapping, creating it if it does not already exist
  - 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
```
public ElementDefinition copy()
```
    Specified by:
    
    copy in class BackboneType
  - copyValues
```
public void copyValues(ElementDefinition dst)
```
  - typedCopy
```
protected ElementDefinition typedCopy()
```
    Specified by:
    
    typedCopy in class Type
  - 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()
```
  - getType
```
public ElementDefinition.TypeRefComponent getType(String code)
```
  - present
```
public String present()
```

Class ElementDefinition

Nested Class Summary

Field Summary

Fields inherited from class org.hl7.fhir.r4.model.BackboneType

Fields inherited from class org.hl7.fhir.r4.model.Element

Constructor Summary

Method Summary

Methods inherited from class org.hl7.fhir.r4.model.BackboneType

Methods inherited from class org.hl7.fhir.r4.model.Element

Methods inherited from class org.hl7.fhir.r4.model.Base

Methods inherited from class java.lang.Object

Methods inherited from interface org.hl7.fhir.instance.model.api.IBase

Methods inherited from interface org.hl7.fhir.instance.model.api.IBaseHasExtensions

Methods inherited from interface org.hl7.fhir.instance.model.api.IBaseElement

Field Detail

path

representation

sliceName

sliceIsConstraining

label

code

slicing

short_

definition

comment

requirements

alias

min

max

base

contentReference

type

defaultValue

meaningWhenMissing

orderMeaning

fixed

pattern

example

minValue

maxValue

maxLength

condition

constraint

mustSupport

isModifier

isModifierReason

isSummary

binding

mapping

NOT_MODIFIER

NOT_IN_SUMMARY

IS_MODIFIER

IS_IN_SUMMARY

Constructor Detail

ElementDefinition

ElementDefinition

ElementDefinition

Method Detail

getPathElement

hasPathElement

hasPath

setPathElement

getPath

setPath

getRepresentation

setRepresentation

hasRepresentation

addRepresentationElement

addRepresentation

hasRepresentation

getSliceNameElement

hasSliceNameElement

hasSliceName

setSliceNameElement

getSliceName

setSliceName

getSliceIsConstrainingElement

hasSliceIsConstrainingElement

hasSliceIsConstraining

setSliceIsConstrainingElement