{
   "$defs": {
      "Activity": {
         "additionalProperties": false,
         "description": "An activity is something that occurs over a period of time and acts upon or with entities; it may include consuming, processing, transforming, modifying, relocating, using, or generating entities.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Activity",
         "type": "object"
      },
      "Agent": {
         "additionalProperties": false,
         "description": "person, group, organization or project that provides a piece of information (i.e. a knowledge association)",
         "properties": {
            "address": {
               "description": "the particulars of the place where someone or an organization is situated.  For now, this slot is a simple text \"blob\" containing all relevant details of the given location for fitness of purpose. For the moment, this \"address\" can include other contact details such as email and phone number(?).",
               "type": "string"
            },
            "affiliation": {
               "description": "a professional relationship between one provider (often a person) within another provider (often an organization). Target provider identity should be specified by a CURIE. Providers may have multiple affiliations.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "Different classes of agents have distinct preferred identifiers. For publishers, use the ISBN publisher code. See https://grp.isbn-international.org/ for publisher code lookups. For editors, authors and  individual providers, use the individual's ORCID if available; Otherwise, a ScopusID, ResearchID or Google Scholar ID ('GSID') may be used if the author ORCID is unknown. Institutional agents could be identified by an International Standard Name Identifier ('ISNI') code.",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "it is recommended that an author's 'name' property be formatted as \"surname, firstname initial.\"",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "category",
            "id"
         ],
         "title": "Agent",
         "type": "object"
      },
      "AnatomicalEntity": {
         "additionalProperties": false,
         "description": "A subcellular location, cell type or gross anatomical part",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "AnatomicalEntity",
         "type": "object"
      },
      "AnatomicalEntityToAnatomicalEntityOntogenicAssociation": {
         "additionalProperties": false,
         "description": "A relationship between two anatomical entities where the relationship is ontogenic, i.e. the two entities are related by development. A number of different relationship types can be used to specify the precise nature of the relationship.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the structure at an earlier time",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "the structure at a later time",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "AnatomicalEntityToAnatomicalEntityOntogenicAssociation",
         "type": "object"
      },
      "AnatomicalEntityToAnatomicalEntityPartOfAssociation": {
         "additionalProperties": false,
         "description": "A relationship between two anatomical entities where the relationship is mereological, i.e the two entities are related by parthood. This includes relationships between cellular components and cells, between cells and tissues, tissues and whole organisms",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the whole",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "the part",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "AnatomicalEntityToAnatomicalEntityPartOfAssociation",
         "type": "object"
      },
      "Article": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "authors": {
               "description": "connects an publication to the list of authors who contributed to the publication. This property should be a comma-delimited list of author names. It is recommended that an author's name be formatted as \"surname, firstname initial.\".   Note that this property is a node annotation expressing the citation list of authorship which might typically otherwise be more completely documented in biolink:PublicationToProviderAssociation defined edges which point to full details about an author and possibly, some qualifiers which clarify the specific status of a given author in the publication.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "Different kinds of publication subtypes will have different preferred identifiers (curies when feasible). Precedence of identifiers for scientific articles is as follows: PMID if available; DOI if not; actual alternate CURIE otherwise. Enclosing publications (i.e. referenced by 'published in' node property) such as books and journals, should have industry-standard identifier such as from ISBN and ISSN.",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "iso_abbreviation": {
               "description": "Optional value, if used locally as a convenience, is set to the iso abbreviation of the 'published in' parent.",
               "type": "string"
            },
            "issue": {
               "description": "issue of a newspaper, a scientific journal or magazine for reference purpose",
               "type": "string"
            },
            "keywords": {
               "description": "keywords tagging a publication",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "license": {
               "type": "string"
            },
            "mesh_terms": {
               "description": "mesh terms tagging a publication",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "name": {
               "description": "the 'title' of the publication is generally recorded in the 'name' property (inherited from NamedThing). The field name 'title' is now also tagged as an acceptable alias for the node property 'name' (just in case).",
               "type": "string"
            },
            "pages": {
               "description": "When a 2-tuple of page numbers are provided, they represent the start and end page of the publication within its parent publication context. For books, this may be set to the total number of pages of the book.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "published_in": {
               "description": "The enclosing parent serial containing the article should have industry-standard identifier from ISSN.",
               "type": "string"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "summary": {
               "description": "executive  summary of a publication",
               "type": "string"
            },
            "type": {
               "description": "Ontology term for publication type may be drawn from Dublin Core types (https://www.dublincore.org/specifications/dublin-core/dcmi-type-vocabulary/), FRBR-aligned Bibliographic Ontology (https://sparontologies.github.io/fabio/current/fabio.html), the MESH publication types (https://www.nlm.nih.gov/mesh/pubtypes.html), the Confederation of Open Access Repositories (COAR) Controlled Vocabulary for Resource Type Genres (http://vocabularies.coar-repositories.org/documentation/resource_types/), Wikidata (https://www.wikidata.org/wiki/Wikidata:Publication_types), or equivalent publication type ontology. When a given publication type ontology term is used within a given knowledge graph, then the CURIE identified term must be documented in the graph as a concept node of biolink:category biolink:OntologyClass.",
               "type": "string"
            },
            "volume": {
               "description": "volume of a book or music release in a collection/series or a published collection of journal issues in a serial publication",
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "category",
            "id",
            "type",
            "published_in"
         ],
         "title": "Article",
         "type": "object"
      },
      "Association": {
         "additionalProperties": false,
         "description": "A typed association between two entities, supported by evidence",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "object",
            "relation"
         ],
         "title": "Association",
         "type": "object"
      },
      "Attribute": {
         "additionalProperties": false,
         "description": "A property or characteristic of an entity. For example, an apple may have properties such as color, shape, age, crispiness. An environmental sample may have attributes such as depth, lat, long, material.",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "Attribute",
         "type": "object"
      },
      "Behavior": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Behavior",
         "type": "object"
      },
      "BehaviorToBehavioralFeatureAssociation": {
         "additionalProperties": false,
         "description": "An association between an aggregate behavior and a behavioral feature manifested by the individual exhibited or has exhibited the behavior.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "behavioral feature that is the object of the association",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "sex_qualifier": {
               "$ref": "#/$defs/BiologicalSex",
               "description": "a qualifier used in a phenotypic association to state whether the association is specific to a particular sex."
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "behavior that is the subject of the association",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "relation",
            "subject",
            "object"
         ],
         "title": "BehaviorToBehavioralFeatureAssociation",
         "type": "object"
      },
      "BehavioralExposure": {
         "additionalProperties": false,
         "description": "A behavioral exposure is a factor relating to behavior impacting an individual.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "BehavioralExposure",
         "type": "object"
      },
      "BehavioralFeature": {
         "additionalProperties": false,
         "description": "A phenotypic feature which is behavioral in nature.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "BehavioralFeature",
         "type": "object"
      },
      "BehavioralOutcome": {
         "additionalProperties": false,
         "description": "An outcome resulting from an exposure event which is the manifestation of human behavior.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "BehavioralOutcome",
         "type": "object"
      },
      "BiologicalProcess": {
         "additionalProperties": false,
         "description": "One or more causally connected executions of molecular functions",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "BiologicalProcess",
         "type": "object"
      },
      "BiologicalProcessOrActivity": {
         "additionalProperties": false,
         "description": "Either an individual molecular activity, or a collection of causally connected molecular activities in a biological system.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "BiologicalProcessOrActivity",
         "type": "object"
      },
      "BiologicalSex": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "BiologicalSex",
         "type": "object"
      },
      "BioticExposure": {
         "additionalProperties": false,
         "description": "An external biotic exposure is an intake of (sometimes pathological) biological organisms (including viruses).",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_taxonomic_rank": {
               "$ref": "#/$defs/TaxonomicRank"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subclass_of": {
               "description": "subclass of holds between two taxa, e.g. human subclass of mammal",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "BioticExposure",
         "type": "object"
      },
      "Book": {
         "additionalProperties": false,
         "description": "This class may rarely be instantiated except if use cases of a given knowledge graph support its utility.",
         "properties": {
            "authors": {
               "description": "connects an publication to the list of authors who contributed to the publication. This property should be a comma-delimited list of author names. It is recommended that an author's name be formatted as \"surname, firstname initial.\".   Note that this property is a node annotation expressing the citation list of authorship which might typically otherwise be more completely documented in biolink:PublicationToProviderAssociation defined edges which point to full details about an author and possibly, some qualifiers which clarify the specific status of a given author in the publication.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "Books should have industry-standard identifier such as from ISBN.",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "keywords": {
               "description": "keywords tagging a publication",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "license": {
               "type": "string"
            },
            "mesh_terms": {
               "description": "mesh terms tagging a publication",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "name": {
               "description": "the 'title' of the publication is generally recorded in the 'name' property (inherited from NamedThing). The field name 'title' is now also tagged as an acceptable alias for the node property 'name' (just in case).",
               "type": "string"
            },
            "pages": {
               "description": "When a 2-tuple of page numbers are provided, they represent the start and end page of the publication within its parent publication context. For books, this may be set to the total number of pages of the book.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "summary": {
               "description": "executive  summary of a publication",
               "type": "string"
            },
            "type": {
               "description": "Should generally be set to an ontology class defined term for 'book'.",
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "category",
            "id",
            "type"
         ],
         "title": "Book",
         "type": "object"
      },
      "BookChapter": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "authors": {
               "description": "connects an publication to the list of authors who contributed to the publication. This property should be a comma-delimited list of author names. It is recommended that an author's name be formatted as \"surname, firstname initial.\".   Note that this property is a node annotation expressing the citation list of authorship which might typically otherwise be more completely documented in biolink:PublicationToProviderAssociation defined edges which point to full details about an author and possibly, some qualifiers which clarify the specific status of a given author in the publication.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "chapter": {
               "description": "chapter of a book",
               "type": "string"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "Different kinds of publication subtypes will have different preferred identifiers (curies when feasible). Precedence of identifiers for scientific articles is as follows: PMID if available; DOI if not; actual alternate CURIE otherwise. Enclosing publications (i.e. referenced by 'published in' node property) such as books and journals, should have industry-standard identifier such as from ISBN and ISSN.",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "keywords": {
               "description": "keywords tagging a publication",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "license": {
               "type": "string"
            },
            "mesh_terms": {
               "description": "mesh terms tagging a publication",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "name": {
               "description": "the 'title' of the publication is generally recorded in the 'name' property (inherited from NamedThing). The field name 'title' is now also tagged as an acceptable alias for the node property 'name' (just in case).",
               "type": "string"
            },
            "pages": {
               "description": "When a 2-tuple of page numbers are provided, they represent the start and end page of the publication within its parent publication context. For books, this may be set to the total number of pages of the book.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "published_in": {
               "description": "The enclosing parent book containing the chapter should have industry-standard identifier from ISBN.",
               "type": "string"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "summary": {
               "description": "executive  summary of a publication",
               "type": "string"
            },
            "type": {
               "description": "Ontology term for publication type may be drawn from Dublin Core types (https://www.dublincore.org/specifications/dublin-core/dcmi-type-vocabulary/), FRBR-aligned Bibliographic Ontology (https://sparontologies.github.io/fabio/current/fabio.html), the MESH publication types (https://www.nlm.nih.gov/mesh/pubtypes.html), the Confederation of Open Access Repositories (COAR) Controlled Vocabulary for Resource Type Genres (http://vocabularies.coar-repositories.org/documentation/resource_types/), Wikidata (https://www.wikidata.org/wiki/Wikidata:Publication_types), or equivalent publication type ontology. When a given publication type ontology term is used within a given knowledge graph, then the CURIE identified term must be documented in the graph as a concept node of biolink:category biolink:OntologyClass.",
               "type": "string"
            },
            "volume": {
               "description": "volume of a book or music release in a collection/series or a published collection of journal issues in a serial publication",
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "category",
            "id",
            "type",
            "published_in"
         ],
         "title": "BookChapter",
         "type": "object"
      },
      "Carbohydrate": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Carbohydrate",
         "type": "object"
      },
      "Case": {
         "additionalProperties": false,
         "description": "An individual (human) organism that has a patient role in some clinical context.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Case",
         "type": "object"
      },
      "CaseToPhenotypicFeatureAssociation": {
         "additionalProperties": false,
         "description": "An association between a case (e.g. individual patient) and a phenotypic feature in which the individual has or has had the phenotype.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "sex_qualifier": {
               "$ref": "#/$defs/BiologicalSex",
               "description": "a qualifier used in a phenotypic association to state whether the association is specific to a particular sex."
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "object",
            "relation"
         ],
         "title": "CaseToPhenotypicFeatureAssociation",
         "type": "object"
      },
      "Cell": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Cell",
         "type": "object"
      },
      "CellLine": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "CellLine",
         "type": "object"
      },
      "CellLineAsAModelOfDiseaseAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "A cell line derived from an organismal entity with a disease state that is used as a model of that disease.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "object",
            "relation",
            "subject"
         ],
         "title": "CellLineAsAModelOfDiseaseAssociation",
         "type": "object"
      },
      "CellLineToDiseaseOrPhenotypicFeatureAssociation": {
         "additionalProperties": false,
         "description": "An relationship between a cell line and a disease or a phenotype, where the cell line is derived from an individual with that disease or phenotype.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "object",
            "relation",
            "subject"
         ],
         "title": "CellLineToDiseaseOrPhenotypicFeatureAssociation",
         "type": "object"
      },
      "CellularComponent": {
         "additionalProperties": false,
         "description": "A location in or around a cell",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "CellularComponent",
         "type": "object"
      },
      "ChemicalExposure": {
         "additionalProperties": false,
         "description": "A chemical exposure is an intake of a particular chemical substance, other than a drug.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ChemicalExposure",
         "type": "object"
      },
      "ChemicalSubstance": {
         "additionalProperties": false,
         "description": "May be a chemical entity or a formulation with a chemical entity as active ingredient, or a complex material with multiple chemical entities as part",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ChemicalSubstance",
         "type": "object"
      },
      "ChemicalToChemicalAssociation": {
         "additionalProperties": false,
         "description": "A relationship between two chemical entities. This can encompass actual interactions as well as temporal causal edges, e.g. one chemical converted to another.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the chemical element that is the target of the statement",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "relation",
            "object"
         ],
         "title": "ChemicalToChemicalAssociation",
         "type": "object"
      },
      "ChemicalToChemicalDerivationAssociation": {
         "additionalProperties": false,
         "description": "A causal relationship between two chemical entities, where the subject represents the upstream entity and the object represents the downstream. For any such association there is an implicit reaction:\n  IF\n  R has-input C1 AND\n  R has-output C2 AND\n  R enabled-by P AND\n  R type Reaction\n  THEN\n  C1 derives-into C2 <<catalyst qualifier P>>",
         "properties": {
            "catalyst_qualifier": {
               "description": "this connects the derivation edge to the molecular entity that catalyzes the reaction that causes the subject chemical to transform into the object chemical.",
               "items": {
                  "$ref": "#/$defs/MacromolecularMachineMixin"
               },
               "type": "array"
            },
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the downstream chemical entity",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "the upstream chemical entity",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "ChemicalToChemicalDerivationAssociation",
         "type": "object"
      },
      "ChemicalToDiseaseOrPhenotypicFeatureAssociation": {
         "additionalProperties": false,
         "description": "An interaction between a chemical entity and a phenotype or disease, where the presence of the chemical gives rise to or exacerbates the phenotype.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the disease or phenotype that is affected by the chemical",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "relation",
            "object"
         ],
         "title": "ChemicalToDiseaseOrPhenotypicFeatureAssociation",
         "type": "object"
      },
      "ChemicalToGeneAssociation": {
         "additionalProperties": false,
         "description": "An interaction between a chemical entity and a gene or gene product.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "the gene or gene product that is affected by the chemical."
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "relation",
            "object"
         ],
         "title": "ChemicalToGeneAssociation",
         "type": "object"
      },
      "ChemicalToPathwayAssociation": {
         "additionalProperties": false,
         "description": "An interaction between a chemical entity and a biological process or pathway.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the pathway that is affected by the chemical",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "relation",
            "object"
         ],
         "title": "ChemicalToPathwayAssociation",
         "type": "object"
      },
      "ClinicalAttribute": {
         "additionalProperties": false,
         "description": "Attributes relating to a clinical manifestation",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "ClinicalAttribute",
         "type": "object"
      },
      "ClinicalCourse": {
         "additionalProperties": false,
         "description": "The course a disease typically takes from its onset, progression in time, and eventual resolution or death of the affected individual",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "ClinicalCourse",
         "type": "object"
      },
      "ClinicalEntity": {
         "additionalProperties": false,
         "description": "Any entity or process that exists in the clinical domain and outside the biological realm. Diseases are placed under biological entities",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ClinicalEntity",
         "type": "object"
      },
      "ClinicalFinding": {
         "additionalProperties": false,
         "description": "this category is currently considered broad enough to tag clinical lab measurements and other biological attributes taken as 'clinical traits' with some statistical score, for example, a p value in genetic associations.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/ClinicalAttribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ClinicalFinding",
         "type": "object"
      },
      "ClinicalIntervention": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ClinicalIntervention",
         "type": "object"
      },
      "ClinicalMeasurement": {
         "additionalProperties": false,
         "description": "A clinical measurement is a special kind of attribute which results from a laboratory observation from a subject individual or sample. Measurements can be connected to their subject by the 'has attribute' slot.",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "ClinicalMeasurement",
         "type": "object"
      },
      "ClinicalModifier": {
         "additionalProperties": false,
         "description": "Used to characterize and specify the phenotypic abnormalities defined in the phenotypic abnormality sub-ontology, with respect to severity, laterality, and other aspects",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "ClinicalModifier",
         "type": "object"
      },
      "ClinicalTrial": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ClinicalTrial",
         "type": "object"
      },
      "CodingSequence": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "CodingSequence",
         "type": "object"
      },
      "Cohort": {
         "additionalProperties": false,
         "description": "A group of people banded together or treated as a group who share common characteristics. A cohort 'study' is a particular form of longitudinal study that samples a cohort, performing a cross-section at intervals through time.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Cohort",
         "type": "object"
      },
      "ComplexChemicalExposure": {
         "additionalProperties": false,
         "description": "A complex chemical exposure is an intake of a chemical mixture (e.g. gasoline), other than a drug.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_constituent": {
               "description": "one or more chemical substances within a mixture",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ComplexChemicalExposure",
         "type": "object"
      },
      "ConfidenceLevel": {
         "additionalProperties": false,
         "description": "Level of confidence in a statement",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "license": {
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ConfidenceLevel",
         "type": "object"
      },
      "ContributorAssociation": {
         "additionalProperties": false,
         "description": "Any association between an entity (such as a publication) and various agents that contribute to its realisation",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "agent helping to realise the given entity (e.g. such as a publication)",
               "type": "string"
            },
            "predicate": {
               "description": "generally one of the predicate values 'provider', 'publisher', 'editor' or 'author'",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "this field can be used to annotate special characteristics of an agent relationship, such as the fact that a given author agent of a publication is the 'corresponding author'",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "information content entity which an agent has helped realise",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "predicate",
            "object"
         ],
         "title": "ContributorAssociation",
         "type": "object"
      },
      "Dataset": {
         "additionalProperties": false,
         "description": "an item that refers to a collection of data from a data source.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "license": {
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Dataset",
         "type": "object"
      },
      "DatasetDistribution": {
         "additionalProperties": false,
         "description": "an item that holds distribution level information about a dataset.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "distribution_download_url": {
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "license": {
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "DatasetDistribution",
         "type": "object"
      },
      "DatasetSummary": {
         "additionalProperties": false,
         "description": "an item that holds summary level information about a dataset.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "license": {
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "source_logo": {
               "type": "string"
            },
            "source_web_page": {
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "DatasetSummary",
         "type": "object"
      },
      "DatasetVersion": {
         "additionalProperties": false,
         "description": "an item that holds version level information about a dataset.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_dataset": {
               "type": "string"
            },
            "has_distribution": {
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "ingest_date": {
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "license": {
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "DatasetVersion",
         "type": "object"
      },
      "Death": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Death",
         "type": "object"
      },
      "Device": {
         "additionalProperties": false,
         "description": "A thing made or adapted for a particular purpose, especially a piece of mechanical or electronic equipment",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Device",
         "type": "object"
      },
      "Disease": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Disease",
         "type": "object"
      },
      "DiseaseOrPhenotypicFeature": {
         "additionalProperties": false,
         "description": "Either one of a disease or an individual phenotypic feature. Some knowledge resources such as Monarch treat these as distinct, others such as MESH conflate.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "DiseaseOrPhenotypicFeature",
         "type": "object"
      },
      "DiseaseOrPhenotypicFeatureAssociationToLocationAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "relation",
            "object"
         ],
         "title": "DiseaseOrPhenotypicFeatureAssociationToLocationAssociation",
         "type": "object"
      },
      "DiseaseOrPhenotypicFeatureExposure": {
         "additionalProperties": false,
         "description": "A disease or phenotypic feature state, when viewed as an exposure, represents an precondition, leading to or influencing an outcome, e.g. HIV predisposing an individual to infections; a relative deficiency of skin pigmentation predisposing an individual to skin cancer.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "DiseaseOrPhenotypicFeatureExposure",
         "type": "object"
      },
      "DiseaseOrPhenotypicFeatureOutcome": {
         "additionalProperties": false,
         "description": "Physiological outcomes resulting from an exposure event which is the manifestation of a disease or other characteristic phenotype.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "DiseaseOrPhenotypicFeatureOutcome",
         "type": "object"
      },
      "DiseaseOrPhenotypicFeatureToLocationAssociation": {
         "additionalProperties": false,
         "description": "An association between either a disease or a phenotypic feature and an anatomical entity, where the disease/feature manifests in that site.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "anatomical entity in which the disease or feature is found.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "relation",
            "object"
         ],
         "title": "DiseaseOrPhenotypicFeatureToLocationAssociation",
         "type": "object"
      },
      "DiseaseToExposureEventAssociation": {
         "additionalProperties": false,
         "description": "An association between an exposure event and a disease.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "object",
            "relation"
         ],
         "title": "DiseaseToExposureEventAssociation",
         "type": "object"
      },
      "DiseaseToPhenotypicFeatureAssociation": {
         "additionalProperties": false,
         "description": "An association between a disease and a phenotypic feature in which the phenotypic feature is associated with the disease in some way.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "sex_qualifier": {
               "$ref": "#/$defs/BiologicalSex",
               "description": "a qualifier used in a phenotypic association to state whether the association is specific to a particular sex."
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "object",
            "relation"
         ],
         "title": "DiseaseToPhenotypicFeatureAssociation",
         "type": "object"
      },
      "Drug": {
         "additionalProperties": false,
         "description": "A substance intended for use in the diagnosis, cure, mitigation, treatment, or prevention of disease",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_constituent": {
               "description": "one or more chemical substances within a mixture",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Drug",
         "type": "object"
      },
      "DrugExposure": {
         "additionalProperties": false,
         "description": "A drug exposure is an intake of a particular drug.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_constituent": {
               "description": "one or more chemical substances within a mixture",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "DrugExposure",
         "type": "object"
      },
      "DrugToGeneAssociation": {
         "additionalProperties": false,
         "description": "An interaction between a drug and a gene or gene product.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "the gene or gene product that is affected by the drug"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "relation",
            "object"
         ],
         "title": "DrugToGeneAssociation",
         "type": "object"
      },
      "DrugToGeneInteractionExposure": {
         "additionalProperties": false,
         "description": "drug to gene interaction exposure is a drug exposure is where the interactions of the drug with specific genes are known to constitute an 'exposure' to the organism, leading to or influencing an outcome.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_constituent": {
               "description": "one or more chemical substances within a mixture",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_gene_or_gene_product": {
               "description": "connects an entity with one or more gene or gene products",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "DrugToGeneInteractionExposure",
         "type": "object"
      },
      "EnvironmentalExposure": {
         "additionalProperties": false,
         "description": "A environmental exposure is a factor relating to abiotic processes in the environment including sunlight (UV-B), atmospheric (heat, cold, general pollution) and water-born contaminants.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "EnvironmentalExposure",
         "type": "object"
      },
      "EnvironmentalFeature": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "EnvironmentalFeature",
         "type": "object"
      },
      "EnvironmentalFoodContaminant": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "EnvironmentalFoodContaminant",
         "type": "object"
      },
      "EnvironmentalProcess": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "EnvironmentalProcess",
         "type": "object"
      },
      "EpidemiologicalOutcome": {
         "additionalProperties": false,
         "description": "An epidemiological outcome, such as societal disease burden, resulting from an exposure event.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "EpidemiologicalOutcome",
         "type": "object"
      },
      "EvidenceType": {
         "additionalProperties": false,
         "description": "Class of evidence that supports an association",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "license": {
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "EvidenceType",
         "type": "object"
      },
      "Exon": {
         "additionalProperties": false,
         "description": "A region of the transcript sequence within a gene which is not removed from the primary RNA transcript by RNA splicing.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Exon",
         "type": "object"
      },
      "ExonToTranscriptRelationship": {
         "additionalProperties": false,
         "description": "A transcript is formed from multiple exons",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "relation",
            "subject",
            "object"
         ],
         "title": "ExonToTranscriptRelationship",
         "type": "object"
      },
      "ExposureEventToOutcomeAssociation": {
         "additionalProperties": false,
         "description": "An association between an exposure event and an outcome.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_population_context": {
               "description": "a biological population (general, study, cohort, etc.) with a specific set of characteristics to constrain an association.",
               "type": "string"
            },
            "has_temporal_context": {
               "description": "a constraint of time placed upon the truth value of an association.",
               "format": "time",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "object",
            "relation"
         ],
         "title": "ExposureEventToOutcomeAssociation",
         "type": "object"
      },
      "ExposureEventToPhenotypicFeatureAssociation": {
         "additionalProperties": false,
         "description": "Any association between an environment and a phenotypic feature, where being in the environment influences the phenotype.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "sex_qualifier": {
               "$ref": "#/$defs/BiologicalSex",
               "description": "a qualifier used in a phenotypic association to state whether the association is specific to a particular sex."
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/ExposureEvent",
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object."
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "object",
            "relation",
            "subject"
         ],
         "title": "ExposureEventToPhenotypicFeatureAssociation",
         "type": "object"
      },
      "Food": {
         "additionalProperties": false,
         "description": "A substance consumed by a living organism as a source of nutrition",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_constituent": {
               "description": "one or more chemical substances within a mixture",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Food",
         "type": "object"
      },
      "FoodAdditive": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "FoodAdditive",
         "type": "object"
      },
      "FoodComponent": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "FoodComponent",
         "type": "object"
      },
      "FunctionalAssociation": {
         "additionalProperties": false,
         "description": "An association between a macromolecular machine mixin (gene, gene product or complex of gene products) and either a molecular activity, a biological process or a cellular location in which a function is executed.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "$ref": "#/$defs/GeneOntologyClass",
               "description": "class describing the activity, process or localization of the gene product"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/MacromolecularMachineMixin",
               "description": "gene, product or macromolecular complex mixin that has the function associated with the GO term"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "relation",
            "subject",
            "object"
         ],
         "title": "FunctionalAssociation",
         "type": "object"
      },
      "Gene": {
         "additionalProperties": false,
         "description": "A region (or regions) that includes all of the sequence elements necessary to encode a functional transcript. A gene locus may include regulatory regions, transcribed regions and/or other functional sequence regions.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "symbol": {
               "description": "Symbol for a particular thing",
               "type": "string"
            },
            "synonym": {
               "description": "Alternate human-readable names for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "type": {
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Gene",
         "type": "object"
      },
      "GeneAsAModelOfDiseaseAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "A gene that has a role in modeling the disease. This may be a model organism ortholog of a known disease gene, or it may be a gene whose mutants recapitulate core features of the disease."
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "object",
            "relation",
            "subject"
         ],
         "title": "GeneAsAModelOfDiseaseAssociation",
         "type": "object"
      },
      "GeneFamily": {
         "additionalProperties": false,
         "description": "any grouping of multiple genes or gene products related by common descent",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_gene_or_gene_product": {
               "description": "connects an entity with one or more gene or gene products",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "GeneFamily",
         "type": "object"
      },
      "GeneHasVariantThatContributesToDiseaseAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "sequence_variant_qualifier": {
               "description": "a qualifier used in an association with the variant",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "A gene that has a role in modeling the disease. This may be a model organism ortholog of a known disease gene, or it may be a gene whose mutants recapitulate core features of the disease."
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "object",
            "relation",
            "subject"
         ],
         "title": "GeneHasVariantThatContributesToDiseaseAssociation",
         "type": "object"
      },
      "GeneRegulatoryRelationship": {
         "additionalProperties": false,
         "description": "A regulatory relationship between two genes",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object."
            },
            "predicate": {
               "description": "the direction is always from regulator to regulated",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object."
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "predicate",
            "subject",
            "object"
         ],
         "title": "GeneRegulatoryRelationship",
         "type": "object"
      },
      "GeneToDiseaseAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "gene in which variation is correlated with the disease, may be protective or causative or associative, or as a model"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "object",
            "relation",
            "subject"
         ],
         "title": "GeneToDiseaseAssociation",
         "type": "object"
      },
      "GeneToExpressionSiteAssociation": {
         "additionalProperties": false,
         "description": "An association between a gene and an expression site, possibly qualified by stage/timing info.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "location in which the gene is expressed",
               "type": "string"
            },
            "predicate": {
               "description": "expression relationship",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "quantifier_qualifier": {
               "$ref": "#/$defs/OntologyClass",
               "description": "can be used to indicate magnitude, or also ranking"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "stage_qualifier": {
               "description": "stage at which the gene is expressed in the site",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "gene in which variation is correlated with the phenotypic feature"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "GeneToExpressionSiteAssociation",
         "type": "object"
      },
      "GeneToGeneCoexpressionAssociation": {
         "additionalProperties": false,
         "description": "Indicates that two genes are co-expressed, generally under the same conditions.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "expression_site": {
               "description": "location in which gene or protein expression takes place. May be cell, tissue, or organ.",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "the object gene in the association. If the relation is symmetric, subject vs object is arbitrary. We allow a gene product to stand as a proxy for the gene or vice versa."
            },
            "phenotypic_state": {
               "description": "in experiments (e.g. gene expression) assaying diseased or unhealthy tissue, the phenotypic state can be put here, e.g. MONDO ID. For healthy tissues, use XXX.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "quantifier_qualifier": {
               "$ref": "#/$defs/OntologyClass",
               "description": "Optional quantitative value indicating degree of expression."
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "stage_qualifier": {
               "description": "stage during which gene or protein expression of takes place.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "the subject gene in the association. If the relation is symmetric, subject vs object is arbitrary. We allow a gene product to stand as a proxy for the gene or vice versa."
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "GeneToGeneCoexpressionAssociation",
         "type": "object"
      },
      "GeneToGeneHomologyAssociation": {
         "additionalProperties": false,
         "description": "A homology association between two genes. May be orthology (in which case the species of subject and object should differ) or paralogy (in which case the species may be the same)",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "the object gene in the association. If the relation is symmetric, subject vs object is arbitrary. We allow a gene product to stand as a proxy for the gene or vice versa."
            },
            "predicate": {
               "description": "homology relationship type",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "the subject gene in the association. If the relation is symmetric, subject vs object is arbitrary. We allow a gene product to stand as a proxy for the gene or vice versa."
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "GeneToGeneHomologyAssociation",
         "type": "object"
      },
      "GeneToGeneProductRelationship": {
         "additionalProperties": false,
         "description": "A gene is transcribed and potentially translated to a gene product",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "$ref": "#/$defs/GeneProductMixin",
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object."
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "GeneToGeneProductRelationship",
         "type": "object"
      },
      "GeneToGoTermAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "$ref": "#/$defs/GeneOntologyClass",
               "description": "class describing the activity, process or localization of the gene product"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "gene, product or macromolecular complex that has the function associated with the GO term",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "relation",
            "subject",
            "object"
         ],
         "title": "GeneToGoTermAssociation",
         "type": "object"
      },
      "GeneToPhenotypicFeatureAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "sex_qualifier": {
               "$ref": "#/$defs/BiologicalSex",
               "description": "a qualifier used in a phenotypic association to state whether the association is specific to a particular sex."
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "gene in which variation is correlated with the phenotypic feature"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "object",
            "relation",
            "subject"
         ],
         "title": "GeneToPhenotypicFeatureAssociation",
         "type": "object"
      },
      "Genome": {
         "additionalProperties": false,
         "description": "A genome is the sum of genetic material within a cell or virion.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Genome",
         "type": "object"
      },
      "GenomicBackgroundExposure": {
         "additionalProperties": false,
         "description": "A genomic background exposure is where an individual's specific genomic background of genes, sequence variants or other pre-existing genomic conditions constitute a kind of 'exposure' to the organism, leading to or influencing an outcome.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "has_gene_or_gene_product": {
               "description": "connects an entity with one or more gene or gene products",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "GenomicBackgroundExposure",
         "type": "object"
      },
      "GenomicEntity": {
         "additionalProperties": false,
         "description": "an entity that can either be directly located on a genome (gene, transcript, exon, regulatory region) or is encoded in a genome (protein)",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "GenomicEntity",
         "type": "object"
      },
      "GenomicSequenceLocalization": {
         "additionalProperties": false,
         "description": "A relationship between a sequence feature and a genomic entity it is localized to. The reference entity may be a chromosome, chromosome region or information entity such as a contig.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "end_interbase_coordinate": {
               "description": "The position at which the subject genomic entity ends on the chromosome or other entity to which it is located on.",
               "type": "integer"
            },
            "genome_build": {
               "description": "The version of the genome on which a feature is located. For example, GRCh38 for Homo sapiens.",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "phase": {
               "description": "The phase for a coding sequence entity. For example, phase of a CDS as represented in a GFF3 with a value of 0, 1 or 2.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "start_interbase_coordinate": {
               "description": "The position at which the subject genomic entity starts on the chromosome or other entity to which it is located on.",
               "type": "integer"
            },
            "strand": {
               "description": "The strand on which a feature is located. Has a value of '+' (sense strand or forward strand) or '-' (anti-sense strand or reverse strand).",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "GenomicSequenceLocalization",
         "type": "object"
      },
      "Genotype": {
         "additionalProperties": false,
         "description": "An information content entity that describes a genome by specifying the total variation in genomic sequence and/or gene expression, relative to some established background",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "has_zygosity": {
               "$ref": "#/$defs/Zygosity"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Genotype",
         "type": "object"
      },
      "GenotypeAsAModelOfDiseaseAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "a disease that is associated with that genotype",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "E.g. is pathogenic for",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "A genotype that has a role in modeling the disease.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "predicate",
            "object",
            "subject"
         ],
         "title": "GenotypeAsAModelOfDiseaseAssociation",
         "type": "object"
      },
      "GenotypeToDiseaseAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "a disease that is associated with that genotype",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "E.g. is pathogenic for",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "a genotype that is associated in some way with a disease state",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "predicate",
            "object"
         ],
         "title": "GenotypeToDiseaseAssociation",
         "type": "object"
      },
      "GenotypeToGeneAssociation": {
         "additionalProperties": false,
         "description": "Any association between a genotype and a gene. The genotype have have multiple variants in that gene or a single one. There is no assumption of cardinality",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "gene implicated in genotype",
               "type": "string"
            },
            "predicate": {
               "description": "the relationship type used to connect genotype to gene",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "parent genotype",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "predicate",
            "subject",
            "object"
         ],
         "title": "GenotypeToGeneAssociation",
         "type": "object"
      },
      "GenotypeToGenotypePartAssociation": {
         "additionalProperties": false,
         "description": "Any association between one genotype and a genotypic entity that is a sub-component of it",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "child genotype",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "parent genotype",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "predicate",
            "subject",
            "object"
         ],
         "title": "GenotypeToGenotypePartAssociation",
         "type": "object"
      },
      "GenotypeToPhenotypicFeatureAssociation": {
         "additionalProperties": false,
         "description": "Any association between one genotype and a phenotypic feature, where having the genotype confers the phenotype, either in isolation or through environment",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "sex_qualifier": {
               "$ref": "#/$defs/BiologicalSex",
               "description": "a qualifier used in a phenotypic association to state whether the association is specific to a particular sex."
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "genotype that is associated with the phenotypic feature",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "object",
            "relation",
            "predicate",
            "subject"
         ],
         "title": "GenotypeToPhenotypicFeatureAssociation",
         "type": "object"
      },
      "GenotypeToVariantAssociation": {
         "additionalProperties": false,
         "description": "Any association between a genotype and a sequence variant.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "gene implicated in genotype",
               "type": "string"
            },
            "predicate": {
               "description": "the relationship type used to connect genotype to gene",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "parent genotype",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "predicate",
            "subject",
            "object"
         ],
         "title": "GenotypeToVariantAssociation",
         "type": "object"
      },
      "GenotypicSex": {
         "additionalProperties": false,
         "description": "An attribute corresponding to the genotypic sex of the individual, based upon genotypic composition of sex chromosomes.",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "GenotypicSex",
         "type": "object"
      },
      "GeographicExposure": {
         "additionalProperties": false,
         "description": "A geographic exposure is a factor relating to geographic proximity to some impactful entity.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "latitude": {
               "description": "latitude",
               "type": "number"
            },
            "longitude": {
               "description": "longitude",
               "type": "number"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "GeographicExposure",
         "type": "object"
      },
      "GeographicLocation": {
         "additionalProperties": false,
         "description": "a location that can be described in lat/long coordinates",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "latitude": {
               "description": "latitude",
               "type": "number"
            },
            "longitude": {
               "description": "longitude",
               "type": "number"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "GeographicLocation",
         "type": "object"
      },
      "GeographicLocationAtTime": {
         "additionalProperties": false,
         "description": "a location that can be described in lat/long coordinates, for a particular time",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "latitude": {
               "description": "latitude",
               "type": "number"
            },
            "longitude": {
               "description": "longitude",
               "type": "number"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "GeographicLocationAtTime",
         "type": "object"
      },
      "GrossAnatomicalStructure": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "GrossAnatomicalStructure",
         "type": "object"
      },
      "Haplotype": {
         "additionalProperties": false,
         "description": "A set of zero or more Alleles on a single instance of a Sequence[VMC]",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Haplotype",
         "type": "object"
      },
      "Hospitalization": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Hospitalization",
         "type": "object"
      },
      "HospitalizationOutcome": {
         "additionalProperties": false,
         "description": "An outcome resulting from an exposure event which is the increased manifestation of acute (e.g. emergency room visit) or chronic (inpatient) hospitalization.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "HospitalizationOutcome",
         "type": "object"
      },
      "IndividualOrganism": {
         "additionalProperties": false,
         "description": "An instance of an organism. For example, Richard Nixon, Charles Darwin, my pet cat. Example ID: ORCID:0000-0002-5355-2576",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "IndividualOrganism",
         "type": "object"
      },
      "Inheritance": {
         "additionalProperties": false,
         "description": "The pattern or 'mode' in which a particular genetic trait or disorder is passed from one generation to the next, e.g. autosomal dominant, autosomal recessive, etc.",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "Inheritance",
         "type": "object"
      },
      "LifeStage": {
         "additionalProperties": false,
         "description": "A stage of development or growth of an organism, including post-natal adult stages",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "LifeStage",
         "type": "object"
      },
      "LogicalInterpretationEnum": {
         "description": "",
         "enum": [
            "SomeSome",
            "AllSome",
            "InverseAllSome"
         ],
         "title": "LogicalInterpretationEnum",
         "type": "string"
      },
      "MacromolecularMachineToBiologicalProcessAssociation": {
         "additionalProperties": false,
         "description": "A functional association between a macromolecular machine (gene, gene product or complex) and a biological process or pathway (as represented in the GO biological process branch), where the entity carries out some part of the process, regulates it, or acts upstream of it.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/MacromolecularMachineMixin",
               "description": "gene, product or macromolecular complex mixin that has the function associated with the GO term"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "relation",
            "subject",
            "object"
         ],
         "title": "MacromolecularMachineToBiologicalProcessAssociation",
         "type": "object"
      },
      "MacromolecularMachineToCellularComponentAssociation": {
         "additionalProperties": false,
         "description": "A functional association between a macromolecular machine (gene, gene product or complex) and a cellular component (as represented in the GO cellular component branch), where the entity carries out its function in the cellular component.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/MacromolecularMachineMixin",
               "description": "gene, product or macromolecular complex mixin that has the function associated with the GO term"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "relation",
            "subject",
            "object"
         ],
         "title": "MacromolecularMachineToCellularComponentAssociation",
         "type": "object"
      },
      "MacromolecularMachineToMolecularActivityAssociation": {
         "additionalProperties": false,
         "description": "A functional association between a macromolecular machine (gene, gene product or complex) and a molecular activity (as represented in the GO molecular function branch), where the entity carries out the activity, or contributes to its execution.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/MacromolecularMachineMixin",
               "description": "gene, product or macromolecular complex mixin that has the function associated with the GO term"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "relation",
            "subject",
            "object"
         ],
         "title": "MacromolecularMachineToMolecularActivityAssociation",
         "type": "object"
      },
      "Macronutrient": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Macronutrient",
         "type": "object"
      },
      "MaterialSample": {
         "additionalProperties": false,
         "description": "A sample is a limited quantity of something (e.g. an individual or set of individuals from a population, or a portion of a substance) to be used for testing, analysis, inspection, investigation, demonstration, or trial use. [SIO]",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "MaterialSample",
         "type": "object"
      },
      "MaterialSampleDerivationAssociation": {
         "additionalProperties": false,
         "description": "An association between a material sample and the material entity from which it is derived.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the material entity the sample was derived from. This may be another material sample, or any other material entity, including for example an organism, a geographic feature, or some environmental material.",
               "type": "string"
            },
            "predicate": {
               "description": "derivation relationship",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "the material sample being described",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "MaterialSampleDerivationAssociation",
         "type": "object"
      },
      "MaterialSampleToDiseaseOrPhenotypicFeatureAssociation": {
         "additionalProperties": false,
         "description": "An association between a material sample and a disease or phenotype.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "object",
            "relation"
         ],
         "title": "MaterialSampleToDiseaseOrPhenotypicFeatureAssociation",
         "type": "object"
      },
      "Metabolite": {
         "additionalProperties": false,
         "description": "Any intermediate or product resulting from metabolism. Includes primary and secondary metabolites.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Metabolite",
         "type": "object"
      },
      "MicroRNA": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "synonym": {
               "description": "Alternate human-readable names for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "type": {
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "MicroRNA",
         "type": "object"
      },
      "Micronutrient": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Micronutrient",
         "type": "object"
      },
      "MolecularActivity": {
         "additionalProperties": false,
         "description": "An execution of a molecular function carried out by a gene product or macromolecular complex.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "The gene product, gene, or complex that catalyzes the reaction",
               "items": {
                  "$ref": "#/$defs/MacromolecularMachineMixin"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "A chemical entity that is the input for the reaction",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "A chemical entity that is the output for the reaction",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "MolecularActivity",
         "type": "object"
      },
      "MolecularEntity": {
         "additionalProperties": false,
         "description": "A gene, gene product, small molecule or macromolecule (including protein complex)\"",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "MolecularEntity",
         "type": "object"
      },
      "MortalityOutcome": {
         "additionalProperties": false,
         "description": "An outcome of death from resulting from an exposure event.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "MortalityOutcome",
         "type": "object"
      },
      "NamedThing": {
         "additionalProperties": false,
         "description": "a databased entity or concept/class",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "NamedThing",
         "type": "object"
      },
      "NoncodingRNAProduct": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "synonym": {
               "description": "Alternate human-readable names for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "type": {
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "NoncodingRNAProduct",
         "type": "object"
      },
      "Nutrient": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Nutrient",
         "type": "object"
      },
      "Onset": {
         "additionalProperties": false,
         "description": "The age group in which (disease) symptom manifestations appear",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "Onset",
         "type": "object"
      },
      "OrganismAttribute": {
         "additionalProperties": false,
         "description": "describes a characteristic of an organismal entity.",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "OrganismAttribute",
         "type": "object"
      },
      "OrganismTaxon": {
         "additionalProperties": false,
         "description": "A classification of a set of organisms. Example instances: NCBITaxon:9606 (Homo sapiens), NCBITaxon:2 (Bacteria). Can also be used to represent strains or subspecies.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_taxonomic_rank": {
               "$ref": "#/$defs/TaxonomicRank"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subclass_of": {
               "description": "subclass of holds between two taxa, e.g. human subclass of mammal",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "OrganismTaxon",
         "type": "object"
      },
      "OrganismTaxonToOrganismTaxonInteraction": {
         "additionalProperties": false,
         "description": "An interaction relationship between two taxa. This may be a symbiotic relationship (encompassing mutualism and parasitism), or it may be non-symbiotic. Example: plague transmitted_by flea; cattle domesticated_by Homo sapiens; plague infects Homo sapiens",
         "properties": {
            "associated_environmental_context": {
               "description": "the environment in which the two taxa interact",
               "type": "string"
            },
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the taxon that is the subject of the association",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "the taxon that is the subject of the association",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "OrganismTaxonToOrganismTaxonInteraction",
         "type": "object"
      },
      "OrganismTaxonToOrganismTaxonSpecialization": {
         "additionalProperties": false,
         "description": "A child-parent relationship between two taxa. For example: Homo sapiens subclass_of Homo",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the more general taxon",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "the more specific taxon",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "OrganismTaxonToOrganismTaxonSpecialization",
         "type": "object"
      },
      "OrganismalEntityAsAModelOfDiseaseAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "A organismal entity (strain, breed) with a predisposition to a disease, or bred/created specifically to model a disease.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "object",
            "relation",
            "subject"
         ],
         "title": "OrganismalEntityAsAModelOfDiseaseAssociation",
         "type": "object"
      },
      "PairwiseGeneToGeneInteraction": {
         "additionalProperties": false,
         "description": "An interaction between two genes or two gene products. May be physical (e.g. protein binding) or genetic (between genes). May be symmetric (e.g. protein interaction) or directed (e.g. phosphorylation)",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "the object gene in the association. If the relation is symmetric, subject vs object is arbitrary. We allow a gene product to stand as a proxy for the gene or vice versa."
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "interaction relationship type",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "$ref": "#/$defs/GeneOrGeneProduct",
               "description": "the subject gene in the association. If the relation is symmetric, subject vs object is arbitrary. We allow a gene product to stand as a proxy for the gene or vice versa."
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "object",
            "predicate",
            "relation"
         ],
         "title": "PairwiseGeneToGeneInteraction",
         "type": "object"
      },
      "PairwiseMolecularInteraction": {
         "additionalProperties": false,
         "description": "An interaction at the molecular level between two physical entities",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "identifier for the interaction. This may come from an interaction database such as IMEX.",
               "type": "string"
            },
            "interacting_molecules_category": {
               "$ref": "#/$defs/OntologyClass"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "interaction relationship type",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "subject",
            "id",
            "predicate",
            "relation",
            "object"
         ],
         "title": "PairwiseMolecularInteraction",
         "type": "object"
      },
      "PathologicalAnatomicalExposure": {
         "additionalProperties": false,
         "description": "An abnormal anatomical structure, when viewed as an exposure, representing an precondition, leading to or influencing an outcome, e.g. thrombosis leading to an ischemic disease outcome.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PathologicalAnatomicalExposure",
         "type": "object"
      },
      "PathologicalAnatomicalOutcome": {
         "additionalProperties": false,
         "description": "An outcome resulting from an exposure event which is the manifestation of an abnormal anatomical structure.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PathologicalAnatomicalOutcome",
         "type": "object"
      },
      "PathologicalAnatomicalStructure": {
         "additionalProperties": false,
         "description": "An anatomical structure with the potential of have an abnormal or deleterious effect at the subcellular, cellular, multicellular, or organismal level.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PathologicalAnatomicalStructure",
         "type": "object"
      },
      "PathologicalProcess": {
         "additionalProperties": false,
         "description": "A biologic function or a process having an abnormal or deleterious effect at the subcellular, cellular, multicellular, or organismal level.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PathologicalProcess",
         "type": "object"
      },
      "PathologicalProcessExposure": {
         "additionalProperties": false,
         "description": "A pathological process, when viewed as an exposure, representing an precondition, leading to or influencing an outcome, e.g. autoimmunity leading to disease.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PathologicalProcessExposure",
         "type": "object"
      },
      "PathologicalProcessOutcome": {
         "additionalProperties": false,
         "description": "An outcome resulting from an exposure event which is the manifestation of a pathological process.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PathologicalProcessOutcome",
         "type": "object"
      },
      "Pathway": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Pathway",
         "type": "object"
      },
      "Phenomenon": {
         "additionalProperties": false,
         "description": "a fact or situation that is observed to exist or happen, especially one whose cause or explanation is in question",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Phenomenon",
         "type": "object"
      },
      "PhenotypicFeature": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PhenotypicFeature",
         "type": "object"
      },
      "PhenotypicQuality": {
         "additionalProperties": false,
         "description": "A property of a phenotype",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "PhenotypicQuality",
         "type": "object"
      },
      "PhenotypicSex": {
         "additionalProperties": false,
         "description": "An attribute corresponding to the phenotypic sex of the individual, based upon the reproductive organs present.",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "PhenotypicSex",
         "type": "object"
      },
      "PhysicalEntity": {
         "additionalProperties": false,
         "description": "An entity that has material reality (a.k.a. physical essence).",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PhysicalEntity",
         "type": "object"
      },
      "PhysiologicalProcess": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PhysiologicalProcess",
         "type": "object"
      },
      "PlanetaryEntity": {
         "additionalProperties": false,
         "description": "Any entity or process that exists at the level of the whole planet",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PlanetaryEntity",
         "type": "object"
      },
      "PopulationOfIndividualOrganisms": {
         "additionalProperties": false,
         "description": "A collection of individuals from the same taxonomic class distinguished by one or more characteristics.  Characteristics can include, but are not limited to, shared geographic location, genetics, phenotypes [Alliance for Genome Resources]",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "PopulationOfIndividualOrganisms",
         "type": "object"
      },
      "PopulationToPopulationAssociation": {
         "additionalProperties": false,
         "description": "An association between a two populations",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the population that form the object of the association",
               "type": "string"
            },
            "predicate": {
               "description": "A relationship type that holds between the subject and object populations. Standard mereological relations can be used. E.g. subject part-of object, subject overlaps object. Derivation relationships can also be used",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "the population that form the subject of the association",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "object",
            "predicate"
         ],
         "title": "PopulationToPopulationAssociation",
         "type": "object"
      },
      "Procedure": {
         "additionalProperties": false,
         "description": "A series of actions conducted in a certain order or manner",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Procedure",
         "type": "object"
      },
      "ProcessedMaterial": {
         "additionalProperties": false,
         "description": "A chemical substance (often a mixture) processed for consumption for nutritional, medical or technical use.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_constituent": {
               "description": "one or more chemical substances within a mixture",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ProcessedMaterial",
         "type": "object"
      },
      "Protein": {
         "additionalProperties": false,
         "description": "A gene product that is composed of a chain of amino acid sequences and is produced by ribosome-mediated translation of mRNA",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "synonym": {
               "description": "Alternate human-readable names for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "type": {
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Protein",
         "type": "object"
      },
      "ProteinIsoform": {
         "additionalProperties": false,
         "description": "Represents a protein that is a specific isoform of the canonical or reference protein. See https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4114032/",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "synonym": {
               "description": "Alternate human-readable names for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "type": {
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ProteinIsoform",
         "type": "object"
      },
      "Publication": {
         "additionalProperties": false,
         "description": "Any published piece of information. Can refer to a whole publication, its encompassing publication (i.e. journal or book) or to a part of a publication, if of significant knowledge scope (e.g. a figure, figure legend, or section highlighted by NLP). The scope is intended to be general and include information published on the web, as well as printed materials, either directly or in one of the Publication Biolink category subclasses.",
         "properties": {
            "authors": {
               "description": "connects an publication to the list of authors who contributed to the publication. This property should be a comma-delimited list of author names. It is recommended that an author's name be formatted as \"surname, firstname initial.\".   Note that this property is a node annotation expressing the citation list of authorship which might typically otherwise be more completely documented in biolink:PublicationToProviderAssociation defined edges which point to full details about an author and possibly, some qualifiers which clarify the specific status of a given author in the publication.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "Different kinds of publication subtypes will have different preferred identifiers (curies when feasible). Precedence of identifiers for scientific articles is as follows: PMID if available; DOI if not; actual alternate CURIE otherwise. Enclosing publications (i.e. referenced by 'published in' node property) such as books and journals, should have industry-standard identifier such as from ISBN and ISSN.",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "keywords": {
               "description": "keywords tagging a publication",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "license": {
               "type": "string"
            },
            "mesh_terms": {
               "description": "mesh terms tagging a publication",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "name": {
               "description": "the 'title' of the publication is generally recorded in the 'name' property (inherited from NamedThing). The field name 'title' is now also tagged as an acceptable alias for the node property 'name' (just in case).",
               "type": "string"
            },
            "pages": {
               "description": "When a 2-tuple of page numbers are provided, they represent the start and end page of the publication within its parent publication context. For books, this may be set to the total number of pages of the book.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "summary": {
               "description": "executive  summary of a publication",
               "type": "string"
            },
            "type": {
               "description": "Ontology term for publication type may be drawn from Dublin Core types (https://www.dublincore.org/specifications/dublin-core/dcmi-type-vocabulary/), FRBR-aligned Bibliographic Ontology (https://sparontologies.github.io/fabio/current/fabio.html), the MESH publication types (https://www.nlm.nih.gov/mesh/pubtypes.html), the Confederation of Open Access Repositories (COAR) Controlled Vocabulary for Resource Type Genres (http://vocabularies.coar-repositories.org/documentation/resource_types/), Wikidata (https://www.wikidata.org/wiki/Wikidata:Publication_types), or equivalent publication type ontology. When a given publication type ontology term is used within a given knowledge graph, then the CURIE identified term must be documented in the graph as a concept node of biolink:category biolink:OntologyClass.",
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "category",
            "id",
            "type"
         ],
         "title": "Publication",
         "type": "object"
      },
      "QuantityValue": {
         "additionalProperties": false,
         "description": "A value of an attribute that is quantitative and measurable, expressed as a combination of a unit and a numeric value",
         "properties": {
            "has_numeric_value": {
               "description": "connects a quantity value to a number",
               "type": "number"
            },
            "has_unit": {
               "description": "connects a quantity value to a unit",
               "type": "string"
            }
         },
         "required": [],
         "title": "QuantityValue",
         "type": "object"
      },
      "RNAProduct": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "synonym": {
               "description": "Alternate human-readable names for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "type": {
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "RNAProduct",
         "type": "object"
      },
      "RNAProductIsoform": {
         "additionalProperties": false,
         "description": "Represents a protein that is a specific isoform of the canonical or reference RNA",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "synonym": {
               "description": "Alternate human-readable names for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "type": {
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "RNAProductIsoform",
         "type": "object"
      },
      "ReagentTargetedGene": {
         "additionalProperties": false,
         "description": "A gene altered in its expression level in the context of some experiment as a result of being targeted by gene-knockdown reagent(s) such as a morpholino or RNAi.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "ReagentTargetedGene",
         "type": "object"
      },
      "RelationshipType": {
         "additionalProperties": false,
         "description": "An OWL property used as an edge label",
         "properties": {},
         "required": [],
         "title": "RelationshipType",
         "type": "object"
      },
      "SequenceAssociation": {
         "additionalProperties": false,
         "description": "An association between a sequence feature and a genomic entity it is localized to.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "predicate",
            "object",
            "relation"
         ],
         "title": "SequenceAssociation",
         "type": "object"
      },
      "SequenceFeatureRelationship": {
         "additionalProperties": false,
         "description": "For example, a particular exon is part of a particular transcript or gene",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "relation",
            "subject",
            "object"
         ],
         "title": "SequenceFeatureRelationship",
         "type": "object"
      },
      "SequenceVariant": {
         "additionalProperties": false,
         "description": "An allele that varies in its sequence from what is considered the reference allele at that locus.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "The state of the sequence w.r.t a reference sequence",
               "type": "string"
            },
            "has_gene": {
               "description": "Each allele can be associated with any number of genes",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "category",
            "id"
         ],
         "title": "SequenceVariant",
         "type": "object"
      },
      "Serial": {
         "additionalProperties": false,
         "description": "This class may rarely be instantiated except if use cases of a given knowledge graph support its utility.",
         "properties": {
            "authors": {
               "description": "connects an publication to the list of authors who contributed to the publication. This property should be a comma-delimited list of author names. It is recommended that an author's name be formatted as \"surname, firstname initial.\".   Note that this property is a node annotation expressing the citation list of authorship which might typically otherwise be more completely documented in biolink:PublicationToProviderAssociation defined edges which point to full details about an author and possibly, some qualifiers which clarify the specific status of a given author in the publication.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "creation_date": {
               "description": "date on which an entity was created. This can be applied to nodes or edges",
               "format": "date",
               "type": "string"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "format": {
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "Serials (journals) should have industry-standard identifier such as from ISSN.",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "iso_abbreviation": {
               "description": "Standard abbreviation for periodicals in the International Organization for Standardization (ISO) 4 system See https://www.issn.org/services/online-services/access-to-the-ltwa/. If the 'published in' property is set, then the iso abbreviation pertains to the broader publication context (the journal) within which the given publication node is embedded, not the publication itself.",
               "type": "string"
            },
            "issue": {
               "description": "issue of a newspaper, a scientific journal or magazine for reference purpose",
               "type": "string"
            },
            "keywords": {
               "description": "keywords tagging a publication",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "license": {
               "type": "string"
            },
            "mesh_terms": {
               "description": "mesh terms tagging a publication",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "name": {
               "description": "the 'title' of the publication is generally recorded in the 'name' property (inherited from NamedThing). The field name 'title' is now also tagged as an acceptable alias for the node property 'name' (just in case).",
               "type": "string"
            },
            "pages": {
               "description": "When a 2-tuple of page numbers are provided, they represent the start and end page of the publication within its parent publication context. For books, this may be set to the total number of pages of the book.",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "rights": {
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "summary": {
               "description": "executive  summary of a publication",
               "type": "string"
            },
            "type": {
               "description": "Should generally be set to an ontology class defined term for 'serial' or 'journal'.",
               "type": "string"
            },
            "volume": {
               "description": "volume of a book or music release in a collection/series or a published collection of journal issues in a serial publication",
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "category",
            "id",
            "type"
         ],
         "title": "Serial",
         "type": "object"
      },
      "SeverityValue": {
         "additionalProperties": false,
         "description": "describes the severity of a phenotypic feature or disease",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "SeverityValue",
         "type": "object"
      },
      "SiRNA": {
         "additionalProperties": false,
         "description": "A small RNA molecule that is the product of a longer exogenous or endogenous dsRNA, which is either a bimolecular duplex or very long hairpin, processed (via the Dicer pathway) such that numerous siRNAs accumulate from both strands of the dsRNA. SRNAs trigger the cleavage of their target molecules.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "synonym": {
               "description": "Alternate human-readable names for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "type": {
               "type": "string"
            },
            "xref": {
               "description": "Alternate CURIEs for a thing",
               "items": {
                  "type": "string"
               },
               "type": "array"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "SiRNA",
         "type": "object"
      },
      "Snv": {
         "additionalProperties": false,
         "description": "SNVs are single nucleotide positions in genomic DNA at which different sequence alternatives exist",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "The state of the sequence w.r.t a reference sequence",
               "type": "string"
            },
            "has_gene": {
               "description": "Each allele can be associated with any number of genes",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "category",
            "id"
         ],
         "title": "Snv",
         "type": "object"
      },
      "SocioeconomicAttribute": {
         "additionalProperties": false,
         "description": "Attributes relating to a socioeconomic manifestation",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "SocioeconomicAttribute",
         "type": "object"
      },
      "SocioeconomicExposure": {
         "additionalProperties": false,
         "description": "A socioeconomic exposure is a factor relating to social and financial status of an affected individual (e.g. poverty).",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/SocioeconomicAttribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category",
            "has_attribute"
         ],
         "title": "SocioeconomicExposure",
         "type": "object"
      },
      "SocioeconomicOutcome": {
         "additionalProperties": false,
         "description": "An general social or economic outcome, such as healthcare costs, utilization, etc., resulting from an exposure event",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "enabled_by": {
               "description": "holds between a process and a physical entity, where the physical entity executes the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_input": {
               "description": "holds between a process and a continuant, where the continuant is an input into the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_output": {
               "description": "holds between a process and a continuant, where the continuant is an output of the process",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "SocioeconomicOutcome",
         "type": "object"
      },
      "StudyPopulation": {
         "additionalProperties": false,
         "description": "A group of people banded together or treated as a group as participants in a research study.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "may often be an organism attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "StudyPopulation",
         "type": "object"
      },
      "TaxonomicRank": {
         "additionalProperties": false,
         "description": "A descriptor for the rank within a taxonomic classification. Example instance: TAXRANK:0000017 (kingdom)",
         "properties": {},
         "required": [],
         "title": "TaxonomicRank",
         "type": "object"
      },
      "Transcript": {
         "additionalProperties": false,
         "description": "An RNA synthesized on a DNA or RNA template by an RNA polymerase.",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_biological_sequence": {
               "description": "connects a genomic feature to its sequence",
               "type": "string"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Transcript",
         "type": "object"
      },
      "TranscriptToGeneRelationship": {
         "additionalProperties": false,
         "description": "A gene is a collection of transcripts",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "relation",
            "subject",
            "object"
         ],
         "title": "TranscriptToGeneRelationship",
         "type": "object"
      },
      "Treatment": {
         "additionalProperties": false,
         "description": "A treatment is targeted at a disease or phenotype and may involve multiple drug 'exposures', medical devices and/or procedures",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_device": {
               "description": "connects an entity to one or more (medical) devices",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_drug": {
               "description": "connects an entity to one or more drugs",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "has_procedure": {
               "description": "connects an entity to one or more (medical) procedures",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "timepoint": {
               "description": "a point in time",
               "format": "time",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Treatment",
         "type": "object"
      },
      "VariantAsAModelOfDiseaseAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "a disease that is associated with that variant",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "E.g. is pathogenic for",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "A variant that has a role in modeling the disease.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "predicate",
            "object",
            "subject"
         ],
         "title": "VariantAsAModelOfDiseaseAssociation",
         "type": "object"
      },
      "VariantToDiseaseAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "a disease that is associated with that variant",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "E.g. is pathogenic for",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "a sequence variant in which the allele state is associated in some way with the disease state",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "relation",
            "subject",
            "predicate",
            "object"
         ],
         "title": "VariantToDiseaseAssociation",
         "type": "object"
      },
      "VariantToGeneAssociation": {
         "additionalProperties": false,
         "description": "An association between a variant and a gene, where the variant has a genetic association with the gene (i.e. is in linkage disequilibrium)",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "relation",
            "object",
            "predicate"
         ],
         "title": "VariantToGeneAssociation",
         "type": "object"
      },
      "VariantToGeneExpressionAssociation": {
         "additionalProperties": false,
         "description": "An association between a variant and expression of a gene (i.e. e-QTL)",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "expression_site": {
               "description": "location in which gene or protein expression takes place. May be cell, tissue, or organ.",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "phenotypic_state": {
               "description": "in experiments (e.g. gene expression) assaying diseased or unhealthy tissue, the phenotypic state can be put here, e.g. MONDO ID. For healthy tissues, use XXX.",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "quantifier_qualifier": {
               "$ref": "#/$defs/OntologyClass",
               "description": "Optional quantitative value indicating degree of expression."
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "stage_qualifier": {
               "description": "stage during which gene or protein expression of takes place.",
               "type": "string"
            },
            "subject": {
               "description": "connects an association to the subject of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "subject",
            "relation",
            "object",
            "predicate"
         ],
         "title": "VariantToGeneExpressionAssociation",
         "type": "object"
      },
      "VariantToPhenotypicFeatureAssociation": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "connects an association to the object of the association. For example, in a gene-to-phenotype association, the gene is subject and phenotype is object.",
               "type": "string"
            },
            "onset_qualifier": {
               "$ref": "#/$defs/Onset",
               "description": "a qualifier used in a phenotypic association to state when the phenotype appears is in the subject"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "severity_qualifier": {
               "$ref": "#/$defs/SeverityValue",
               "description": "a qualifier used in a phenotypic association to state how severe the phenotype is in the subject"
            },
            "sex_qualifier": {
               "$ref": "#/$defs/BiologicalSex",
               "description": "a qualifier used in a phenotypic association to state whether the association is specific to a particular sex."
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "a sequence variant in which the allele state is associated in some way with the phenotype state",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "object",
            "relation",
            "subject"
         ],
         "title": "VariantToPhenotypicFeatureAssociation",
         "type": "object"
      },
      "VariantToPopulationAssociation": {
         "additionalProperties": false,
         "description": "An association between a variant and a population, where the variant has particular frequency in the population",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "frequency_qualifier": {
               "description": "a qualifier used in a phenotypic association to state how frequent the phenotype is observed in the subject",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "has_count": {
               "description": "number in object population that carry a particular allele, aka allele count",
               "type": "integer"
            },
            "has_percentage": {
               "description": "equivalent to has quotient multiplied by 100",
               "type": "number"
            },
            "has_quotient": {
               "description": "frequency of allele in population, expressed as a number with allele divided by number in reference population, aka allele frequency",
               "type": "number"
            },
            "has_total": {
               "description": "number all populations that carry a particular allele, aka allele number",
               "type": "integer"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "negated": {
               "description": "if set to true, then the association is negated i.e. is not true",
               "type": "boolean"
            },
            "object": {
               "description": "the population that is observed to have the frequency",
               "type": "string"
            },
            "predicate": {
               "description": "A high-level grouping for the relationship type. AKA minimal predicate. This is analogous to category for nodes.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "publications": {
               "description": "connects an association to publications supporting the association",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "qualifiers": {
               "description": "connects an association to qualifiers that modify or qualify the meaning of that association",
               "items": {
                  "$ref": "#/$defs/OntologyClass"
               },
               "type": "array"
            },
            "relation": {
               "description": "The relation which describes an association between a subject and an object in a more granular manner. Usually this is a term from Relation Ontology, but it can be any edge CURIE.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "subject": {
               "description": "an allele that has a certain frequency in a given population",
               "type": "string"
            },
            "type": {
               "description": "rdf:type of biolink:Association should be fixed at rdf:Statement",
               "type": "string"
            }
         },
         "required": [
            "id",
            "predicate",
            "relation",
            "subject",
            "object"
         ],
         "title": "VariantToPopulationAssociation",
         "type": "object"
      },
      "Vitamin": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "category": {
               "description": "Name of the high level ontology class in which this entity is categorized. Corresponds to the label for the biolink entity type class.\n * In a neo4j database this MAY correspond to the neo4j label tag.\n * In an RDF database it should be a biolink model class URI.\nThis field is multi-valued. It should include values for ancestors of the biolink class; for example, a protein such as Shh would have category values `biolink:Protein`, `biolink:GeneProduct`, `biolink:MolecularEntity`, ...\nIn an RDF database, nodes will typically have an rdf:type triples. This can be to the most specific biolink class, or potentially to a class more specific than something in biolink. For example, a sequence feature `f` may have a rdf:type assertion to a SO class such as TF_binding_site, which is more specific than anything in biolink. Here we would have categories {biolink:GenomicEntity, biolink:MolecularEntity, biolink:NamedThing}",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "description": {
               "description": "a human-readable description of an entity",
               "type": "string"
            },
            "has_attribute": {
               "description": "connects any entity to an attribute",
               "items": {
                  "$ref": "#/$defs/Attribute"
               },
               "type": "array"
            },
            "id": {
               "description": "A unique identifier for an entity. Must be either a CURIE shorthand for a URI or a complete URI",
               "type": "string"
            },
            "in_taxon": {
               "description": "connects an entity to its taxonomic classification. Only certain kinds of entities can be taxonomically classified; see 'thing with taxon'",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "is_metabolite": {
               "description": "indicates whether a chemical substance is a metabolite",
               "type": "boolean"
            },
            "name": {
               "description": "A human-readable name for an attribute or entity.",
               "type": "string"
            },
            "provided_by": {
               "description": "connects an association to the agent (person, organization or group) that provided it",
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            },
            "type": {
               "type": "string"
            }
         },
         "required": [
            "id",
            "category"
         ],
         "title": "Vitamin",
         "type": "object"
      },
      "Zygosity": {
         "additionalProperties": false,
         "description": "",
         "properties": {
            "has_attribute_type": {
               "$ref": "#/$defs/OntologyClass",
               "description": "connects an attribute to a class that describes it"
            },
            "has_qualitative_value": {
               "description": "connects an attribute to a value",
               "type": "string"
            },
            "has_quantitative_value": {
               "description": "connects an attribute to a value",
               "items": {
                  "$ref": "#/$defs/QuantityValue"
               },
               "type": "array"
            },
            "iri": {
               "description": "An IRI for an entity. This is determined by the id using expansion rules.",
               "type": "string"
            },
            "name": {
               "description": "The human-readable 'attribute name' can be set to a string which reflects its context of interpretation, e.g. SEPIO evidence/provenance/confidence annotation or it can default to the name associated with the 'has attribute type' slot ontology term.",
               "type": "string"
            },
            "source": {
               "description": "a lightweight analog to the association class 'has provider' slot, which is the string name, or the authoritative (i.e. database) namespace, designating the origin of the entity to which the slot belongs.",
               "type": "string"
            }
         },
         "required": [
            "has_attribute_type"
         ],
         "title": "Zygosity",
         "type": "object"
      }
   },
   "$id": "https://w3id.org/biolink/biolink-model",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "additionalProperties": true,
   "properties": {},
   "required": [],
   "title": "Biolink-Model",
   "type": "object"
}
