FHIR CI-Build

This is the Continuous Integration Build of FHIR (will be incorrect/inconsistent at times).
See the Directory of published versions icon

Clinical Genomics icon Work GroupMaturity Level: N/AStandards Status: Informative Compartments: No defined compartments

This is a representation of the json schema for MolecularDefinition, 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/MolecularDefinition",
  "$ref": "#/definitions/MolecularDefinition",
  "description": "see http://hl7.org/fhir/json.html#schema for information about the FHIR Json Schemas",
  "definitions": {
    "MolecularDefinition": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "properties": {
        "resourceType": {
          "description": "This is a MolecularDefinition resource",
          "const": "MolecularDefinition"
        },
        "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": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.",
          "$ref": "Meta.schema.json#/definitions/Meta"
        },
        "implicitRules": {
          "description": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. 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": "The base language in which the resource is written.",
          "$ref": "#/definitions/code"
        },
        "_language": {
          "description": "Extensions for language",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "text": {
          "description": "A human-readable narrative that contains a summary of the resource and can be used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it \"clinically safe\" for a human to just read the narrative. Resource definitions may define what content should be represented in the narrative to ensure clinical safety.",
          "$ref": "Narrative.schema.json#/definitions/Narrative"
        },
        "contained": {
          "description": "These resources do not have an independent existence apart from the resource that contains them - they cannot be identified independently, nor can they have their own independent transaction scope. This is allowed to be a Parameters resource if and only if it is referenced by a resource that provides context/meaning.",
          "items": {
            "$ref": "ResourceList.schema.json#/definitions/ResourceList"
          },
          "type": "array"
        },
        "extension": {
          "description": "May be used to represent additional information that is not part of the basic definition of the resource. To make the use of extensions safe and managable, 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 resource and that modifies the understanding of the element that contains it and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "identifier": {
          "description": "A unique identifier for a particular instance of this resource.",
          "items": {
            "$ref": "Identifier.schema.json#/definitions/Identifier"
          },
          "type": "array"
        },
        "description": {
          "description": "A description of the molecular entity in a human friendly format.",
          "$ref": "#/definitions/markdown"
        },
        "_description": {
          "description": "Extensions for description",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "moleculeType": {
          "description": "The type of molecule (e.g., DNA, RNA, amino acid). This is a broad concept that refers to the general physical composition of the molecule, intended to facilitate searching and to provide domain context for profiles and instances. The terminology binding may be expanded to support additional types of molecules in the future (e.g., peptide nucleic acids, oligosaccharides).",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "type": {
          "description": "Classifications of an instance of the resource into arbitrary types, based on domain semantics. For example, this element could indicate that an instance of moleculeType \u0027RNA\u0027 could have a type of \u0027mRNA\u0027 or \u0027siRNA\u0027.",
          "items": {
            "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
          },
          "type": "array"
        },
        "topology": {
          "description": "The structural topology of the molecular entity. For sequences (e.g., DNA), this could specify \u0027linear\u0027 and \u0027circular\u0027. More complex entities might be branched or have a quaternary structure.",
          "items": {
            "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
          },
          "type": "array"
        },
        "memberState": {
          "description": "Reserved for future profiles (e.g., haplotype, genotype).",
          "items": {
            "$ref": "Reference.schema.json#/definitions/Reference"
          },
          "type": "array"
        },
        "location": {
          "description": "A defined location on a molecular entity. Location definitions may vary with respect to coordinate space and precision or level of granularity.",
          "items": {
            "$ref": "#/definitions/MolecularDefinition_Location"
          },
          "type": "array"
        },
        "representation": {
          "description": "A representation of a molecular entity, specifically including sequence. Note this element is intended to define the entity primarily through computable, discrete elements that express domain semantics rather than replicating a particular file format or relational schema.",
          "items": {
            "$ref": "#/definitions/MolecularDefinition_Representation"
          },
          "type": "array"
        }
      },
      "type": "object",
      "additionalProperties": false,
      "required": [
        "resourceType"
      ]
    },
    "MolecularDefinition_Location": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "sequenceLocation": {
          "description": "A location on a sequence, defined using a nucleotide coordinate system.",
          "$ref": "#/definitions/MolecularDefinition_SequenceLocation"
        },
        "cytobandLocation": {
          "description": "A location on a sequence, defined using cytobands.",
          "$ref": "#/definitions/MolecularDefinition_CytobandLocation"
        },
        "featureLocation": {
          "description": "Reserved and possibly deprecated.",
          "items": {
            "$ref": "#/definitions/string"
          },
          "type": "array"
        },
        "_featureLocation": {
          "description": "Extensions for featureLocation",
          "items": {
            "$ref": "Element.schema.json#/definitions/Element"
          },
          "type": "array"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_SequenceLocation": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "sequenceContext": {
          "description": "A reference to a sequence on which the location is defined.",
          "$ref": "Reference.schema.json#/definitions/Reference"
        },
        "coordinateInterval": {
          "description": "An interval on a sequence, defined by coordinate-based start and end coordinates.",
          "$ref": "#/definitions/MolecularDefinition_CoordinateInterval"
        },
        "strand": {
          "description": "The specific strand at the coordinateInterval, when the interval alone is not sufficient to define a location (e.g., double stranded DNA). Example values include \u0027forward\u0027 and \u0027reverse\u0027.",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        }
      },
      "type": "object",
      "additionalProperties": false,
      "required": [
        "sequenceContext"
      ]
    },
    "MolecularDefinition_CoordinateInterval": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "coordinateSystem": {
          "description": "A definition of the coordinate system. Examples include 1-based character counting, and 0-based interval counting.",
          "$ref": "#/definitions/MolecularDefinition_CoordinateSystem"
        },
        "startQuantity": {
          "description": "The start location of the interval expressed as a precise coordinate (Quantity) or expressed as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported.",
          "$ref": "Quantity.schema.json#/definitions/Quantity"
        },
        "startRange": {
          "description": "The start location of the interval expressed as a precise coordinate (Quantity) or expressed as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported.",
          "$ref": "Range.schema.json#/definitions/Range"
        },
        "endQuantity": {
          "description": "The end location of the interval expressed as a precise coordinate (Quantity) or as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported..",
          "$ref": "Quantity.schema.json#/definitions/Quantity"
        },
        "endRange": {
          "description": "The end location of the interval expressed as a precise coordinate (Quantity) or as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported..",
          "$ref": "Range.schema.json#/definitions/Range"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_CoordinateSystem": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "system": {
          "description": "A definition of the coordinate system. Examples include 1-based character counting, and 0-based interval counting.",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "origin": {
          "description": "The location of the origin (0 or 1, depending on the coordinate system). For example, this could specify the origin is at the start of the sequence (e.g., 5’ end or N-terminus), the beginning of a designated feature (e.g., A in the ATG translation initiation codon), or the end of a designated feature (e.g., 3’ end of an exon, from which an offset is calculated into the following intron).",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "normalizationMethod": {
          "description": "The normalization method used for determining a location within the coordinate system. Examples include left shift (e.g., VCF), right shift (e.g., HGVS), or fully justified (e.g., VOCA).",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_CytobandLocation": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "genomeAssembly": {
          "description": "The reference genome assemble.",
          "$ref": "#/definitions/MolecularDefinition_GenomeAssembly"
        },
        "cytobandInterval": {
          "description": "The Cytoband Interval.",
          "$ref": "#/definitions/MolecularDefinition_CytobandInterval"
        }
      },
      "type": "object",
      "additionalProperties": false,
      "required": [
        "cytobandInterval",
        "genomeAssembly"
      ]
    },
    "MolecularDefinition_GenomeAssembly": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "organism": {
          "description": "Species of the organism.",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "build": {
          "description": "The build number of this genome assemble.",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "accession": {
          "description": "The accession of this genome assemble.",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "descriptionMarkdown": {
          "description": "The description of this genome assembly.",
          "pattern": "^^[\\s\\S]+$$",
          "type": "string"
        },
        "_descriptionMarkdown": {
          "description": "Extensions for descriptionMarkdown",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "descriptionString": {
          "description": "The description of this genome assembly.",
          "pattern": "^^[\\s\\S]+$$",
          "type": "string"
        },
        "_descriptionString": {
          "description": "Extensions for descriptionString",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_CytobandInterval": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "chromosome": {
          "description": "The chromosome where this cytoband interval occurs.",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "startCytoband": {
          "description": "The start of this cytoband Interval.",
          "$ref": "#/definitions/MolecularDefinition_StartCytoband"
        },
        "endCytoband": {
          "description": "The end of this cytoband Interval.",
          "$ref": "#/definitions/MolecularDefinition_EndCytoband"
        }
      },
      "type": "object",
      "additionalProperties": false,
      "required": [
        "chromosome"
      ]
    },
    "MolecularDefinition_StartCytoband": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "armCode": {
          "description": "The arm of this start interval.",
          "pattern": "^[^\\s]+( [^\\s]+)*$",
          "type": "string"
        },
        "_armCode": {
          "description": "Extensions for armCode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "armString": {
          "description": "The arm of this start interval.",
          "pattern": "^^[\\s\\S]+$$",
          "type": "string"
        },
        "_armString": {
          "description": "Extensions for armString",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "regionCode": {
          "description": "The region of this start interval.",
          "pattern": "^[^\\s]+( [^\\s]+)*$",
          "type": "string"
        },
        "_regionCode": {
          "description": "Extensions for regionCode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "regionString": {
          "description": "The region of this start interval.",
          "pattern": "^^[\\s\\S]+$$",
          "type": "string"
        },
        "_regionString": {
          "description": "Extensions for regionString",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "bandCode": {
          "description": "The band of this start interval.",
          "pattern": "^[^\\s]+( [^\\s]+)*$",
          "type": "string"
        },
        "_bandCode": {
          "description": "Extensions for bandCode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "bandString": {
          "description": "The band of this start interval.",
          "pattern": "^^[\\s\\S]+$$",
          "type": "string"
        },
        "_bandString": {
          "description": "Extensions for bandString",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "subBandCode": {
          "description": "The sub-band of this start interval.",
          "pattern": "^[^\\s]+( [^\\s]+)*$",
          "type": "string"
        },
        "_subBandCode": {
          "description": "Extensions for subBandCode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "subBandString": {
          "description": "The sub-band of this start interval.",
          "pattern": "^^[\\s\\S]+$$",
          "type": "string"
        },
        "_subBandString": {
          "description": "Extensions for subBandString",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_EndCytoband": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "armCode": {
          "description": "The arm of this end interval.",
          "pattern": "^[^\\s]+( [^\\s]+)*$",
          "type": "string"
        },
        "_armCode": {
          "description": "Extensions for armCode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "armString": {
          "description": "The arm of this end interval.",
          "pattern": "^^[\\s\\S]+$$",
          "type": "string"
        },
        "_armString": {
          "description": "Extensions for armString",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "regionCode": {
          "description": "The region of this end interval.",
          "pattern": "^[^\\s]+( [^\\s]+)*$",
          "type": "string"
        },
        "_regionCode": {
          "description": "Extensions for regionCode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "regionString": {
          "description": "The region of this end interval.",
          "pattern": "^^[\\s\\S]+$$",
          "type": "string"
        },
        "_regionString": {
          "description": "Extensions for regionString",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "bandCode": {
          "description": "The band of this end interval.",
          "pattern": "^[^\\s]+( [^\\s]+)*$",
          "type": "string"
        },
        "_bandCode": {
          "description": "Extensions for bandCode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "bandString": {
          "description": "The band of this end interval.",
          "pattern": "^^[\\s\\S]+$$",
          "type": "string"
        },
        "_bandString": {
          "description": "Extensions for bandString",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "subBandCode": {
          "description": "The sub-band of this end interval.",
          "pattern": "^[^\\s]+( [^\\s]+)*$",
          "type": "string"
        },
        "_subBandCode": {
          "description": "Extensions for subBandCode",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "subBandString": {
          "description": "The sub-band of this end interval.",
          "pattern": "^^[\\s\\S]+$$",
          "type": "string"
        },
        "_subBandString": {
          "description": "Extensions for subBandString",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_Representation": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "focus": {
          "description": "The domain concept that is the focus of the representation. This element is used to disambiguate the representations of the “reference” and the “alternate” alleles at a given location, for example.",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "code": {
          "description": "A code (e.g., sequence accession number) used to represent a molecular entity.",
          "items": {
            "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
          },
          "type": "array"
        },
        "literal": {
          "description": "A molecular entity defined as a string literal.",
          "$ref": "#/definitions/MolecularDefinition_Literal"
        },
        "resolvable": {
          "description": "A resolvable representation of a molecular entity, which may be specified as a URI and/or attached document (in a defined format).",
          "$ref": "Reference.schema.json#/definitions/Reference"
        },
        "extracted": {
          "description": "A molecular entity that is represented as a portion of a different entity. For example, this element can represent a subsequence (e.g., genetic region) that is part of and conceptually extracted from a longer sequence (e.g., chromosome sequence). The “parent” entity is specified in startingMolecule and the location of the intended molecular entity on the parent entity is defined by coordinateInterval.",
          "$ref": "#/definitions/MolecularDefinition_Extracted"
        },
        "repeated": {
          "description": "A representation of a molecular entity that is expressed as a number of copies of a repeated motif.",
          "$ref": "#/definitions/MolecularDefinition_Repeated"
        },
        "concatenated": {
          "description": "A representation comprised of an ordered concatenation of two or more molecular entities.",
          "$ref": "#/definitions/MolecularDefinition_Concatenated"
        },
        "relative": {
          "description": "A molecular entity represented as an ordered series of edits on a specified starting entity. This representation can be used to define one entity relative to another.",
          "$ref": "#/definitions/MolecularDefinition_Relative"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_Literal": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "encoding": {
          "description": "The encoding used for the expression of the entity. For a primary sequence, this element represents the alphabet used (e.g., 1 character DNA without ambiguity codes, 3 character amino acid codes).",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "value": {
          "description": "A string literal representation of the molecular entity, using a specific encoding. For example, this may be the primary sequence of a strand of DNA.",
          "$ref": "#/definitions/string"
        },
        "_value": {
          "description": "Extensions for value",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_Extracted": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "startingMolecule": {
          "description": "A reference to the molecular entity that serves as the conceptual \u0027parent\u0027 from which the intended entity is derived. For example, this could be a chromosome sequence on which a coordinateInterval is defined.",
          "$ref": "Reference.schema.json#/definitions/Reference"
        },
        "coordinateInterval": {
          "description": "The interval on startingMolecule that defines the portion to be extracted in order to create the intended entity.",
          "$ref": "#/definitions/MolecularDefinition_CoordinateInterval1"
        },
        "reverseComplement": {
          "description": "A flag that indicates whether the extracted sequence should be reverse complemented in order to produce the intended entity. This element is only relevant to molecular entities that support the concept of reverse complement (e.g., double stranded DNA).",
          "$ref": "#/definitions/boolean"
        },
        "_reverseComplement": {
          "description": "Extensions for reverseComplement",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "type": "object",
      "additionalProperties": false,
      "required": [
        "startingMolecule"
      ]
    },
    "MolecularDefinition_CoordinateInterval1": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "coordinateSystem": {
          "description": "The coordinate system used to define the location, which may vary depending on application or context of use.",
          "$ref": "#/definitions/MolecularDefinition_CoordinateSystem1"
        },
        "startQuantity": {
          "description": "The start location of the interval expressed as a precise coordinate (Quantity) or expressed as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported.",
          "$ref": "Quantity.schema.json#/definitions/Quantity"
        },
        "startRange": {
          "description": "The start location of the interval expressed as a precise coordinate (Quantity) or expressed as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported.",
          "$ref": "Range.schema.json#/definitions/Range"
        },
        "endQuantity": {
          "description": "The end location of the interval expressed as a precise coordinate (Quantity) or as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported..",
          "$ref": "Quantity.schema.json#/definitions/Quantity"
        },
        "endRange": {
          "description": "The end location of the interval expressed as a precise coordinate (Quantity) or as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported..",
          "$ref": "Range.schema.json#/definitions/Range"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_CoordinateSystem1": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "system": {
          "description": "A definition of the coordinate system. Examples include 1-based character counting, and 0-based interval counting.",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "origin": {
          "description": "The location of the origin (0 or 1, depending on the coordinate system). For example, this could specify the origin is at the start of the sequence (e.g., 5’ end or N-terminus), the beginning of a designated feature (e.g., A in the ATG translation initiation codon), or the end of a designated feature (e.g., 3’ end of an exon, from which an offset is calculated into the following intron).",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "normalizationMethod": {
          "description": "The normalization method used for determining a location within the coordinate system. Examples include left shift (e.g., VCF), right shift (e.g., HGVS), or fully justified (e.g., VOCA).",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_Repeated": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "sequenceMotif": {
          "description": "The motif that is repeated in tandem, which ultimately defines the intended molecular entity.",
          "$ref": "Reference.schema.json#/definitions/Reference"
        },
        "copyCount": {
          "description": "The number of times the motif is repeated to create the intended molecular entity.",
          "$ref": "#/definitions/integer"
        },
        "_copyCount": {
          "description": "Extensions for copyCount",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "type": "object",
      "additionalProperties": false,
      "required": [
        "sequenceMotif"
      ]
    },
    "MolecularDefinition_Concatenated": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "sequenceElement": {
          "description": "One of the concatenated entities within the concatenated representation.",
          "items": {
            "$ref": "#/definitions/MolecularDefinition_SequenceElement"
          },
          "type": "array"
        }
      },
      "type": "object",
      "additionalProperties": false,
      "required": [
        "sequenceElement"
      ]
    },
    "MolecularDefinition_SequenceElement": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "sequence": {
          "description": "A reference to the sequence that defines this specific concatenated element.",
          "$ref": "Reference.schema.json#/definitions/Reference"
        },
        "ordinalIndex": {
          "description": "The ordinal index of the element within the concatenated representation.",
          "$ref": "#/definitions/integer"
        },
        "_ordinalIndex": {
          "description": "Extensions for ordinalIndex",
          "$ref": "Element.schema.json#/definitions/Element"
        }
      },
      "type": "object",
      "additionalProperties": false,
      "required": [
        "sequence"
      ]
    },
    "MolecularDefinition_Relative": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "startingMolecule": {
          "description": "The molecular entity that serves as the starting point, on which edits will be applied.",
          "$ref": "Reference.schema.json#/definitions/Reference"
        },
        "edit": {
          "description": "A defined edit (change) to be applied to the molecular entity.",
          "items": {
            "$ref": "#/definitions/MolecularDefinition_Edit"
          },
          "type": "array"
        }
      },
      "type": "object",
      "additionalProperties": false,
      "required": [
        "startingMolecule"
      ]
    },
    "MolecularDefinition_Edit": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "editOrder": {
          "description": "Defines the order of edits when multiple edits are to be applied to the startingMolecule. This is important when edits may overlap (intervals) or when edits change the length of the entity.",
          "$ref": "#/definitions/integer"
        },
        "_editOrder": {
          "description": "Extensions for editOrder",
          "$ref": "Element.schema.json#/definitions/Element"
        },
        "coordinateInterval": {
          "description": "The interval on startingMolecule that defines the portion to be extracted in order to create the intended entity.",
          "$ref": "#/definitions/MolecularDefinition_CoordinateInterval2"
        },
        "replacementMolecule": {
          "description": "The molecular entity that serves as the replacement in the edit operation. After the edit has been applied, the state of the entity at the specified coordinateInterval is defined by the state of the replacementMolecule.",
          "$ref": "Reference.schema.json#/definitions/Reference"
        },
        "replacedMolecule": {
          "description": "The portion of the molecular entity that is replaced by the replacementMolecule as a result of the edit. The value of this element can be derived as the state of the entity at the specified coordinateInterval, prior to the edit being applied. It is provided for convenience.",
          "$ref": "Reference.schema.json#/definitions/Reference"
        }
      },
      "type": "object",
      "additionalProperties": false,
      "required": [
        "replacementMolecule"
      ]
    },
    "MolecularDefinition_CoordinateInterval2": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "coordinateSystem": {
          "description": "The coordinate system used to define the location, which may vary depending on application or context of use.",
          "$ref": "#/definitions/MolecularDefinition_CoordinateSystem2"
        },
        "startQuantity": {
          "description": "The start location of the interval expressed as a precise coordinate (Quantity) or expressed as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported.",
          "$ref": "Quantity.schema.json#/definitions/Quantity"
        },
        "startRange": {
          "description": "The start location of the interval expressed as a precise coordinate (Quantity) or expressed as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported.",
          "$ref": "Range.schema.json#/definitions/Range"
        },
        "endQuantity": {
          "description": "The end location of the interval expressed as a precise coordinate (Quantity) or as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported..",
          "$ref": "Quantity.schema.json#/definitions/Quantity"
        },
        "endRange": {
          "description": "The end location of the interval expressed as a precise coordinate (Quantity) or as a range (Range) that is defined by low (range start) and high (range end). Open-ended ranges, where one end is unbounded, may be supported..",
          "$ref": "Range.schema.json#/definitions/Range"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "MolecularDefinition_CoordinateSystem2": {
      "description": "Definitional content for a molecular entity, such as a nucleotide or protein sequence.",
      "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 managable, 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 and/or the understanding of the containing element\u0027s descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, 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"
        },
        "system": {
          "description": "A definition of the coordinate system. Examples include 1-based character counting, and 0-based interval counting.",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "origin": {
          "description": "The location of the origin (0 or 1, depending on the coordinate system). For example, this could specify the origin is at the start of the sequence (e.g., 5’ end or N-terminus), the beginning of a designated feature (e.g., A in the ATG translation initiation codon), or the end of a designated feature (e.g., 3’ end of an exon, from which an offset is calculated into the following intron).",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        },
        "normalizationMethod": {
          "description": "The normalization method used for determining a location within the coordinate system. Examples include left shift (e.g., VCF), right shift (e.g., HGVS), or fully justified (e.g., VOCA).",
          "$ref": "CodeableConcept.schema.json#/definitions/CodeableConcept"
        }
      },
      "type": "object",
      "additionalProperties": false
    }
  }
}