### ----------------------------------------------------
### -- FHIR
### -- Licenses: Artistic-2.0
### -- Authors: Hugh Simpson
### -- File: t/resources/structureDefinition/elementDefinition.json
### ----------------------------------------------------
### -- Chunk 5 of 7
 recommended.).",
        "requirements": "May also be used for code generation purposes.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "v2",
            "map": "N/A"
          },
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.sliceIsConstraining",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status",
            "valueCode": "trial-use"
          }
        ],
        "path": "ElementDefinition.sliceIsConstraining",
        "short": "If this slice definition constrains an inherited slice definition (or not)",
        "definition": "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.",
        "comment": "If set to true, an ancestor profile SHALL have a slicing definition with this name.  If set to false, no ancestor profile is permitted to have a slicing definition with this name.",
        "requirements": "Allows detection of a situation where an ancestor profile adds or removes slicing with the same name where that might impact the child profile.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "boolean"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "v2",
            "map": "N/A"
          },
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.label",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
            "valueBoolean": true
          }
        ],
        "path": "ElementDefinition.label",
        "short": "Name for element to display with or prompt for element",
        "definition": "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.",
        "comment": "See also the extension (http://hl7.org/fhir/StructureDefinition/elementdefinition-question)[extension-elementdefinition-question.html].",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "./code/display"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.code",
        "path": "ElementDefinition.code",
        "short": "Corresponding codes in terminologies",
        "definition": "A code that has the same meaning as the element in a particular terminology.",
        "comment": "The concept SHALL be properly aligned with the data element definition and other constraints, as defined in the code system, including relationships, of any code listed here.  Where multiple codes exist in a terminology that could correspond to the data element, the most granular code(s) should be selected, so long as they are not more restrictive than the data element itself. The mappings may be used to provide more or less granular or structured equivalences in the code system.",
        "requirements": "Links the meaning of an element to an external terminology, and is very useful for searching and indexing.",
        "min": 0,
        "max": "*",
        "type": [
          {
            "code": "Coding"
          }
        ],
        "isSummary": true,
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "ElementDefinitionCode"
            }
          ],
          "strength": "example",
          "description": "Codes that indicate the meaning of a data element.",
          "valueSet": "http://hl7.org/fhir/ValueSet/observation-codes"
        },
        "mapping": [
          {
            "identity": "v2",
            "map": "OM1.7"
          },
          {
            "identity": "rim",
            "map": "./code (root or translation)"
          },
          {
            "identity": "iso11179",
            "map": "(Data_Element).data_element_concept.identifier"
          },
          {
            "identity": "loinc",
            "map": "LOINC_NUM"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing",
        "path": "ElementDefinition.slicing",
        "short": "This element is sliced - slices follow",
        "definition": "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).",
        "comment": "The first element in the sequence, the one that carries the slicing, is the definition that applies to all the slices. This is based on the unconstrained element, but can apply any constraints as appropriate. This may include the common constraints on the children of the element.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "Element"
          }
        ],
        "constraint": [
          {
            "key": "eld-1",
            "severity": "error",
            "human": "If there are no discriminators, there must be a definition",
            "expression": "discriminator.exists() or description.exists()",
            "xpath": "(f:discriminator) or (f:description)"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing.discriminator",
        "path": "ElementDefinition.slicing.discriminator",
        "short": "Element values that are used to distinguish the slices",
        "definition": "Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices.",
        "comment": "If there is no discriminator, the content is hard to process, so this should be avoided.",
        "min": 0,
        "max": "*",
        "type": [
          {
            "code": "Element"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing.discriminator.type",
        "path": "ElementDefinition.slicing.discriminator.type",
        "short": "value | exists | pattern | type | profile",
        "definition": "How the element value is interpreted when discrimination is evaluated.",
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "code"
          }
        ],
        "isSummary": true,
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "DiscriminatorType"
            }
          ],
          "strength": "required",
          "description": "How an element value is interpreted when discrimination is evaluated.",
          "valueSet": "http://hl7.org/fhir/ValueSet/discriminator-type|4.0.0"
        },
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing.discriminator.path",
        "path": "ElementDefinition.slicing.discriminator.path",
        "short": "Path to element value",
        "definition": "A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.",
        "comment": "The only FHIRPath functions that are allowed are as(type), resolve(), and extension(url).",
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing.description",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
            "valueBoolean": true
          }
        ],
        "path": "ElementDefinition.slicing.description",
        "short": "Text description of how slicing works (or not)",
        "definition": "A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.",
        "comment": "If it's really not possible to differentiate them, the design should be re-evaluated to make the content usable.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "condition": [
          "eld-1"
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing.ordered",
        "path": "ElementDefinition.slicing.ordered",
        "short": "If elements must be in same order as slices",
        "definition": "If the matching elements have to occur in the same order as defined in the profile.",
        "comment": "Order should only be required when it is a pressing concern for presentation. Profile authors should consider making the order a feature of the rules about the narrative, not the rules about the data - requiring ordered data makes the profile much less re-usable.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "boolean"
          }
        ],
        "meaningWhenMissing": "Order is not required unless specified",
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing.rules",
        "path": "ElementDefinition.slicing.rules",
        "short": "closed | open | openAtEnd",
        "definition": "Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.",
        "comment": "Allowing additional elements makes for a much for flexible template - it's open for use in wider contexts, but also means that the content of the resource is not closed, and applications have to decide how to handle content not described by the profile.",
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "code"
          }
        ],
        "isSummary": true,
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "SlicingRules"
            }
          ],
          "strength": "required",
          "description": "How slices are interpreted when evaluating an instance.",
          "valueSet": "http://hl7.org/fhir/ValueSet/resource-slicing-rules|4.0.0"
        },
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.short",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
            "valueBoolean": true
          }
        ],
        "path": "ElementDefinition.short",
        "short": "Concise definition for space-constrained presentation",
        "definition": "A concise description of what this element means (e.g. for use in autogenerated summaries).",
        "comment": "It is easy for a different short definition to change the meaning of an element and this can have nasty downstream consequences. Please be careful when providing short definitions in a profile.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "N/A"
          }
        ]
      },
      {
        "id": "ElementDefinition.definition",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
            "valueBoolean": true
          }
        ],
        "path": "ElementDefinition.definition",
        "short": "Full formal definition as narrative text",
        "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": "It is easy for a different definition to change the meaning of an element and this can have nasty downstream consequences. Please be careful when providing definitions in a profile.",
        "requirements": "To allow a user to state the usage of an element in a particular context.",
        "alias": [
          "Description"
        ],
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "markdown"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "v2",
            "map": "OM1.6, OM1.41"
          },
          {
            "identity": "rim",
            "map": "./text"
          },
          {
            "identity": "iso11179",
            "map": "(Designatable_Item).definition.text  acceptability=preferred in default context"
          },
          {
            "identity": "loinc",
            "map": "TERM DEFINITION/DESCRIPTION(S)"
          }
        ]
      },
      {
        "id": "ElementDefinition.comment",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
            "valueBoolean": true
          }
        ],
        "path": "ElementDefinition.comment",
        "short": "Comments about the use of this element",
        "definition": "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).",
        "comment": "If it is possible to capture usage rules using constraints, that mechanism should be used in preference to this element.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "markdown"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "v2",
            "map": "NTE, OM1.32, OM1.33, OM1.39"
          },
          {
            "identity": "rim",
            "map": "./inboundRelationship[typeCode=SUBJ]/source[classCode=LIST, moodCode=EVN]/code"
          },
          {
            "identity": "iso11179",
            "map": "(Administered_Item).explanatory_comment"
          },
          {
            "identity": "loinc",
            "map": "COMMENTS"
          }
        ]
      },
      {
        "id": "ElementDefinition.requirements",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
            "valueBoolean": true
          }
        ],
        "path": "ElementDefinition.requirements",
        "short": "Why this resource has been created",
        "definition": "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.",
        "comment": "This element does not describe the usage of the element (that's done in comments), rather it's for traceability of *why* the element is either needed or why the constraints exist as they do.  This may be used to point to source materials or specifications that drove the structure of this data element.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "markdown"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "./inboundRelationship[typeCode=META]/source[classCode=ACT, moodCode=EVN, isCriterionInd=true]/reasonCode/originalText"
          },
          {
            "identity": "iso11179",
            "map": "(Registered_item).document_reference[document_type=requirements].notation"
          }
        ]
      },
      {
        "id": "ElementDefinition.alias",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
            "valueBoolean": true
          }
        ],
        "path": "ElementDefinition.alias",
        "short": "Other names",
        "definition": "Identifies additional names by which this element might also be known.",
        "requirements": "Allows for better easier recognition of the element by multiple communities, including international communities.",
        "alias": [
          "synonym",
          "other name"
        ],
        "min": 0,
        "max": "*",
        "type": [
          {
            "code": "string"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "v2",
            "map": "OM1.8, OM1.52"
          },
          {
            "identity": "rim",
            "map": "Not currently expressible"
          },
          {
            "identity": "iso11179",
            "map": "(Designatable_Item).designation.sign  acceptability!=preferred or context is other than default"
          },
          {
            "identity": "loinc",
            "map": "RELATED NAMES (only some of these apply)"
          }
        ]
      },
      {
        "id": "ElementDefinition.min",
        "path": "ElementDefinition.min",
        "short": "Minimum Cardinality",
        "definition": "The minimum number of times this element SHALL appear in the instance.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "unsignedInt"
          }
        ],
        "condition": [
          "eld-2"
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "Minimum  size of  data element  values?"
          }
        ]
      },
      {
        "id": "ElementDefinition.max",
        "path": "ElementDefinition.max",
        "short": "Maximum Cardinality (a number or *)",
        "definition": "The maximum number of times this element is permitted to appear in the instance.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "condition": [
          "eld-3",
          "eld-2"
        ],
        "constraint": [
          {
            "key": "eld-3",
            "severity": "error",
            "human": "Max SHALL be a number or \"*\"",
            "expression": "empty() or ($this = '*') or (toInteger() >= 0)",
            "xpath": "@value='*' or (normalize-space(@value)!='' and normalize-space(translate(@value, '0123456789',''))='')"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "v2",
            "map": "OMC.10"
          },
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "Maximum  size of  data element  values?"
          }
        ]
      },
      {
        "id": "ElementDefinition.base",
        "path": "ElementDefinition.base",
        "short": "Base definition information for tools",
        "definition": "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.",
        "comment": "The base information does not carry any information that could not be determined from the path and related profiles, but making this determination requires both that the related profiles are available, and that the algorithm to determine them be available. For tooling simplicity, the base information must always be populated in element definitions in snap shots, even if it is the same.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "Element"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.base.path",
        "path": "ElementDefinition.base.path",
        "short": "Path that identifies the base element",
        "definition": "The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.",
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.base.min",
        "path": "ElementDefinition.base.min",
        "short": "Min cardinality of the base element",
        "definition": "Minimum cardinality of the base element identified by the path.",
        "comment": "This is provided for consistency with max, and may affect code generation of mandatory elements of the base resource are generated differently (some reference implementations have done this).",
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "unsignedInt"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.base.max",
        "path": "ElementDefinition.base.max",
        "short": "Max cardinality of the base element",
        "definition": "Maximum cardinality of the base element identified by the path.",
        "comment": "This is provided to code generation, since the serialization representation in JSON differs depending on whether the base element has max > 1. Also, some forms of code generation may differ.",
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.contentReference",
        "path": "ElementDefinition.contentReference",
        "short": "Reference to definition of content for the element",
        "definition": "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.",
        "comment": "ContentReferences can only be defined in specializations, not constrained types, and they cannot be changed and always reference the non-constrained definition.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "uri"
          }
        ],
        "condition": [
          "eld-5"
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          }
        ]
      },
      {
        "id": "ElementDefinition.type",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
            "valueString": "TypeRef"
          }
        ],
        "path": "ElementDefinition.type",
        "short": "Data type and Profile for this element",
        "definition": "The data type or resource that the value of this element is permitted to be.",
        "comment": "The Type of the element can be left blank in a differential constraint, in which case the type is inherited from the resource. Abstract types are not permitted to appear as a type when multiple types are listed.  (I.e. Abstract types cannot be part of a choice).",
        "min": 0,
        "max": "*",
        "type": [
          {
            "code": "Element"
          }
        ],
        "condition": [
          "eld-13"
        ],
        "constraint": [
          {
            "key": "eld-4",
            "severity": "error",
            "human": "Aggregation may only be specified if one of the allowed types for the element is a reference",
            "expression": "aggregation.empty() or (code = 'Reference')",
            "xpath": "not(exists(f:aggregation)) or exists(f:code[@value = 'Reference'])"
          },
          {
            "key": "eld-17",
            "severity": "error",
            "human": "targetProfile is only allowed if the type is Reference or canonical",
            "expression": "(code='Reference' or code = 'canonical') or targetProfile.empty()",
            "xpath": "not(exists(f:targetProfile)) or (f:code/@value = 'Reference')"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "v2",
            "map": "OM1.3, OMC.9"
          },
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": ".domain.data+Q14type"
          },
          {
            "identity": "dex",
            "map": "valueDomain.dataType"
          },
          {
            "identity": "loinc",
            "map": "HL7_V2_DATATYPE (translation required), HL7_V3_DATATYPE (translation required)"
          }
        ]
      },
      {
        "id": "ElementDefinition.type.code",
        "path": "ElementDefinition.type.code",
        "short": "Data type or Resource (reference to definition)",
        "definition": "URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. \"string\" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.",
        "comment": "If the element is a reference to another resource, this element contains \"Reference\", and the targetProfile element defines what resources can be referenced. The targetProfile may be a reference to the general definition of a resource (e.g. http://hl7.org/fhir/StructureDefinition/Patient).",
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "uri"
          }
        ],
        "isSummary": true,
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "FHIRDefinedTypeExt"
            }
          ],
          "strength": "extensible",
          "description": "Either a resource or a data type, including logical model types.",
          "valueSet": "http://hl7.org/fhir/ValueSet/defined-types"
        },
        "mapping": [
          {
            "identity": "v2",
            "map": "OM1.3"
          },
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": ".domain.data+Q14type"
          },
          {
            "identity": "loinc",
            "map": "HL7_V2_DATATYPE (translation required), HL7_V3_DATATYPE (translation required)"
          }
        ]
      },
      {
        "id": "ElementDefinition.type.profile",
        "path": "ElementDefinition.type.profile",
        "short": "Profiles (StructureDefinition or IG) - one must apply",
        "definition": "Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.",
        "comment": "It is possible to profile  backbone element (e.g. part of a resource), using the [profile-element](extension-elementdefinition-profile-element.html) extension.",
        "min": 0,
        "max": "*",
        "type": [
          {
            "code": "canonical",
            "targetProfile": [
              "http://hl7.org/fhir/StructureDefinition/StructureDefinition",
              "http://hl7.org/fhir/StructureDefinition/ImplementationGuide"
            ]
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.type.targetProfile",
        "path": "ElementDefinition.type.targetProfile",
        "short": "Profile (StructureDefinition or IG) on the Reference/canonical target - one must apply",
        "definition": "Used when the type is \"Reference\" or \"canonical\", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.",
        "min": 0,
        "max": "*",
        "type": [
          {
            "code": "canonical",
            "targetProfile": [
              "http://hl7.org/fhir/StructureDefinition/StructureDefinition",
              "http://hl7.org/fhir/StructureDefinition/ImplementationGuide"
            ]
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.type.aggregation",
        "path": "ElementDefinition.type.aggregation",
        "short": "contained | referenced | bundled - how aggregated",
        "definition": "If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.",
        "comment": "See [Aggregation Rules](elementdefinition.html#aggregation) for further clarification.",
        "min": 0,
        "max": "*",
        "type": [
          {
            "code": "code"
          }
        ],
        "condition": [
          "eld-4"
        ],
        "isSummary": true,
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "AggregationMode"
            }
          ],
          "strength": "required",
          "description": "How resource references can be aggregated.",
          "valueSet": "http://hl7.org/fhir/ValueSet/resource-aggregation-mode|4.0.0"
        },
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.type.versioning",
        "path": "ElementDefinition.type.versioning",
        "short": "either | independent | specific",
        "definition": "Whether this reference needs to be version specific or version independent, or whether either can be used.",
        "comment": "The base specification never makes a rule as to which form is allowed, but implementation guides may do this. See [Aggregation Rules](elementdefinition.html#aggregation) for further clarification.",
        "min": 0,
        "max": "1",
        "type": [
          {
            "code": "code"
          }
        ],
        "isSummary": true,
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "ReferenceVersionRules"
            }
          ],
          "strength": "required",
          "description": "Whether a reference needs to be version specific or version independent, or whether either can be used.",
          "valueSet": "http://hl7.org/fhir/ValueSet/reference-version-rules|4.0.0"
        },
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          }
        ]
      },
      {
        "id": "ElementDefinition.defaultValue[x]",
        "path": "ElementDefinition.defaultValue[x]",
        "short": "Specified value if missing from instance",
        "definition": "The value that should be used if there is no value stated in the