### ----------------------------------------------------
### -- FHIR
### -- Licenses: Artistic-2.0
### -- Authors: Hugh Simpson
### -- File: t/resources/structureDefinition/elementDefinition.json
### ----------------------------------------------------
### -- Chunk 1 of 7
{
  "resourceType": "StructureDefinition",
  "id": "ElementDefinition",
  "text": {
    "status": "generated",
    "div": "<div>stubbed</div>"
  },
  "extension": [
    {
      "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status",
      "valueCode": "normative"
    },
    {
      "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version",
      "valueCode": "4.0.0"
    }
  ],
  "url": "http://hl7.org/fhir/StructureDefinition/ElementDefinition",
  "version": "4.0.0",
  "name": "ElementDefinition",
  "status": "active",
  "date": "2018-12-27T22:37:54+11:00",
  "publisher": "HL7 FHIR Standard",
  "contact": [
    {
      "telecom": [
        {
          "system": "url",
          "value": "http://hl7.org/fhir"
        }
      ]
    }
  ],
  "description": "Base StructureDefinition for ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension.",
  "fhirVersion": "4.0.0",
  "mapping": [
    {
      "identity": "v2",
      "uri": "http://hl7.org/v2",
      "name": "HL7 v2 Mapping"
    },
    {
      "identity": "rim",
      "uri": "http://hl7.org/v3",
      "name": "RIM Mapping"
    },
    {
      "identity": "iso11179",
      "uri": "http://metadata-standards.org/11179/",
      "name": "ISO 11179"
    },
    {
      "identity": "dex",
      "uri": "http://ihe.net/data-element-exchange",
      "name": "IHE Data Element Exchange (DEX)"
    },
    {
      "identity": "loinc",
      "uri": "http://loinc.org",
      "name": "LOINC code for the element"
    }
  ],
  "kind": "complex-type",
  "abstract": false,
  "type": "ElementDefinition",
  "baseDefinition": "http://hl7.org/fhir/StructureDefinition/BackboneElement",
  "derivation": "specialization",
  "snapshot": {
    "element": [
      {
        "id": "ElementDefinition",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status",
            "valueCode": "normative"
          },
          {
            "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version",
            "valueCode": "4.0.0"
          }
        ],
        "path": "ElementDefinition",
        "short": "Definition of an element in a resource or extension",
        "definition": "Captures constraints on each element within the resource, profile, or extension.",
        "min": 0,
        "max": "*",
        "base": {
          "path": "ElementDefinition",
          "min": 0,
          "max": "*"
        },
        "constraint": [
          {
            "key": "eld-19",
            "severity": "error",
            "human": "Element names cannot include some special characters",
            "expression": "path.matches('[^\\\\s\\\\.,:;\\\\\\'\"\\\\/|?!@#$%&*()\\\\[\\\\]{}]{1,64}(\\\\.[^\\\\s\\\\.,:;\\\\\\'\"\\\\/|?!@#$%&*()\\\\[\\\\]{}]{1,64}(\\\\[x\\\\])?(\\\\:[^\\\\s\\\\.]+)?)*')",
            "xpath": "matches(path/@value, '[^\\s\\.,:;\\'&quot;\\/|?!@#$%&amp;*()\\[\\]{}]{1,64}(\\.[^\\s\\.,:;\\'&quot;\\/|?!@#$%&amp;*()\\[\\]{}]{1,64}(\\[x\\])?(\\:[^\\s\\.]+)?)*')"
          },
          {
            "key": "eld-2",
            "severity": "error",
            "human": "Min <= Max",
            "expression": "min.empty() or max.empty() or (max = '*') or iif(max != '*', min <= max.toInteger())",
            "xpath": "not(exists(f:min)) or not(exists(f:max)) or (not(f:max/@value) and not(f:min/@value)) or (f:max/@value = '*') or (number(f:max/@value) >= f:min/@value)"
          },
          {
            "key": "eld-5",
            "severity": "error",
            "human": "if the element definition has a contentReference, it cannot have type, defaultValue, fixed, pattern, example, minValue, maxValue, maxLength, or binding",
            "expression": "contentReference.empty() or (type.empty() and defaultValue.empty() and fixed.empty() and pattern.empty() and example.empty() and minValue.empty() and maxValue.empty() and maxLength.empty() and binding.empty())",
            "xpath": "not(exists(f:contentReference) and (exists(f:type) or exists(f:*[starts-with(local-name(.), 'value')]) or exists(f:*[starts-with(local-name(.), 'defaultValue')])  or exists(f:*[starts-with(local-name(.), 'fixed')]) or exists(f:*[starts-with(local-name(.), 'pattern')]) or exists(f:*[starts-with(local-name(.), 'example')]) or exists(f:*[starts-with(local-name(.), 'f:minValue')]) or exists(f:*[starts-with(local-name(.), 'f:maxValue')]) or exists(f:maxLength) or exists(f:binding)))"
          },
          {
            "key": "eld-7",
            "severity": "error",
            "human": "Pattern may only be specified if there is one type",
            "expression": "pattern.empty() or (type.count() <= 1)",
            "xpath": "not(exists(f:*[starts-with(local-name(.), 'pattern')])) or (count(f:type)<=1)"
          },
          {
            "key": "eld-6",
            "severity": "error",
            "human": "Fixed value may only be specified if there is one type",
            "expression": "fixed.empty() or (type.count()  <= 1)",
            "xpath": "not(exists(f:*[starts-with(local-name(.), 'fixed')])) or (count(f:type)<=1)"
          },
          {
            "key": "eld-11",
            "severity": "error",
            "human": "Binding can only be present for coded elements, string, and uri",
            "expression": "binding.empty() or type.code.empty() or type.select((code = 'code') or (code = 'Coding') or (code='CodeableConcept') or (code = 'Quantity') or (code = 'string') or (code = 'uri')).exists()",
            "xpath": "not(exists(f:binding)) or (count(f:type/f:code) = 0) or  f:type/f:code/@value=('code','Coding','CodeableConcept','Quantity','string', 'uri')"
          },
          {
            "key": "eld-22",
            "severity": "error",
            "human": "sliceIsConstraining can only appear if slicename is present",
            "expression": "sliceIsConstraining.exists() implies sliceName.exists()",
            "xpath": "exists(f:sliceName) or not(exists(f:sliceIsConstraining))"
          },
          {
            "key": "eld-8",
            "severity": "error",
            "human": "Pattern and value are mutually exclusive",
            "expression": "pattern.empty() or fixed.empty()",
            "xpath": "not(exists(f:*[starts-with(local-name(.), 'pattern')])) or not(exists(f:*[starts-with(local-name(.), 'fixed')]))"
          },
          {
            "key": "eld-14",
            "severity": "error",
            "human": "Constraints must be unique by key",
            "expression": "constraint.select(key).isDistinct()",
            "xpath": "count(f:constraint) = count(distinct-values(f:constraint/f:key/@value))"
          },
          {
            "key": "eld-13",
            "severity": "error",
            "human": "Types must be unique by code",
            "expression": "type.select(code).isDistinct()",
            "xpath": "not(exists(for $type in f:type return $type/preceding-sibling::f:type[f:code/@value=$type/f:code/@value]))"
          },
          {
            "key": "eld-16",
            "severity": "error",
            "human": "sliceName must be composed of proper tokens separated by \"/\"",
            "expression": "sliceName.empty() or sliceName.matches('^[a-zA-Z0-9\\\\/\\\\-_\\\\[\\\\]\\\\@]+$')",
            "xpath": "not(exists(f:sliceName/@value)) or matches(f:sliceName/@value, '^[a-zA-Z0-9\\/\\-_\\[\\]\\@]+$')"
          },
          {
            "key": "eld-15",
            "severity": "error",
            "human": "default value and meaningWhenMissing are mutually exclusive",
            "expression": "defaultValue.empty() or meaningWhenMissing.empty()",
            "xpath": "not(exists(f:*[starts-with(local-name(.), 'fixed')])) or not(exists(f:meaningWhenMissing))"
          },
          {
            "key": "eld-18",
            "severity": "error",
            "human": "Must have a modifier reason if isModifier = true",
            "expression": "isModifier implies isModifierReason.exists()",
            "xpath": "not(f:isModifier/@value = 'true') or exists(f:isModifierReason)"
          },
          {
            "key": "eld-20",
            "severity": "warning",
            "human": "Element names should be simple alphanumerics with a max of 64 characters, or code generation tools may be broken",
            "expression": "path.matches('[A-Za-z][A-Za-z0-9]*(\\\\.[a-z][A-Za-z0-9]*(\\\\[x])?)*')",
            "xpath": "matches(path/@value, '[A-Za-z][A-Za-z0-9]*(\\.[a-z][A-Za-z0-9]*(\\[x])?)*')"
          }
        ],
        "isModifier": false,
        "mapping": [
          {
            "identity": "rim",
            "map": "n/a"
          },
          {
            "identity": "v2",
            "map": "OM1"
          },
          {
            "identity": "rim",
            "map": "Observation[classCode=OBS, moodCode=DEFN]"
          },
          {
            "identity": "iso11179",
            "map": "Data_Element"
          },
          {
            "identity": "dex",
            "map": "RetrieveMetadata response"
          }
        ]
      },
      {
        "id": "ElementDefinition.id",
        "path": "ElementDefinition.id",
        "representation": [
          "xmlAttr"
        ],
        "short": "Unique id for inter-element referencing",
        "definition": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "Element.id",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "isSummary": false,
        "mapping": [
          {
            "identity": "rim",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.extension",
        "path": "ElementDefinition.extension",
        "slicing": {
          "discriminator": [
            {
              "type": "value",
              "path": "url"
            }
          ],
          "description": "Extensions are always sliced by (at least) url",
          "rules": "open"
        },
        "short": "Additional content defined by implementations",
        "definition": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
        "comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
        "alias": [
          "extensions",
          "user content"
        ],
        "min": 0,
        "max": "*",
        "base": {
          "path": "Element.extension",
          "min": 0,
          "max": "*"
        },
        "type": [
          {
            "code": "Extension"
          }
        ],
        "isModifier": false,
        "isSummary": false,
        "mapping": [
          {
            "identity": "rim",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.modifierExtension",
        "path": "ElementDefinition.modifierExtension",
        "short": "Extensions that cannot be ignored even if unrecognized",
        "definition": "May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).",
        "comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
        "requirements": "Modifier extensions allow for extensions that *cannot* be safely ignored to be clearly distinguished from the vast majority of extensions which can be safely ignored.  This promotes interoperability by eliminating the need for implementers to prohibit the presence of extensions. For further information, see the [definition of modifier extensions](extensibility.html#modifierExtension).",
        "alias": [
          "extensions",
          "user content",
          "modifiers"
        ],
        "min": 0,
        "max": "*",
        "base": {
          "path": "BackboneElement.modifierExtension",
          "min": 0,
          "max": "*"
        },
        "type": [
          {
            "code": "Extension"
          }
        ],
        "isModifier": true,
        "isModifierReason": "Modifier extensions are expected to modify the meaning or interpretation of the element that contains them",
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          }
        ]
      },
      {
        "id": "ElementDefinition.path",
        "path": "ElementDefinition.path",
        "short": "Path of the element in the hierarchy of elements",
        "definition": "The path identifies the element and is expressed as a \".\"-separated list of ancestor elements, beginning with the name of the resource or extension.",
        "min": 1,
        "max": "1",
        "base": {
          "path": "ElementDefinition.path",
          "min": 1,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "v2",
            "map": "N/A"
          },
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "Name, Identifier & Context"
          }
        ]
      },
      {
        "id": "ElementDefinition.representation",
        "path": "ElementDefinition.representation",
        "short": "xmlAttr | xmlText | typeAttr | cdaText | xhtml",
        "definition": "Codes that define how this element is represented in instances, when the deviation varies from the normal case.",
        "comment": "In resources, this is rarely used except for special cases where the representation deviates from the normal, and can only be done in the base standard (and profiles must reproduce what the base standard does). This element is used quite commonly in Logical models when the logical models represent a specific serialization format (e.g. CDA, v2 etc.).",
        "min": 0,
        "max": "*",
        "base": {
          "path": "ElementDefinition.representation",
          "min": 0,
          "max": "*"
        },
        "type": [
          {
            "code": "code"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "PropertyRepresentation"
            }
          ],
          "strength": "required",
          "description": "How a property is represented when serialized.",
          "valueSet": "http://hl7.org/fhir/ValueSet/property-representation|4.0.0"
        },
        "mapping": [
          {
            "identity": "v2",
            "map": "N/A"
          },
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.sliceName",
        "path": "ElementDefinition.sliceName",
        "short": "Name for this particular element (in a set of slices)",
        "definition": "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.",
        "comment": "The name SHALL be unique within the structure within the context of the constrained resource element.  (Though to avoid confusion, uniqueness across all elements is recommended.).",
        "requirements": "May also be used for code generation purposes.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.sliceName",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "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",
        "base": {
          "path": "ElementDefinition.sliceIsConstraining",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "boolean"
          }
        ],
        "isModifier": false,
        "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",
        "base": {
          "path": "ElementDefinition.label",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "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": "*",
        "base": {
          "path": "ElementDefinition.code",
          "min": 0,
          "max": "*"
        },
        "type": [
          {
            "code": "Coding"
          }
        ],
        "isModifier": false,
        "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",
        "base": {
          "path": "ElementDefinition.slicing",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "Element"
          }
        ],
        "constraint": [
          {
            "key": "ele-1",
            "severity": "error",
            "human": "All FHIR elements must have a @value or children",
            "expression": "hasValue() or (children().count() > id.count())",
            "xpath": "@value|f:*|h:div",
            "source": "Element"
          },
          {
            "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)"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing.id",
        "path": "ElementDefinition.slicing.id",
        "representation": [
          "xmlAttr"
        ],
        "short": "Unique id for inter-element referencing",
        "definition": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "Element.id",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "isSummary": false,
        "mapping": [
          {
            "identity": "rim",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing.extension",
        "path": "ElementDefinition.slicing.extension",
        "slicing": {
          "discriminator": [
            {
              "type": "value",
              "path": "url"
            }
          ],
          "description": "Extensions are always sliced by (at least) url",
          "rules": "open"
        },
        "short": "Additional content defined by implementations",
        "definition": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
        "comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
        "alias": [
          "extensions",
          "user content"
        ],
        "min": 0,
        "max": "*",
        "base": {
          "path": "Element.extension",
          "min": 0,
          "max": "*"
        },
        "type": [
          {
            "code": "Extension"
          }
        ],
        "isModifier": false,
        "isSummary": false,
        "mapping": [
          {
            "identity": "rim",
            "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": "*",
        "base": {
          "path": "ElementDefinition.slicing.discriminator",
          "min": 0,
          "max": "*"
        },
        "type": [
          {
            "code": "Element"
          }
        ],
        "constraint": [
          {
            "key": "ele-1",
            "severity": "error",
            "human": "All FHIR elements must have a @value or children",
            "expression": "hasValue() or (children().count() > id.count())",
            "xpath": "@value|f:*|h:div",
            "source": "Element"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A"
          },
          {
            "identity": "iso11179",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing.discriminator.id",
        "path": "ElementDefinition.slicing.discriminator.id",
        "representation": [
          "xmlAttr"
        ],
        "short": "Unique id for inter-element referencing",
        "definition": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "Element.id",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "isSummary": false,
        "mapping": [
          {
            "identity": "rim",
            "map": "n/a"
          }
        ]
      },
      {
        "id": "ElementDefinition.slicing.discriminator.extension",
        "path": "ElementDefinition.slicing.discriminator.extension",
        "slicing": {
          "discriminator": [
            {
              "type": "value",
              "path": "url"
            }
          ],
          "description": "Extensions are always sliced by (at least) url",
          "rules": "open"
        },
        "short": "Additional content defined by implementations",
        "definition": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
        "comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
        "alias": [
          "extensions",
          "user content"
        ],
        "min": 0,
        "max": "*",
        "base": {
          "path": "Element.extension",
          "min": 0,
          "max": "*"
        },
        "type": [
          {
            "code": "Extension"
          }
        ],
        "isModifier": false,
        "isSummary": false,
        "mapping": [
          {
            "identity": "rim",
            "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",
        "base": {
          "path": "ElementDefinition.slicing.discriminator.type",
          "min": 1,
          "max": "1"
        },
        "type": [
          {
            "code": "code"
          }
        ],
        "isModifier": false,
        "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",
        "base": {
          "path": "ElementDefinition.slicing.discriminator.path",
          "min": 1,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "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",
        "base": {
          "path": "ElementDefinition.slicing.description",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "condition": [
          "eld-1"
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
