### ----------------------------------------------------
### -- FHIR
### -- Licenses: Artistic-2.0
### -- Authors: Hugh Simpson
### -- File: t/resources/structureDefinition/elementDefinition.json
### ----------------------------------------------------
### -- Chunk 4 of 7
 ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          }
        ]
      },
      {
        "id": "ElementDefinition.constraint.source",
        "path": "ElementDefinition.constraint.source",
        "short": "Reference to original source of constraint",
        "definition": "A reference to the original source of the constraint, for traceability purposes.",
        "comment": "This is used when, e.g. rendering, where it is not useful to present inherited constraints when rendering the snapshot.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.constraint.source",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "canonical",
            "targetProfile": [
              "http://hl7.org/fhir/StructureDefinition/StructureDefinition"
            ]
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          }
        ]
      },
      {
        "id": "ElementDefinition.mustSupport",
        "path": "ElementDefinition.mustSupport",
        "short": "If the element must be supported",
        "definition": "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.",
        "comment": "\"Something useful\" is context dependent and impossible to describe in the base FHIR specification. For this reason, tue mustSupport flag is never set to true by the FHIR specification itself - it is only set to true in profiles.  A profile on a type can always make musSupport = true if it is false in the base type but cannot make mustSupport = false if it is true in the base type.   This is done in [Resource Profiles](profiling.html#mustsupport), where the profile labels an element as mustSupport=true. When a profile does this, it SHALL also make clear exactly what kind of \"support\" is required, as this can mean many things.    Note that an element that has the property IsModifier is not necessarily a \"key\" element (e.g. one of the important elements to make use of the resource), nor is it automatically mustSupport - however both of these things are more likely to be true for IsModifier elements than for other elements.",
        "requirements": "Allows a profile to set expectations for system capabilities beyond merely respecting cardinality constraints.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.mustSupport",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "boolean"
          }
        ],
        "meaningWhenMissing": "In a base type, where the element is being defined for the first time, the element is assumed to be mustSupport = false. In a profile (a constraint on an existing type), if mustSupport is not specific in either the differentil or the snapshot, the mustSupport value is not changed fro the base definition. Not, though, that the snapshot SHOULD always populate the mustSuppot value",
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "??"
          }
        ]
      },
      {
        "id": "ElementDefinition.isModifier",
        "path": "ElementDefinition.isModifier",
        "short": "If this modifies the meaning of other elements",
        "definition": "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.",
        "comment": "Only the definition of an element can set IsModifier true - either the specification itself or where an extension is originally defined. Once set, it cannot be changed in derived profiles. An element/extension that has isModifier=true SHOULD also have a minimum cardinality of 1, so that there is no lack of clarity about what to do if it is missing. If it can be missing, the definition SHALL make the meaning of a missing element clear.",
        "requirements": "Allows elements to be introduced into a specification that can't safely be ignored by applications that don't recognize them.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.isModifier",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "boolean"
          }
        ],
        "meaningWhenMissing": "An element is not a modifier element unless it is explicitly specified to be one",
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "??"
          }
        ]
      },
      {
        "id": "ElementDefinition.isModifierReason",
        "path": "ElementDefinition.isModifierReason",
        "short": "Reason that this element is marked as a modifier",
        "definition": "Explains how that element affects the interpretation of the resource or element that contains it.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.isModifierReason",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          }
        ]
      },
      {
        "id": "ElementDefinition.isSummary",
        "path": "ElementDefinition.isSummary",
        "short": "Include when _summary = true?",
        "definition": "Whether the element should be included if a client requests a search with the parameter _summary=true.",
        "comment": "Some resources include a set of simple metadata, and some very large data. This element is used to reduce the quantity of data returned in searches. Note that servers may pre-cache summarized resources for optimal performance, so servers might not support per-profile use of the isSummary flag. When a request is made with _summary=true, serailisers only include elements marked as 'isSummary = true'. Other than Attachment.data, all data type properties are included in the summary form. In resource and data type definitions, if an element is at the root or has a parent that is 'mustSupport' and the minimum cardinality is 1 or the element is a modifier, it must be marked as isSummary=true.",
        "requirements": "Allow clients to search through large resources quickly.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.isSummary",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "boolean"
          }
        ],
        "meaningWhenMissing": "An element is not included in the summary unless it is explicitly specified to be so",
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "??"
          }
        ]
      },
      {
        "id": "ElementDefinition.binding",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
            "valueString": "ElementDefinitionBinding"
          }
        ],
        "path": "ElementDefinition.binding",
        "short": "ValueSet details if this is coded",
        "definition": "Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri).",
        "comment": "For a CodeableConcept, when no codes are allowed - only text, use a binding of strength \"required\" with a description explaining that no coded values are allowed and what sort of information to put in the \"text\" element.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.binding",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "Element"
          }
        ],
        "condition": [
          "eld-11"
        ],
        "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-12",
            "severity": "error",
            "human": "ValueSet SHALL start with http:// or https:// or urn:",
            "expression": "valueSet.exists() implies (valueSet.startsWith('http:') or valueSet.startsWith('https') or valueSet.startsWith('urn:'))",
            "xpath": "(starts-with(string(f:valueSet/@value), 'http:') or starts-with(string(f:valueSet/@value), 'https:') or starts-with(string(f:valueSet/@value), 'urn:'))"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "v2",
            "map": "OM3, OMC.11"
          },
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": ".domain"
          },
          {
            "identity": "loinc",
            "map": "ANSWER LIST, NORMATIVE ANSWER LIST"
          }
        ]
      },
      {
        "id": "ElementDefinition.binding.id",
        "path": "ElementDefinition.binding.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.binding.extension",
        "path": "ElementDefinition.binding.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.binding.strength",
        "path": "ElementDefinition.binding.strength",
        "short": "required | extensible | preferred | example",
        "definition": "Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.",
        "comment": "For further discussion, see [Using Terminologies](terminologies.html).",
        "alias": [
          "conformance",
          "extensibility"
        ],
        "min": 1,
        "max": "1",
        "base": {
          "path": "ElementDefinition.binding.strength",
          "min": 1,
          "max": "1"
        },
        "type": [
          {
            "code": "code"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "BindingStrength"
            },
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
              "valueBoolean": true
            }
          ],
          "strength": "required",
          "description": "Indication of the degree of conformance expectations associated with a binding.",
          "valueSet": "http://hl7.org/fhir/ValueSet/binding-strength|4.0.0"
        },
        "mapping": [
          {
            "identity": "v2",
            "map": "N/A"
          },
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "loinc",
            "map": "N/A"
          }
        ]
      },
      {
        "id": "ElementDefinition.binding.description",
        "extension": [
          {
            "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
            "valueBoolean": true
          }
        ],
        "path": "ElementDefinition.binding.description",
        "short": "Human explanation of the value set",
        "definition": "Describes the intended use of this particular set of codes.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.binding.description",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": ".domain.description"
          }
        ]
      },
      {
        "id": "ElementDefinition.binding.valueSet",
        "path": "ElementDefinition.binding.valueSet",
        "short": "Source of value set",
        "definition": "Refers to the value set that identifies the set of codes the binding refers to.",
        "comment": "The reference may be version-specific or not (e.g. have a |[version] at the end of the canonical URL).",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.binding.valueSet",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "canonical",
            "targetProfile": [
              "http://hl7.org/fhir/StructureDefinition/ValueSet"
            ]
          }
        ],
        "condition": [
          "eld-12"
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "points to explicit list or expression that evaluates to list of (Enumerated_Value_Domain).member"
          },
          {
            "identity": "dex",
            "map": "valueDomain.valueSet"
          },
          {
            "identity": "loinc",
            "map": "CODE_TABLE"
          }
        ]
      },
      {
        "id": "ElementDefinition.mapping",
        "path": "ElementDefinition.mapping",
        "short": "Map element to another set of definitions",
        "definition": "Identifies a concept from an external specification that roughly corresponds to this element.",
        "comment": "Mappings are not necessarily specific enough for safe translation.",
        "requirements": "Provides guidance to implementers familiar with or converting content from other specifications.",
        "min": 0,
        "max": "*",
        "base": {
          "path": "ElementDefinition.mapping",
          "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 (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "Registered_item).document_reference[document_type=mapping]  Also, .meaning linkage to Data_Element_Concept is done as a mapping to a reference model.  (Data_Element_Concepts are all defined in some sort of reference model, be that Object_Class and Property or some other mechanism)"
          },
          {
            "identity": "dex",
            "map": "mappingSpecification"
          }
        ]
      },
      {
        "id": "ElementDefinition.mapping.id",
        "path": "ElementDefinition.mapping.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.mapping.extension",
        "path": "ElementDefinition.mapping.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.mapping.identity",
        "path": "ElementDefinition.mapping.identity",
        "short": "Reference to mapping declaration",
        "definition": "An internal reference to the definition of a mapping.",
        "min": 1,
        "max": "1",
        "base": {
          "path": "ElementDefinition.mapping.identity",
          "min": 1,
          "max": "1"
        },
        "type": [
          {
            "code": "id"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          }
        ]
      },
      {
        "id": "ElementDefinition.mapping.language",
        "path": "ElementDefinition.mapping.language",
        "short": "Computable language of mapping",
        "definition": "Identifies the computable language in which mapping.map is expressed.",
        "comment": "If omitted, then there can be no expectation of computational interpretation of the mapping.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.mapping.language",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "code"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "MimeType"
            },
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
              "valueBoolean": true
            }
          ],
          "strength": "required",
          "description": "The mime type of an attachment. Any valid mime type is allowed.",
          "valueSet": "http://hl7.org/fhir/ValueSet/mimetypes|4.0.0"
        },
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          }
        ]
      },
      {
        "id": "ElementDefinition.mapping.map",
        "path": "ElementDefinition.mapping.map",
        "short": "Details of the mapping",
        "definition": "Expresses what part of the target specification corresponds to this element.",
        "comment": "For most mappings, the syntax is undefined.  Syntax will be provided for mappings to the RIM.  Multiple mappings may be possible and may include constraints on other resource elements that identify when a particular mapping applies.",
        "min": 1,
        "max": "1",
        "base": {
          "path": "ElementDefinition.mapping.map",
          "min": 1,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          },
          {
            "identity": "iso11179",
            "map": "ObjectClass, Property (this is one possible data model that can be mapped to - the uri would identify the data model  mappingSpecification.mappingScript"
          }
        ]
      },
      {
        "id": "ElementDefinition.mapping.comment",
        "path": "ElementDefinition.mapping.comment",
        "short": "Comments about the mapping or its use",
        "definition": "Comments that provide information about the mapping or its use.",
        "min": 0,
        "max": "1",
        "base": {
          "path": "ElementDefinition.mapping.comment",
          "min": 0,
          "max": "1"
        },
        "type": [
          {
            "code": "string"
          }
        ],
        "isModifier": false,
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "N/A (MIF territory)"
          }
        ]
      }
    ]
  },
  "differential": {
    "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": "*",
        "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])?)*')"
          }
        ],
        "mapping": [
          {
            "identity": "v2",
            "map": "OM1"
          },
          {
            "identity": "rim",
            "map": "Observation[classCode=OBS, moodCode=DEFN]"
          },
          {
            "identity": "iso11179",
            "map": "Data_Element"
          },
          {
            "identity": "dex",
            "map": "RetrieveMetadata response"
          }
        ]
      },
      {
        "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",
        "type": [
          {
            "code": "string"
          }
        ],
        "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": "*",
        "type": [
          {
            "code": "code"
          }
        ],
        "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