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

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class	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	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 DataType`	`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 DataType`	`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 DataType`	`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 DataType`	`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 DataType`	`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.r5.model.BackboneType
modifierExtension

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

Constructor Summary

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

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	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()`
`DataType`	`getDefaultValue()`
`Address`	`getDefaultValueAddress()`
`Age`	`getDefaultValueAge()`
`Annotation`	`getDefaultValueAnnotation()`
`Attachment`	`getDefaultValueAttachment()`
`Base64BinaryType`	`getDefaultValueBase64BinaryType()`
`BooleanType`	`getDefaultValueBooleanType()`
`CanonicalType`	`getDefaultValueCanonicalType()`
`CodeableConcept`	`getDefaultValueCodeableConcept()`
`CodeableReference`	`getDefaultValueCodeableReference()`
`CodeType`	`getDefaultValueCodeType()`
`Coding`	`getDefaultValueCoding()`
`ContactDetail`	`getDefaultValueContactDetail()`
`ContactPoint`	`getDefaultValueContactPoint()`
`Contributor`	`getDefaultValueContributor()`
`Count`	`getDefaultValueCount()`
`DataRequirement`	`getDefaultValueDataRequirement()`
`DateTimeType`	`getDefaultValueDateTimeType()`
`DateType`	`getDefaultValueDateType()`
`DecimalType`	`getDefaultValueDecimalType()`
`Distance`	`getDefaultValueDistance()`
`Dosage`	`getDefaultValueDosage()`
`Duration`	`getDefaultValueDuration()`
`Expression`	`getDefaultValueExpression()`
`HumanName`	`getDefaultValueHumanName()`
`Identifier`	`getDefaultValueIdentifier()`
`IdType`	`getDefaultValueIdType()`
`InstantType`	`getDefaultValueInstantType()`
`Integer64Type`	`getDefaultValueInteger64Type()`
`IntegerType`	`getDefaultValueIntegerType()`
`MarkdownType`	`getDefaultValueMarkdownType()`
`Meta`	`getDefaultValueMeta()`
`Money`	`getDefaultValueMoney()`
`OidType`	`getDefaultValueOidType()`
`ParameterDefinition`	`getDefaultValueParameterDefinition()`
`Period`	`getDefaultValuePeriod()`
`PositiveIntType`	`getDefaultValuePositiveIntType()`
`Quantity`	`getDefaultValueQuantity()`
`Range`	`getDefaultValueRange()`
`Ratio`	`getDefaultValueRatio()`
`RatioRange`	`getDefaultValueRatioRange()`
`Reference`	`getDefaultValueReference()`
`RelatedArtifact`	`getDefaultValueRelatedArtifact()`
`SampledData`	`getDefaultValueSampledData()`
`Signature`	`getDefaultValueSignature()`
`StringType`	`getDefaultValueStringType()`
`TimeType`	`getDefaultValueTimeType()`
`Timing`	`getDefaultValueTiming()`
`TriggerDefinition`	`getDefaultValueTriggerDefinition()`
`UnsignedIntType`	`getDefaultValueUnsignedIntType()`
`UriType`	`getDefaultValueUriType()`
`UrlType`	`getDefaultValueUrlType()`
`UsageContext`	`getDefaultValueUsageContext()`
`UuidType`	`getDefaultValueUuidType()`
`String`	`getDefinition()`
`MarkdownType`	`getDefinitionElement()`
`List<ElementDefinition.ElementDefinitionExampleComponent>`	`getExample()`
`ElementDefinition.ElementDefinitionExampleComponent`	`getExampleFirstRep()`
`DataType`	`getFixed()`
`Address`	`getFixedAddress()`
`Age`	`getFixedAge()`
`Annotation`	`getFixedAnnotation()`
`Attachment`	`getFixedAttachment()`
`Base64BinaryType`	`getFixedBase64BinaryType()`
`BooleanType`	`getFixedBooleanType()`
`CanonicalType`	`getFixedCanonicalType()`
`CodeableConcept`	`getFixedCodeableConcept()`
`CodeableReference`	`getFixedCodeableReference()`
`CodeType`	`getFixedCodeType()`
`Coding`	`getFixedCoding()`
`ContactDetail`	`getFixedContactDetail()`
`ContactPoint`	`getFixedContactPoint()`
`Contributor`	`getFixedContributor()`
`Count`	`getFixedCount()`
`DataRequirement`	`getFixedDataRequirement()`
`DateTimeType`	`getFixedDateTimeType()`
`DateType`	`getFixedDateType()`
`DecimalType`	`getFixedDecimalType()`
`Distance`	`getFixedDistance()`
`Dosage`	`getFixedDosage()`
`Duration`	`getFixedDuration()`
`Expression`	`getFixedExpression()`
`HumanName`	`getFixedHumanName()`
`Identifier`	`getFixedIdentifier()`
`IdType`	`getFixedIdType()`
`InstantType`	`getFixedInstantType()`
`Integer64Type`	`getFixedInteger64Type()`
`IntegerType`	`getFixedIntegerType()`
`MarkdownType`	`getFixedMarkdownType()`
`Meta`	`getFixedMeta()`
`Money`	`getFixedMoney()`
`OidType`	`getFixedOidType()`
`ParameterDefinition`	`getFixedParameterDefinition()`
`Period`	`getFixedPeriod()`
`PositiveIntType`	`getFixedPositiveIntType()`
`Quantity`	`getFixedQuantity()`
`Range`	`getFixedRange()`
`Ratio`	`getFixedRatio()`
`RatioRange`	`getFixedRatioRange()`
`Reference`	`getFixedReference()`
`RelatedArtifact`	`getFixedRelatedArtifact()`
`SampledData`	`getFixedSampledData()`
`Signature`	`getFixedSignature()`
`StringType`	`getFixedStringType()`
`TimeType`	`getFixedTimeType()`
`Timing`	`getFixedTiming()`
`TriggerDefinition`	`getFixedTriggerDefinition()`
`UnsignedIntType`	`getFixedUnsignedIntType()`
`UriType`	`getFixedUriType()`
`UrlType`	`getFixedUrlType()`
`UsageContext`	`getFixedUsageContext()`
`UuidType`	`getFixedUuidType()`
`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()`
`DataType`	`getMaxValue()`
`DateTimeType`	`getMaxValueDateTimeType()`
`DateType`	`getMaxValueDateType()`
`DecimalType`	`getMaxValueDecimalType()`
`InstantType`	`getMaxValueInstantType()`
`Integer64Type`	`getMaxValueInteger64Type()`
`IntegerType`	`getMaxValueIntegerType()`
`PositiveIntType`	`getMaxValuePositiveIntType()`
`Quantity`	`getMaxValueQuantity()`
`TimeType`	`getMaxValueTimeType()`
`UnsignedIntType`	`getMaxValueUnsignedIntType()`
`String`	`getMeaningWhenMissing()`
`MarkdownType`	`getMeaningWhenMissingElement()`
`int`	`getMin()`
`UnsignedIntType`	`getMinElement()`
`DataType`	`getMinValue()`
`DateTimeType`	`getMinValueDateTimeType()`
`DateType`	`getMinValueDateType()`
`DecimalType`	`getMinValueDecimalType()`
`InstantType`	`getMinValueInstantType()`
`Integer64Type`	`getMinValueInteger64Type()`
`IntegerType`	`getMinValueIntegerType()`
`PositiveIntType`	`getMinValuePositiveIntType()`
`Quantity`	`getMinValueQuantity()`
`TimeType`	`getMinValueTimeType()`
`UnsignedIntType`	`getMinValueUnsignedIntType()`
`boolean`	`getMustSupport()`
`BooleanType`	`getMustSupportElement()`
`String`	`getName()`
`Property`	`getNamedProperty(int _hash, String _name, boolean _checkValid)`
`String`	`getOrderMeaning()`
`StringType`	`getOrderMeaningElement()`
`String`	`getPath()`
`StringType`	`getPathElement()`
`DataType`	`getPattern()`
`Address`	`getPatternAddress()`
`Age`	`getPatternAge()`
`Annotation`	`getPatternAnnotation()`
`Attachment`	`getPatternAttachment()`
`Base64BinaryType`	`getPatternBase64BinaryType()`
`BooleanType`	`getPatternBooleanType()`
`CanonicalType`	`getPatternCanonicalType()`
`CodeableConcept`	`getPatternCodeableConcept()`
`CodeableReference`	`getPatternCodeableReference()`
`CodeType`	`getPatternCodeType()`
`Coding`	`getPatternCoding()`
`ContactDetail`	`getPatternContactDetail()`
`ContactPoint`	`getPatternContactPoint()`
`Contributor`	`getPatternContributor()`
`Count`	`getPatternCount()`
`DataRequirement`	`getPatternDataRequirement()`
`DateTimeType`	`getPatternDateTimeType()`
`DateType`	`getPatternDateType()`
`DecimalType`	`getPatternDecimalType()`
`Distance`	`getPatternDistance()`
`Dosage`	`getPatternDosage()`
`Duration`	`getPatternDuration()`
`Expression`	`getPatternExpression()`
`HumanName`	`getPatternHumanName()`
`Identifier`	`getPatternIdentifier()`
`IdType`	`getPatternIdType()`
`InstantType`	`getPatternInstantType()`
`Integer64Type`	`getPatternInteger64Type()`
`IntegerType`	`getPatternIntegerType()`
`MarkdownType`	`getPatternMarkdownType()`
`Meta`	`getPatternMeta()`
`Money`	`getPatternMoney()`
`OidType`	`getPatternOidType()`
`ParameterDefinition`	`getPatternParameterDefinition()`
`Period`	`getPatternPeriod()`
`PositiveIntType`	`getPatternPositiveIntType()`
`Quantity`	`getPatternQuantity()`
`Range`	`getPatternRange()`
`Ratio`	`getPatternRatio()`
`RatioRange`	`getPatternRatioRange()`
`Reference`	`getPatternReference()`
`RelatedArtifact`	`getPatternRelatedArtifact()`
`SampledData`	`getPatternSampledData()`
`Signature`	`getPatternSignature()`
`StringType`	`getPatternStringType()`
`TimeType`	`getPatternTimeType()`
`Timing`	`getPatternTiming()`
`TriggerDefinition`	`getPatternTriggerDefinition()`
`UnsignedIntType`	`getPatternUnsignedIntType()`
`UriType`	`getPatternUriType()`
`UrlType`	`getPatternUrlType()`
`UsageContext`	`getPatternUsageContext()`
`UuidType`	`getPatternUuidType()`
`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`	`hasCode(Coding c)`
`boolean`	`hasComment()`
`boolean`	`hasCommentElement()`
`boolean`	`hasCondition()`
`boolean`	`hasCondition(String value)`
`boolean`	`hasCondition(IdType id)`
`boolean`	`hasConstraint()`
`boolean`	`hasConstraint(String key)`
`boolean`	`hasContentReference()`
`boolean`	`hasContentReferenceElement()`
`boolean`	`hasDefaultValue()`
`boolean`	`hasDefaultValueAddress()`
`boolean`	`hasDefaultValueAge()`
`boolean`	`hasDefaultValueAnnotation()`
`boolean`	`hasDefaultValueAttachment()`
`boolean`	`hasDefaultValueBase64BinaryType()`
`boolean`	`hasDefaultValueBooleanType()`
`boolean`	`hasDefaultValueCanonicalType()`
`boolean`	`hasDefaultValueCodeableConcept()`
`boolean`	`hasDefaultValueCodeableReference()`
`boolean`	`hasDefaultValueCodeType()`
`boolean`	`hasDefaultValueCoding()`
`boolean`	`hasDefaultValueContactDetail()`
`boolean`	`hasDefaultValueContactPoint()`
`boolean`	`hasDefaultValueContributor()`
`boolean`	`hasDefaultValueCount()`
`boolean`	`hasDefaultValueDataRequirement()`
`boolean`	`hasDefaultValueDateTimeType()`
`boolean`	`hasDefaultValueDateType()`
`boolean`	`hasDefaultValueDecimalType()`
`boolean`	`hasDefaultValueDistance()`
`boolean`	`hasDefaultValueDosage()`
`boolean`	`hasDefaultValueDuration()`
`boolean`	`hasDefaultValueExpression()`
`boolean`	`hasDefaultValueHumanName()`
`boolean`	`hasDefaultValueIdentifier()`
`boolean`	`hasDefaultValueIdType()`
`boolean`	`hasDefaultValueInstantType()`
`boolean`	`hasDefaultValueInteger64Type()`
`boolean`	`hasDefaultValueIntegerType()`
`boolean`	`hasDefaultValueMarkdownType()`
`boolean`	`hasDefaultValueMeta()`
`boolean`	`hasDefaultValueMoney()`
`boolean`	`hasDefaultValueOidType()`
`boolean`	`hasDefaultValueParameterDefinition()`
`boolean`	`hasDefaultValuePeriod()`
`boolean`	`hasDefaultValuePositiveIntType()`
`boolean`	`hasDefaultValueQuantity()`
`boolean`	`hasDefaultValueRange()`
`boolean`	`hasDefaultValueRatio()`
`boolean`	`hasDefaultValueRatioRange()`
`boolean`	`hasDefaultValueReference()`
`boolean`	`hasDefaultValueRelatedArtifact()`
`boolean`	`hasDefaultValueSampledData()`
`boolean`	`hasDefaultValueSignature()`
`boolean`	`hasDefaultValueStringType()`
`boolean`	`hasDefaultValueTimeType()`
`boolean`	`hasDefaultValueTiming()`
`boolean`	`hasDefaultValueTriggerDefinition()`
`boolean`	`hasDefaultValueUnsignedIntType()`
`boolean`	`hasDefaultValueUriType()`
`boolean`	`hasDefaultValueUrlType()`
`boolean`	`hasDefaultValueUsageContext()`
`boolean`	`hasDefaultValueUuidType()`
`boolean`	`hasDefinition()`
`boolean`	`hasDefinitionElement()`
`boolean`	`hasExample()`
`boolean`	`hasFixed()`
`boolean`	`hasFixedAddress()`
`boolean`	`hasFixedAge()`
`boolean`	`hasFixedAnnotation()`
`boolean`	`hasFixedAttachment()`
`boolean`	`hasFixedBase64BinaryType()`
`boolean`	`hasFixedBooleanType()`
`boolean`	`hasFixedCanonicalType()`
`boolean`	`hasFixedCodeableConcept()`
`boolean`	`hasFixedCodeableReference()`
`boolean`	`hasFixedCodeType()`
`boolean`	`hasFixedCoding()`
`boolean`	`hasFixedContactDetail()`
`boolean`	`hasFixedContactPoint()`
`boolean`	`hasFixedContributor()`
`boolean`	`hasFixedCount()`
`boolean`	`hasFixedDataRequirement()`
`boolean`	`hasFixedDateTimeType()`
`boolean`	`hasFixedDateType()`
`boolean`	`hasFixedDecimalType()`
`boolean`	`hasFixedDistance()`
`boolean`	`hasFixedDosage()`
`boolean`	`hasFixedDuration()`
`boolean`	`hasFixedExpression()`
`boolean`	`hasFixedHumanName()`
`boolean`	`hasFixedIdentifier()`
`boolean`	`hasFixedIdType()`
`boolean`	`hasFixedInstantType()`
`boolean`	`hasFixedInteger64Type()`
`boolean`	`hasFixedIntegerType()`
`boolean`	`hasFixedMarkdownType()`
`boolean`	`hasFixedMeta()`
`boolean`	`hasFixedMoney()`
`boolean`	`hasFixedOidType()`
`boolean`	`hasFixedParameterDefinition()`
`boolean`	`hasFixedPeriod()`
`boolean`	`hasFixedPositiveIntType()`
`boolean`	`hasFixedQuantity()`
`boolean`	`hasFixedRange()`
`boolean`	`hasFixedRatio()`
`boolean`	`hasFixedRatioRange()`
`boolean`	`hasFixedReference()`
`boolean`	`hasFixedRelatedArtifact()`
`boolean`	`hasFixedSampledData()`
`boolean`	`hasFixedSignature()`
`boolean`	`hasFixedStringType()`
`boolean`	`hasFixedTimeType()`
`boolean`	`hasFixedTiming()`
`boolean`	`hasFixedTriggerDefinition()`
`boolean`	`hasFixedUnsignedIntType()`
`boolean`	`hasFixedUriType()`
`boolean`	`hasFixedUrlType()`
`boolean`	`hasFixedUsageContext()`
`boolean`	`hasFixedUuidType()`
`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`	`hasMaxValueInteger64Type()`
`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`	`hasMinValueInteger64Type()`
`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`	`hasPatternAddress()`
`boolean`	`hasPatternAge()`
`boolean`	`hasPatternAnnotation()`
`boolean`	`hasPatternAttachment()`
`boolean`	`hasPatternBase64BinaryType()`
`boolean`	`hasPatternBooleanType()`
`boolean`	`hasPatternCanonicalType()`
`boolean`	`hasPatternCodeableConcept()`
`boolean`	`hasPatternCodeableReference()`
`boolean`	`hasPatternCodeType()`
`boolean`	`hasPatternCoding()`
`boolean`	`hasPatternContactDetail()`
`boolean`	`hasPatternContactPoint()`
`boolean`	`hasPatternContributor()`
`boolean`	`hasPatternCount()`
`boolean`	`hasPatternDataRequirement()`
`boolean`	`hasPatternDateTimeType()`
`boolean`	`hasPatternDateType()`
`boolean`	`hasPatternDecimalType()`
`boolean`	`hasPatternDistance()`
`boolean`	`hasPatternDosage()`
`boolean`	`hasPatternDuration()`
`boolean`	`hasPatternExpression()`
`boolean`	`hasPatternHumanName()`
`boolean`	`hasPatternIdentifier()`
`boolean`	`hasPatternIdType()`
`boolean`	`hasPatternInstantType()`
`boolean`	`hasPatternInteger64Type()`
`boolean`	`hasPatternIntegerType()`
`boolean`	`hasPatternMarkdownType()`
`boolean`	`hasPatternMeta()`
`boolean`	`hasPatternMoney()`
`boolean`	`hasPatternOidType()`
`boolean`	`hasPatternParameterDefinition()`
`boolean`	`hasPatternPeriod()`
`boolean`	`hasPatternPositiveIntType()`
`boolean`	`hasPatternQuantity()`
`boolean`	`hasPatternRange()`
`boolean`	`hasPatternRatio()`
`boolean`	`hasPatternRatioRange()`
`boolean`	`hasPatternReference()`
`boolean`	`hasPatternRelatedArtifact()`
`boolean`	`hasPatternSampledData()`
`boolean`	`hasPatternSignature()`
`boolean`	`hasPatternStringType()`
`boolean`	`hasPatternTimeType()`
`boolean`	`hasPatternTiming()`
`boolean`	`hasPatternTriggerDefinition()`
`boolean`	`hasPatternUnsignedIntType()`
`boolean`	`hasPatternUriType()`
`boolean`	`hasPatternUrlType()`
`boolean`	`hasPatternUsageContext()`
`boolean`	`hasPatternUuidType()`
`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`	`isChoice()`
`boolean`	`isEmpty()`
`boolean`	`isInlineType()`
`boolean`	`isMandatory()`
`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(DataType value)`
`ElementDefinition`	`setDefinition(String value)`
`ElementDefinition`	`setDefinitionElement(MarkdownType value)`
`ElementDefinition`	`setExample(List<ElementDefinition.ElementDefinitionExampleComponent> theExample)`
`ElementDefinition`	`setFixed(DataType 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(DataType value)`
`ElementDefinition`	`setMeaningWhenMissing(String value)`
`ElementDefinition`	`setMeaningWhenMissingElement(MarkdownType value)`
`ElementDefinition`	`setMin(int value)`
`ElementDefinition`	`setMinElement(UnsignedIntType value)`
`ElementDefinition`	`setMinValue(DataType 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(DataType 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()`
`String`	`typeSummaryVB()`
`boolean`	`unbounded()`

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

Methods inherited from class org.hl7.fhir.r5.model.DataType
copyValues

Methods inherited from class org.hl7.fhir.r5.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.r5.model.Base
children, clearUserData, compareDeep, compareDeep, compareDeep, compareDeep, compareValues, compareValues, copyUserData, copyValues, dateTimeValue, equals, getChildByName, getFormatCommentsPost, getFormatCommentsPre, getNamedProperty, getUserData, getUserInt, getUserString, getXhtml, 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.IBaseElement
getUserData, setUserData

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

- 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 DataType 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 DataType 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 DataType 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 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
```
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(String 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 {3}
  - 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 {3}
  - getDefaultValue
```
public DataType 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
```
public boolean 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
```
public boolean 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
```
public boolean 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
```
public boolean 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
```
public boolean 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()
```
  - getDefaultValueContributor
```
public Contributor getDefaultValueContributor()
                                       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
  - hasDefaultValueContributor
```
public boolean hasDefaultValueContributor()
```
  - 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
```
public boolean 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
```
public boolean 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
```
public boolean 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
```
public boolean 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()
```
  - 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
```
public ElementDefinition setDefaultValue(DataType 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 DataType 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.)
  - 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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()
```
  - getFixedContributor
```
public Contributor getFixedContributor()
                                throws org.hl7.fhir.exceptions.FHIRException
```
    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.)
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - hasFixedContributor
```
public boolean hasFixedContributor()
```
  - 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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. For purposes of comparison, 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()
```
  - 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. For purposes of comparison, 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. For purposes of comparison, 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
```
public ElementDefinition setFixed(DataType 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 DataType 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.)
  - getPatternBase64BinaryType
```
public Base64BinaryType getPatternBase64BinaryType()
                                            throws org.hl7.fhir.exceptions.FHIRException
```
    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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    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 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.)
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - hasPatternContactDetail
```
public boolean hasPatternContactDetail()
```
  - getPatternContributor
```
public Contributor getPatternContributor()
                                  throws org.hl7.fhir.exceptions.FHIRException
```
    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.)
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - hasPatternContributor
```
public boolean hasPatternContributor()
```
  - getPatternDataRequirement
```
public DataRequirement getPatternDataRequirement()
                                          throws org.hl7.fhir.exceptions.FHIRException
```
    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.)
    
    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 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.)
    
    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 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.)
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - hasPatternParameterDefinition
```
public boolean hasPatternParameterDefinition()
```
  - getPatternRelatedArtifact
```
public RelatedArtifact getPatternRelatedArtifact()
                                          throws org.hl7.fhir.exceptions.FHIRException
```
    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.)
    
    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 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.)
    
    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 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.)
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - hasPatternUsageContext
```
public boolean hasPatternUsageContext()
```
  - getPatternDosage
```
public Dosage getPatternDosage()
                        throws org.hl7.fhir.exceptions.FHIRException
```
    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.)
    
    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 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.)
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - hasPatternMeta
```
public boolean hasPatternMeta()
```
  - hasPattern
```
public boolean hasPattern()
```
  - setPattern
```
public ElementDefinition setPattern(DataType 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 {3}
  - getMinValue
```
public DataType 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
```
public ElementDefinition setMinValue(DataType 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 DataType 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
```
public ElementDefinition setMaxValue(DataType 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 {3}
  - 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 {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
```
public ElementDefinition copy()
```
    Specified by:
    
    copy in class BackboneType
  - copyValues
```
public void copyValues(ElementDefinition dst)
```
  - typedCopy
```
protected ElementDefinition 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
```
public String typeSummaryVB()
```
  - getType
```
public ElementDefinition.TypeRefComponent getType(String code)
```
  - 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()
```

Class ElementDefinition

Nested Class Summary

Field Summary

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

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

Constructor Summary

Method Summary

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

Methods inherited from class org.hl7.fhir.r5.model.DataType

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

Methods inherited from class org.hl7.fhir.r5.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.IBaseElement

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

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