Current Build

Переводит команда Health Samurai . Приглашаем поучаствовать в русификации стандарта FHIR: GitHub , Email.

7.8 JSON Schema for StructureMap

FHIR Infrastructure Work GroupMaturity Level: N/ABallot Status: Informative Compartments: Not linked to any defined compartments

This is a representation of the json schema for StructureMap, which is just a part of the full JSON Schema.

{
  "$schema": "http://json-schema.org/draft-06/schema#",
  "id": "http://hl7.org/fhir/json-schema/StructureMap",
  "$ref": "#/definitions/StructureMap",
  "description": "see http://hl7.org/fhir/json.html#schema for information about the FHIR Json Schemas",
  "definitions": {
    "StructureMap": {
      "description": "Карта взаимосвязей между двумя структурами, которую можно использовать для трансформации данных.",
      "properties": {
        "resourceType": {
          "description": "This is a StructureMap resource",
          "const": "StructureMap"
        },
        "id": {
          "description": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
          "$ref": "id.schema.json#/definitions/id"
        },
        "meta": {
          "description": "Метаданные ресурса. Это такая информация, которая поддерживается инфраструктурой. Изменения этой информации не всегда можно ассоциировать с версионными изменениями ресурса.",
          "$ref": "Meta.schema.json#/definitions/Meta"
        },
        "implicitRules": {
          "description": "Ссылка на свод правил, которым следовали при создании этого ресурса и которые необходимо понимать при обработке этого содержимого. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc.",
          "$ref": "#/definitions/uri"
        },
        "_implicitRules": {
          "description": "Extensions for implicitRules",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "language": {
          "description": "Основной язык, на котором написан ресурс.",
          "$ref": "#/definitions/code"
        },
        "_language": {
          "description": "Extensions for language",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "text": {
          "description": "Человекочитаемая описательная часть, содержащая краткое изложение ресурса, которая может использоваться для представления содержимого ресурса человеку. От описательной части не требуется кодировать все структурированные данные, но она должна содержать достаточно сведений, чтобы простое её прочтение человеком было \"клинически безопасным\". Определения ресурсов могут описывать, какое содержимое должно быть представлено в описательной части для обеспечения клинической безопасной.",
          "$ref": "Narrative.schema.json#/definitions/Narrative"
        },
        "contained": {
          "description": "Эти ресурсы не обладают независимым существованием вне ресурса, который их содержит - их нельзя идентифицировать независимо, и они не могут иметь своей собственной независимой транзакционной области действия.",
          "items": {
            "$ref": "ResourceList.schema.json#/definitions/ResourceList"
          },
          "type": "array"
        },
        "extension": {
          "description": "Может использоваться для представления дополнительной информации, не являющейся частью базового определения ресурса. Чтобы сделать использование расширений надежным и управляемым, существует строгий набор управления применительно к определению и использованию расширений. Хотя каждому реализатору разрешается определять расширения, имеется набор требований, которые должны выполняться в рамках определения расширения.",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "modifierExtension": {
          "description": "May be used to represent additional information that is not part of the basic definition of the resource, and that modifies the understanding of the element that contains it. 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 is allowed to 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).",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "url": {
          "description": "An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this structure map is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure map is stored on different servers.",
          "$ref": "#/definitions/uri"
        },
        "_url": {
          "description": "Extensions for url",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "identifier": {
          "description": "A formal identifier that is used to identify this structure map when it is represented in other formats, or referenced in a specification, model, design or an instance.",
          "items": {
            "$ref": "Identifier.schema.json#/definitions/Identifier"
          },
          "type": "array"
        },
        "version": {
          "description": "The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
          "$ref": "#/definitions/string"
        },
        "_version": {
          "description": "Extensions for version",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "name": {
          "description": "A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
          "$ref": "#/definitions/string"
        },
        "_name": {
          "description": "Extensions for name",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "title": {
          "description": "A short, descriptive, user-friendly title for the structure map.",
          "$ref": "#/definitions/string"
        },
        "_title": {
          "description": "Extensions for title",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "status": {
          "description": "The status of this structure map. Enables tracking the life-cycle of the content.",
          "enum": [
            "draft",
            "active",
            "retired",
            "unknown"
          ]
        },
        "_status": {
          "description": "Extensions for status",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "experimental": {
          "description": "A Boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.",
          "$ref": "#/definitions/boolean"
        },
        "_experimental": {
          "description": "Extensions for experimental",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "date": {
          "description": "The date  (and optionally time) when the structure map was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes.",
          "$ref": "#/definitions/dateTime"
        },
        "_date": {
          "description": "Extensions for date",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "publisher": {
          "description": "The name of the organization or individual that published the structure map.",
          "$ref": "#/definitions/string"
        },
        "_publisher": {
          "description": "Extensions for publisher",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "contact": {
          "description": "Contact details to assist a user in finding and communicating with the publisher.",
          "items": {
            "$ref": "ContactDetail.schema.json#/definitions/ContactDetail"
          },
          "type": "array"
        },
        "description": {
          "description": "A free text natural language description of the structure map from a consumer\u0027s perspective.",
          "$ref": "#/definitions/markdown"
        },
        "_description": {
          "description": "Extensions for description",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "useContext": {
          "description": "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate structure map instances.",
          "items": {
            "$ref": "UsageContext.schema.json#/definitions/UsageContext"
          },
          "type": "array"
        },
        "jurisdiction": {
          "description": "A legal or geographic region in which the structure map is intended to be used.",
          "items": {
            "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
          },
          "type": "array"
        },
        "purpose": {
          "description": "Explanation of why this structure map is needed and why it has been designed as it has.",
          "$ref": "#/definitions/markdown"
        },
        "_purpose": {
          "description": "Extensions for purpose",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "copyright": {
          "description": "A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map.",
          "$ref": "#/definitions/markdown"
        },
        "_copyright": {
          "description": "Extensions for copyright",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "structure": {
          "description": "Структурное определение, используемое этой картой. Структурное определение может описывать экземпляры, которые конвертируются, или экземпляры, которые создаются [в процессе конвертации].",
          "items": {
            "$ref": "#/definitions/StructureMap_Structure"
          },
          "type": "array"
        },
        "import": {
          "description": "Другие карты, используемые данной картой (канонические URLs).",
          "items": {
            "$ref": "canonical.schema.json#/definitions/canonical"
          },
          "type": "array"
        },
        "group": {
          "description": "Organizes the mapping into manageable chunks for human review/ease of maintenance.",
          "items": {
            "$ref": "#/definitions/StructureMap_Group"
          },
          "type": "array"
        }
      },
      "additionalProperties": false,
      "required": [
        "resourceType",
        "group"
      ]
    },
    "StructureMap_Structure": {
      "description": "Карта взаимосвязей между двумя структурами, которую можно использовать для трансформации данных.",
      "properties": {
        "id": {
          "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
          "$ref": "string.schema.json#/definitions/string"
        },
        "extension": {
          "description": "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.",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "modifierExtension": {
          "description": "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. 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).",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "url": {
          "description": "The canonical reference to the structure.",
          "$ref": "canonical.schema.json#/definitions/canonical"
        },
        "mode": {
          "description": "Каким образом упомянутая структура используется в данном мэппинге.",
          "enum": [
            "source",
            "queried",
            "target",
            "produced"
          ]
        },
        "_mode": {
          "description": "Extensions for mode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "alias": {
          "description": "The name used for this type in the map.",
          "$ref": "#/definitions/string"
        },
        "_alias": {
          "description": "Extensions for alias",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "documentation": {
          "description": "Документация, которая описывает, как данная структура используется в этом мэппинге.",
          "$ref": "#/definitions/string"
        },
        "_documentation": {
          "description": "Extensions for documentation",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "additionalProperties": false,
      "required": [
        "url"
      ]
    },
    "StructureMap_Group": {
      "description": "Карта взаимосвязей между двумя структурами, которую можно использовать для трансформации данных.",
      "properties": {
        "id": {
          "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
          "$ref": "string.schema.json#/definitions/string"
        },
        "extension": {
          "description": "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.",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "modifierExtension": {
          "description": "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. 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).",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "name": {
          "description": "A unique name for the group for the convenience of human readers.",
          "$ref": "#/definitions/id"
        },
        "_name": {
          "description": "Extensions for name",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "extends": {
          "description": "Другая группа, к которой данная группа добавляет правила.",
          "$ref": "#/definitions/id"
        },
        "_extends": {
          "description": "Extensions for extends",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "typeMode": {
          "description": "If this is the default rule set to apply for the source type or this combination of types.",
          "enum": [
            "none",
            "types",
            "type-and-types"
          ]
        },
        "_typeMode": {
          "description": "Extensions for typeMode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "documentation": {
          "description": "Additional supporting documentation that explains the purpose of the group and the types of mappings within it.",
          "$ref": "#/definitions/string"
        },
        "_documentation": {
          "description": "Extensions for documentation",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "input": {
          "description": "Имя, назначенное экземпляру данных. Этот экземпляр должен предоставляться, когда вызывается данный мэппинг.",
          "items": {
            "$ref": "#/definitions/StructureMap_Input"
          },
          "type": "array"
        },
        "rule": {
          "description": "Правило трансформации из источника в целевой объект.",
          "items": {
            "$ref": "#/definitions/StructureMap_Rule"
          },
          "type": "array"
        }
      },
      "additionalProperties": false,
      "required": [
        "input",
        "rule"
      ]
    },
    "StructureMap_Input": {
      "description": "Карта взаимосвязей между двумя структурами, которую можно использовать для трансформации данных.",
      "properties": {
        "id": {
          "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
          "$ref": "string.schema.json#/definitions/string"
        },
        "extension": {
          "description": "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.",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "modifierExtension": {
          "description": "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. 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).",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "name": {
          "description": "Имя для этого экземпляра данных.",
          "$ref": "#/definitions/id"
        },
        "_name": {
          "description": "Extensions for name",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "type": {
          "description": "Тип этого экземпляра данных.",
          "$ref": "#/definitions/string"
        },
        "_type": {
          "description": "Extensions for type",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "mode": {
          "description": "Режим для этого экземпляра данных.",
          "enum": [
            "source",
            "target"
          ]
        },
        "_mode": {
          "description": "Extensions for mode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "documentation": {
          "description": "Документация к этому экземпляру данных.",
          "$ref": "#/definitions/string"
        },
        "_documentation": {
          "description": "Extensions for documentation",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "additionalProperties": false
    },
    "StructureMap_Rule": {
      "description": "Карта взаимосвязей между двумя структурами, которую можно использовать для трансформации данных.",
      "properties": {
        "id": {
          "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
          "$ref": "string.schema.json#/definitions/string"
        },
        "extension": {
          "description": "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.",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "modifierExtension": {
          "description": "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. 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).",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "name": {
          "description": "Имя правила для внутренних ссылок.",
          "$ref": "#/definitions/id"
        },
        "_name": {
          "description": "Extensions for name",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "source": {
          "description": "Исходные входные данные для мэппинга.",
          "items": {
            "$ref": "#/definitions/StructureMap_Source"
          },
          "type": "array"
        },
        "target": {
          "description": "Содержимое, которое будет создано в соответствии с даннным правилом мэппинга.",
          "items": {
            "$ref": "#/definitions/StructureMap_Target"
          },
          "type": "array"
        },
        "rule": {
          "description": "Правила, входящие в данное правило.",
          "items": {
            "$ref": "#/definitions/StructureMap_Rule"
          },
          "type": "array"
        },
        "dependent": {
          "description": "Какие ещё правила необходимо применить в контексте данного правила.",
          "items": {
            "$ref": "#/definitions/StructureMap_Dependent"
          },
          "type": "array"
        },
        "documentation": {
          "description": "Документация к этому экземпляру данных.",
          "$ref": "#/definitions/string"
        },
        "_documentation": {
          "description": "Extensions for documentation",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "additionalProperties": false,
      "required": [
        "source"
      ]
    },
    "StructureMap_Source": {
      "description": "Карта взаимосвязей между двумя структурами, которую можно использовать для трансформации данных.",
      "properties": {
        "id": {
          "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
          "$ref": "string.schema.json#/definitions/string"
        },
        "extension": {
          "description": "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.",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "modifierExtension": {
          "description": "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. 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).",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "context": {
          "description": "Тип или переменная, к которым применяется данное правило.",
          "$ref": "#/definitions/id"
        },
        "_context": {
          "description": "Extensions for context",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "min": {
          "description": "Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content.",
          "$ref": "#/definitions/integer"
        },
        "_min": {
          "description": "Extensions for min",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "max": {
          "description": "Specified maximum cardinality for the element - a number or a \"*\". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it\u0027s the default value).",
          "$ref": "#/definitions/string"
        },
        "_max": {
          "description": "Extensions for max",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "type": {
          "description": "Specified type for the element. This works as a condition on the mapping - use for polymorphic elements.",
          "$ref": "#/definitions/string"
        },
        "_type": {
          "description": "Extensions for type",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueBase64Binary": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^(\\s*([0-9a-zA-Z\\+/\u003d]){4}\\s*)+$",
          "type": "string"
        },
        "_defaultValueBase64Binary": {
          "description": "Extensions for defaultValueBase64Binary",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueBoolean": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^true|false$",
          "type": "boolean"
        },
        "_defaultValueBoolean": {
          "description": "Extensions for defaultValueBoolean",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueCanonical": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^\\S*$",
          "type": "string"
        },
        "_defaultValueCanonical": {
          "description": "Extensions for defaultValueCanonical",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueCode": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
          "type": "string"
        },
        "_defaultValueCode": {
          "description": "Extensions for defaultValueCode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueDate": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1]))?)?$",
          "type": "string"
        },
        "_defaultValueDate": {
          "description": "Extensions for defaultValueDate",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueDateTime": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$",
          "type": "string"
        },
        "_defaultValueDateTime": {
          "description": "Extensions for defaultValueDateTime",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueDecimal": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
          "type": "number"
        },
        "_defaultValueDecimal": {
          "description": "Extensions for defaultValueDecimal",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueId": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^[A-Za-z0-9\\-\\.]{1,64}$",
          "type": "string"
        },
        "_defaultValueId": {
          "description": "Extensions for defaultValueId",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueInstant": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))$",
          "type": "string"
        },
        "_defaultValueInstant": {
          "description": "Extensions for defaultValueInstant",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueInteger": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^-?([0]|([1-9][0-9]*))$",
          "type": "number"
        },
        "_defaultValueInteger": {
          "description": "Extensions for defaultValueInteger",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueMarkdown": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^[ \\r\\n\\t\\S]+$",
          "type": "string"
        },
        "_defaultValueMarkdown": {
          "description": "Extensions for defaultValueMarkdown",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueOid": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^urn:oid:[0-2](\\.(0|[1-9][0-9]*))+$",
          "type": "string"
        },
        "_defaultValueOid": {
          "description": "Extensions for defaultValueOid",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValuePositiveInt": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^[1-9][0-9]*$",
          "type": "number"
        },
        "_defaultValuePositiveInt": {
          "description": "Extensions for defaultValuePositiveInt",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueString": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^[ \\r\\n\\t\\S]+$",
          "type": "string"
        },
        "_defaultValueString": {
          "description": "Extensions for defaultValueString",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueTime": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?$",
          "type": "string"
        },
        "_defaultValueTime": {
          "description": "Extensions for defaultValueTime",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueUnsignedInt": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^[0]|([1-9][0-9]*)$",
          "type": "number"
        },
        "_defaultValueUnsignedInt": {
          "description": "Extensions for defaultValueUnsignedInt",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueUri": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^\\S*$",
          "type": "string"
        },
        "_defaultValueUri": {
          "description": "Extensions for defaultValueUri",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueUrl": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^\\S*$",
          "type": "string"
        },
        "_defaultValueUrl": {
          "description": "Extensions for defaultValueUrl",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueUuid": {
          "description": "A value to use if there is no existing value in the source object.",
          "pattern": "^urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
          "type": "string"
        },
        "_defaultValueUuid": {
          "description": "Extensions for defaultValueUuid",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "defaultValueAddress": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Address.schema.json#/definitions/Address"
        },
        "defaultValueAge": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Age.schema.json#/definitions/Age"
        },
        "defaultValueAnnotation": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Annotation.schema.json#/definitions/Annotation"
        },
        "defaultValueAttachment": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Attachment.schema.json#/definitions/Attachment"
        },
        "defaultValueCodeableConcept": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "defaultValueCoding": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Coding.schema.json#/definitions/Coding"
        },
        "defaultValueContactPoint": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "ContactPoint.schema.json#/definitions/ContactPoint"
        },
        "defaultValueCount": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Count.schema.json#/definitions/Count"
        },
        "defaultValueDistance": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Distance.schema.json#/definitions/Distance"
        },
        "defaultValueDuration": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Duration.schema.json#/definitions/Duration"
        },
        "defaultValueHumanName": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "HumanName.schema.json#/definitions/HumanName"
        },
        "defaultValueIdentifier": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Identifier.schema.json#/definitions/Identifier"
        },
        "defaultValueMoney": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Money.schema.json#/definitions/Money"
        },
        "defaultValuePeriod": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Period.schema.json#/definitions/Period"
        },
        "defaultValueQuantity": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Quantity.schema.json#/definitions/Quantity"
        },
        "defaultValueRange": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Range.schema.json#/definitions/Range"
        },
        "defaultValueRatio": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Ratio.schema.json#/definitions/Ratio"
        },
        "defaultValueReference": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Reference.schema.json#/definitions/Reference"
        },
        "defaultValueSampledData": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "SampledData.schema.json#/definitions/SampledData"
        },
        "defaultValueSignature": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Signature.schema.json#/definitions/Signature"
        },
        "defaultValueTiming": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Timing.schema.json#/definitions/Timing"
        },
        "defaultValueContactDetail": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "ContactDetail.schema.json#/definitions/ContactDetail"
        },
        "defaultValueContributor": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Contributor.schema.json#/definitions/Contributor"
        },
        "defaultValueDataRequirement": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "DataRequirement.schema.json#/definitions/DataRequirement"
        },
        "defaultValueExpression": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Expression.schema.json#/definitions/Expression"
        },
        "defaultValueParameterDefinition": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "ParameterDefinition.schema.json#/definitions/ParameterDefinition"
        },
        "defaultValueRelatedArtifact": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "RelatedArtifact.schema.json#/definitions/RelatedArtifact"
        },
        "defaultValueTriggerDefinition": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "TriggerDefinition.schema.json#/definitions/TriggerDefinition"
        },
        "defaultValueUsageContext": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "UsageContext.schema.json#/definitions/UsageContext"
        },
        "defaultValueDosage": {
          "description": "A value to use if there is no existing value in the source object.",
          "$ref": "Dosage.schema.json#/definitions/Dosage"
        },
        "element": {
          "description": "Необязательное поле для этого источника.",
          "$ref": "#/definitions/string"
        },
        "_element": {
          "description": "Extensions for element",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "listMode": {
          "description": "Как обрабатывать режим списка для этого элемента.",
          "enum": [
            "first",
            "not_first",
            "last",
            "not_last",
            "only_one"
          ]
        },
        "_listMode": {
          "description": "Extensions for listMode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "variable": {
          "description": "Именованный контектс для поля, если поле не указано.",
          "$ref": "#/definitions/id"
        },
        "_variable": {
          "description": "Extensions for variable",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "condition": {
          "description": "FHIRPath expression  - must be true or the rule does not apply.",
          "$ref": "#/definitions/string"
        },
        "_condition": {
          "description": "Extensions for condition",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "check": {
          "description": "FHIRPath expression  - must be true or the mapping engine throws an error instead of completing.",
          "$ref": "#/definitions/string"
        },
        "_check": {
          "description": "Extensions for check",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "logMessage": {
          "description": "A FHIRPath expression which specifies a message to put in the transform log when content matching the source rule is found.",
          "$ref": "#/definitions/string"
        },
        "_logMessage": {
          "description": "Extensions for logMessage",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "additionalProperties": false
    },
    "StructureMap_Target": {
      "description": "Карта взаимосвязей между двумя структурами, которую можно использовать для трансформации данных.",
      "properties": {
        "id": {
          "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
          "$ref": "string.schema.json#/definitions/string"
        },
        "extension": {
          "description": "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.",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "modifierExtension": {
          "description": "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. 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).",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "context": {
          "description": "Тип или переменная, к которым применяется данное правило.",
          "$ref": "#/definitions/id"
        },
        "_context": {
          "description": "Extensions for context",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "contextType": {
          "description": "Как интерпретировать контекст.",
          "enum": [
            "type",
            "variable"
          ]
        },
        "_contextType": {
          "description": "Extensions for contextType",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "element": {
          "description": "Поле, которое будет создано в этом контексте.",
          "$ref": "#/definitions/string"
        },
        "_element": {
          "description": "Extensions for element",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "variable": {
          "description": "Именованный контекст для поля, если необходимо, и поле указано.",
          "$ref": "#/definitions/id"
        },
        "_variable": {
          "description": "Extensions for variable",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "listMode": {
          "description": "Если поле является списком, как управлять этим списком.",
          "items": {
            "enum": [
              "first",
              "share",
              "last",
              "collate"
            ]
          },
          "type": "array"
        },
        "_listMode": {
          "description": "Extensions for listMode",
          "items": {
            "$ref": "Element.schema.json#/definitions/Element"
          },
          "type": "array"
        },
        "listRuleId": {
          "description": "Внутренняя ссылка на правило для общих пунктов списка.",
          "$ref": "#/definitions/id"
        },
        "_listRuleId": {
          "description": "Extensions for listRuleId",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "transform": {
          "description": "Как данные копируются / создаются.",
          "enum": [
            "create",
            "copy",
            "truncate",
            "escape",
            "cast",
            "append",
            "translate",
            "reference",
            "dateOp",
            "uuid",
            "pointer",
            "evaluate",
            "cc",
            "c",
            "qty",
            "id",
            "cp"
          ]
        },
        "_transform": {
          "description": "Extensions for transform",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "parameter": {
          "description": "Параметры трансформации.",
          "items": {
            "$ref": "#/definitions/StructureMap_Parameter"
          },
          "type": "array"
        }
      },
      "additionalProperties": false
    },
    "StructureMap_Parameter": {
      "description": "Карта взаимосвязей между двумя структурами, которую можно использовать для трансформации данных.",
      "properties": {
        "id": {
          "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
          "$ref": "string.schema.json#/definitions/string"
        },
        "extension": {
          "description": "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.",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "modifierExtension": {
          "description": "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. 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).",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "valueId": {
          "description": "Значение параметра - переменная или литерал.",
          "pattern": "^[A-Za-z0-9\\-\\.]{1,64}$",
          "type": "string"
        },
        "_valueId": {
          "description": "Extensions for valueId",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "valueString": {
          "description": "Значение параметра - переменная или литерал.",
          "pattern": "^[ \\r\\n\\t\\S]+$",
          "type": "string"
        },
        "_valueString": {
          "description": "Extensions for valueString",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "valueBoolean": {
          "description": "Значение параметра - переменная или литерал.",
          "pattern": "^true|false$",
          "type": "boolean"
        },
        "_valueBoolean": {
          "description": "Extensions for valueBoolean",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "valueInteger": {
          "description": "Значение параметра - переменная или литерал.",
          "pattern": "^-?([0]|([1-9][0-9]*))$",
          "type": "number"
        },
        "_valueInteger": {
          "description": "Extensions for valueInteger",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "valueDecimal": {
          "description": "Значение параметра - переменная или литерал.",
          "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
          "type": "number"
        },
        "_valueDecimal": {
          "description": "Extensions for valueDecimal",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "additionalProperties": false
    },
    "StructureMap_Dependent": {
      "description": "Карта взаимосвязей между двумя структурами, которую можно использовать для трансформации данных.",
      "properties": {
        "id": {
          "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
          "$ref": "string.schema.json#/definitions/string"
        },
        "extension": {
          "description": "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.",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "modifierExtension": {
          "description": "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. 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).",
          "items": {
            "$ref": "Extension.schema.json#/definitions/Extension"
          },
          "type": "array"
        },
        "name": {
          "description": "Имя правила или группы, которое необходимо применить.",
          "$ref": "#/definitions/id"
        },
        "_name": {
          "description": "Extensions for name",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "variable": {
          "description": "Variable to pass to the rule or group.",
          "items": {
            "$ref": "#/definitions/string"
          },
          "type": "array"
        },
        "_variable": {
          "description": "Extensions for variable",
          "items": {
            "$ref": "Element.schema.json#/definitions/Element"
          },
          "type": "array"
        }
      },
      "additionalProperties": false
    }
  }
}