From 04c298c5e6680cbb7651c5429f4f38aa9223de38 Mon Sep 17 00:00:00 2001 From: Patrick Kalita Date: Mon, 12 Dec 2022 08:46:47 -0800 Subject: [PATCH] Update to latest metamodel --- linkml_runtime/linkml_model/datasets.py | 402 + linkml_runtime/linkml_model/excel/meta.xlsx | Bin 0 -> 58381 bytes .../linkml_model/json/datasets.json | 1171 +++ linkml_runtime/linkml_model/json/meta.json | 4 +- .../jsonld/datasets.context.jsonld | 138 + .../jsonld/datasets.model.context.jsonld | 138 + .../linkml_model/jsonld/meta.context.jsonld | 2 +- .../linkml_model/jsonld/meta.jsonld | 7379 +++++++++++++++++ .../jsonld/meta.model.context.jsonld | 2 +- .../jsonld/types.model.context.jsonld | 2 +- .../jsonschema/datasets.schema.json | 293 + linkml_runtime/linkml_model/meta.py | 15 +- .../linkml_model/model/schema/datasets.yaml | 355 + linkml_runtime/linkml_model/owl/meta.owl.ttl | 2078 ++--- .../linkml_model/prefixmap/meta.yaml | 29 + .../linkml_model/protobuf/meta.proto | 844 ++ .../linkml_model/rdf/datasets.model.ttl | 747 ++ linkml_runtime/linkml_model/rdf/datasets.ttl | 747 ++ .../linkml_model/rdf/meta.model.ttl | 56 +- linkml_runtime/linkml_model/rdf/meta.ttl | 52 +- .../linkml_model/rdf/types.model.ttl | 128 +- .../linkml_model/shacl/meta.shacl.ttl | 4001 +++++++++ .../linkml_model/shex/annotations.shex | 2 - .../linkml_model/shex/annotations.shexj | 5 - .../linkml_model/shex/datasets.shex | 109 + .../linkml_model/shex/datasets.shexj | 454 + .../linkml_model/shex/extensions.shex | 2 - .../linkml_model/shex/extensions.shexj | 5 - .../linkml_model/shex/mappings.shexj | 5 - linkml_runtime/linkml_model/shex/meta.shexj | 589 +- linkml_runtime/linkml_model/shex/types.shex | 2 - linkml_runtime/linkml_model/shex/types.shexj | 5 - .../linkml_model/shex/validation.shex | 4 +- .../linkml_model/shex/validation.shexj | 7 +- linkml_runtime/linkml_model/sqlddl/meta.sql | 4196 ++++++++++ .../linkml_model/sqlschema/meta.sql | 1439 ++++ 36 files changed, 23615 insertions(+), 1792 deletions(-) create mode 100644 linkml_runtime/linkml_model/datasets.py create mode 100644 linkml_runtime/linkml_model/excel/meta.xlsx create mode 100644 linkml_runtime/linkml_model/json/datasets.json create mode 100644 linkml_runtime/linkml_model/jsonld/datasets.context.jsonld create mode 100644 linkml_runtime/linkml_model/jsonld/datasets.model.context.jsonld create mode 100644 linkml_runtime/linkml_model/jsonld/meta.jsonld create mode 100644 linkml_runtime/linkml_model/jsonschema/datasets.schema.json create mode 100644 linkml_runtime/linkml_model/model/schema/datasets.yaml create mode 100644 linkml_runtime/linkml_model/prefixmap/meta.yaml create mode 100644 linkml_runtime/linkml_model/protobuf/meta.proto create mode 100644 linkml_runtime/linkml_model/rdf/datasets.model.ttl create mode 100644 linkml_runtime/linkml_model/rdf/datasets.ttl create mode 100644 linkml_runtime/linkml_model/shacl/meta.shacl.ttl create mode 100644 linkml_runtime/linkml_model/shex/datasets.shex create mode 100644 linkml_runtime/linkml_model/shex/datasets.shexj create mode 100644 linkml_runtime/linkml_model/sqlddl/meta.sql create mode 100644 linkml_runtime/linkml_model/sqlschema/meta.sql diff --git a/linkml_runtime/linkml_model/datasets.py b/linkml_runtime/linkml_model/datasets.py new file mode 100644 index 00000000..97e201f8 --- /dev/null +++ b/linkml_runtime/linkml_model/datasets.py @@ -0,0 +1,402 @@ +# Auto generated from datasets.yaml by pythongen.py version: 0.9.0 +# Generation date: 2022-07-14T00:57:19 +# Schema: datasets +# +# id: https://w3id.org/linkml/datasets +# description: A datamodel for datasets +# license: https://creativecommons.org/publicdomain/zero/1.0/ + +import dataclasses +import sys +import re +from jsonasobj2 import JsonObj, as_dict +from typing import Optional, List, Union, Dict, ClassVar, Any +from dataclasses import dataclass + +from linkml_runtime.utils.slot import Slot +from linkml_runtime.utils.metamodelcore import empty_list, empty_dict, bnode +from linkml_runtime.utils.yamlutils import YAMLRoot, extended_str, extended_float, extended_int +from linkml_runtime.utils.dataclass_extensions_376 import dataclasses_init_fn_with_kwargs +from linkml_runtime.utils.formatutils import camelcase, underscore, sfx +from linkml_runtime.utils.enumerations import EnumDefinitionImpl +from rdflib import Namespace, URIRef +from linkml_runtime.utils.curienamespace import CurieNamespace +from .types import Datetime, Integer, String, Uri, Uriorcurie +from linkml_runtime.utils.metamodelcore import URI, URIorCURIE, XSDDateTime + +metamodel_version = "1.7.0" +version = None + +# Overwrite dataclasses _init_fn to add **kwargs in __init__ +dataclasses._init_fn = dataclasses_init_fn_with_kwargs + +# Namespaces +BIBO = CurieNamespace('bibo', 'http://example.org/UNKNOWN/bibo/') +CSVW = CurieNamespace('csvw', 'http://www.w3.org/ns/csvw#') +DATASETS = CurieNamespace('datasets', 'https://w3id.org/linkml/report') +DCAT = CurieNamespace('dcat', 'http://www.w3.org/ns/dcat#') +DCTERMS = CurieNamespace('dcterms', 'http://purl.org/dc/terms/') +FORMATS = CurieNamespace('formats', 'http://www.w3.org/ns/formats/') +FRICTIONLESS = CurieNamespace('frictionless', 'https://specs.frictionlessdata.io/') +LINKML = CurieNamespace('linkml', 'https://w3id.org/linkml/') +MEDIATYPES = CurieNamespace('mediatypes', 'https://www.iana.org/assignments/media-types/') +OSLC = CurieNamespace('oslc', 'http://example.org/UNKNOWN/oslc/') +OWL = CurieNamespace('owl', 'http://www.w3.org/2002/07/owl#') +PAV = CurieNamespace('pav', 'http://purl.org/pav/') +PROV = CurieNamespace('prov', 'http://www.w3.org/ns/prov#') +RDF = CurieNamespace('rdf', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#') +RDFS = CurieNamespace('rdfs', 'http://www.w3.org/2000/01/rdf-schema#') +SCHEMA = CurieNamespace('schema', 'http://schema.org/') +SH = CurieNamespace('sh', 'https://w3id.org/shacl/') +SKOS = CurieNamespace('skos', 'http://www.w3.org/2004/02/skos/core#') +VOID = CurieNamespace('void', 'http://rdfs.org/ns/void#') +XSD = CurieNamespace('xsd', 'http://www.w3.org/2001/XMLSchema#') +DEFAULT_ = DATASETS + + +# Types + +# Class references +class InformationId(extended_str): + pass + + +class DataPackageId(InformationId): + pass + + +class DataResourceId(InformationId): + pass + + +@dataclass +class Information(YAMLRoot): + """ + Grouping for datasets and data files + """ + _inherited_slots: ClassVar[List[str]] = [] + + class_class_uri: ClassVar[URIRef] = DATASETS.Information + class_class_curie: ClassVar[str] = "datasets:Information" + class_name: ClassVar[str] = "Information" + class_model_uri: ClassVar[URIRef] = DATASETS.Information + + id: Union[str, InformationId] = None + download_url: Optional[Union[str, URI]] = None + license: Optional[str] = None + title: Optional[str] = None + description: Optional[str] = None + conforms_to: Optional[Union[str, URIorCURIE]] = None + conforms_to_schema: Optional[Union[str, URIorCURIE]] = None + conforms_to_class: Optional[Union[str, URIorCURIE]] = None + version: Optional[str] = None + language: Optional[str] = None + publisher: Optional[Union[str, URIorCURIE]] = None + keywords: Optional[Union[str, List[str]]] = empty_list() + issued: Optional[Union[str, XSDDateTime]] = None + created_by: Optional[Union[str, URIorCURIE]] = None + created_on: Optional[Union[str, XSDDateTime]] = None + compression: Optional[str] = None + was_derived_from: Optional[str] = None + page: Optional[str] = None + test_roles: Optional[Union[Union[str, "TestRole"], List[Union[str, "TestRole"]]]] = empty_list() + + def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): + if self._is_empty(self.id): + self.MissingRequiredField("id") + if not isinstance(self.id, InformationId): + self.id = InformationId(self.id) + + if self.download_url is not None and not isinstance(self.download_url, URI): + self.download_url = URI(self.download_url) + + if self.license is not None and not isinstance(self.license, str): + self.license = str(self.license) + + if self.title is not None and not isinstance(self.title, str): + self.title = str(self.title) + + if self.description is not None and not isinstance(self.description, str): + self.description = str(self.description) + + if self.conforms_to is not None and not isinstance(self.conforms_to, URIorCURIE): + self.conforms_to = URIorCURIE(self.conforms_to) + + if self.conforms_to_schema is not None and not isinstance(self.conforms_to_schema, URIorCURIE): + self.conforms_to_schema = URIorCURIE(self.conforms_to_schema) + + if self.conforms_to_class is not None and not isinstance(self.conforms_to_class, URIorCURIE): + self.conforms_to_class = URIorCURIE(self.conforms_to_class) + + if self.version is not None and not isinstance(self.version, str): + self.version = str(self.version) + + if self.language is not None and not isinstance(self.language, str): + self.language = str(self.language) + + if self.publisher is not None and not isinstance(self.publisher, URIorCURIE): + self.publisher = URIorCURIE(self.publisher) + + if not isinstance(self.keywords, list): + self.keywords = [self.keywords] if self.keywords is not None else [] + self.keywords = [v if isinstance(v, str) else str(v) for v in self.keywords] + + if self.issued is not None and not isinstance(self.issued, XSDDateTime): + self.issued = XSDDateTime(self.issued) + + if self.created_by is not None and not isinstance(self.created_by, URIorCURIE): + self.created_by = URIorCURIE(self.created_by) + + if self.created_on is not None and not isinstance(self.created_on, XSDDateTime): + self.created_on = XSDDateTime(self.created_on) + + if self.compression is not None and not isinstance(self.compression, str): + self.compression = str(self.compression) + + if self.was_derived_from is not None and not isinstance(self.was_derived_from, str): + self.was_derived_from = str(self.was_derived_from) + + if self.page is not None and not isinstance(self.page, str): + self.page = str(self.page) + + if not isinstance(self.test_roles, list): + self.test_roles = [self.test_roles] if self.test_roles is not None else [] + self.test_roles = [v if isinstance(v, TestRole) else TestRole(v) for v in self.test_roles] + + super().__post_init__(**kwargs) + + +@dataclass +class DataPackage(Information): + """ + A collection of data resources + """ + _inherited_slots: ClassVar[List[str]] = [] + + class_class_uri: ClassVar[URIRef] = VOID.Dataset + class_class_curie: ClassVar[str] = "void:Dataset" + class_name: ClassVar[str] = "DataPackage" + class_model_uri: ClassVar[URIRef] = DATASETS.DataPackage + + id: Union[str, DataPackageId] = None + resources: Optional[Union[Union[str, DataResourceId], List[Union[str, DataResourceId]]]] = empty_list() + + def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): + if self._is_empty(self.id): + self.MissingRequiredField("id") + if not isinstance(self.id, DataPackageId): + self.id = DataPackageId(self.id) + + if not isinstance(self.resources, list): + self.resources = [self.resources] if self.resources is not None else [] + self.resources = [v if isinstance(v, DataResourceId) else DataResourceId(v) for v in self.resources] + + super().__post_init__(**kwargs) + + +@dataclass +class DataResource(Information): + """ + An individual file or table + """ + _inherited_slots: ClassVar[List[str]] = [] + + class_class_uri: ClassVar[URIRef] = DCAT.Distribution + class_class_curie: ClassVar[str] = "dcat:Distribution" + class_name: ClassVar[str] = "DataResource" + class_model_uri: ClassVar[URIRef] = DATASETS.DataResource + + id: Union[str, DataResourceId] = None + path: Optional[str] = None + title: Optional[str] = None + description: Optional[str] = None + format: Optional[Union[str, "FormatEnum"]] = None + media_type: Optional[str] = None + encoding: Optional[str] = None + bytes: Optional[int] = None + hash: Optional[str] = None + md5: Optional[str] = None + sha256: Optional[str] = None + dialect: Optional[str] = None + + def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): + if self._is_empty(self.id): + self.MissingRequiredField("id") + if not isinstance(self.id, DataResourceId): + self.id = DataResourceId(self.id) + + if self.path is not None and not isinstance(self.path, str): + self.path = str(self.path) + + if self.title is not None and not isinstance(self.title, str): + self.title = str(self.title) + + if self.description is not None and not isinstance(self.description, str): + self.description = str(self.description) + + if self.format is not None and not isinstance(self.format, FormatEnum): + self.format = FormatEnum(self.format) + + if self.media_type is not None and not isinstance(self.media_type, str): + self.media_type = str(self.media_type) + + if self.encoding is not None and not isinstance(self.encoding, str): + self.encoding = str(self.encoding) + + if self.bytes is not None and not isinstance(self.bytes, int): + self.bytes = int(self.bytes) + + if self.hash is not None and not isinstance(self.hash, str): + self.hash = str(self.hash) + + if self.md5 is not None and not isinstance(self.md5, str): + self.md5 = str(self.md5) + + if self.sha256 is not None and not isinstance(self.sha256, str): + self.sha256 = str(self.sha256) + + if self.dialect is not None and not isinstance(self.dialect, str): + self.dialect = str(self.dialect) + + super().__post_init__(**kwargs) + + +@dataclass +class FormatDialect(YAMLRoot): + """ + Additional format information for a file + """ + _inherited_slots: ClassVar[List[str]] = [] + + class_class_uri: ClassVar[URIRef] = DATASETS.FormatDialect + class_class_curie: ClassVar[str] = "datasets:FormatDialect" + class_name: ClassVar[str] = "FormatDialect" + class_model_uri: ClassVar[URIRef] = DATASETS.FormatDialect + + comment_prefix: Optional[str] = None + delimiter: Optional[str] = None + double_quote: Optional[str] = None + header: Optional[str] = None + quote_char: Optional[str] = None + + def __post_init__(self, *_: List[str], **kwargs: Dict[str, Any]): + if self.comment_prefix is not None and not isinstance(self.comment_prefix, str): + self.comment_prefix = str(self.comment_prefix) + + if self.delimiter is not None and not isinstance(self.delimiter, str): + self.delimiter = str(self.delimiter) + + if self.double_quote is not None and not isinstance(self.double_quote, str): + self.double_quote = str(self.double_quote) + + if self.header is not None and not isinstance(self.header, str): + self.header = str(self.header) + + if self.quote_char is not None and not isinstance(self.quote_char, str): + self.quote_char = str(self.quote_char) + + super().__post_init__(**kwargs) + + +# Enumerations +class TestRole(EnumDefinitionImpl): + + Example = PermissibleValue(text="Example") + CounterExample = PermissibleValue(text="CounterExample") + + _defn = EnumDefinition( + name="TestRole", + ) + +class MediaTypeEnum(EnumDefinitionImpl): + + csv = PermissibleValue(text="csv", + meaning=MEDIATYPES["text/csv"]) + + _defn = EnumDefinition( + name="MediaTypeEnum", + ) + + @classmethod + def _addvals(cls): + setattr(cls, "rdf-xml", + PermissibleValue(text="rdf-xml", + meaning=MEDIATYPES["application/rdf+xml"]) ) + +class FormatEnum(EnumDefinitionImpl): + + N3 = PermissibleValue(text="N3", + meaning=FORMATS.N3) + Microdata = PermissibleValue(text="Microdata", + meaning=FORMATS.microdata) + POWDER = PermissibleValue(text="POWDER", + meaning=FORMATS.POWDER) + RDFa = PermissibleValue(text="RDFa", + meaning=FORMATS.RDFa) + Turtle = PermissibleValue(text="Turtle", + meaning=FORMATS.Turtle) + TriG = PermissibleValue(text="TriG", + meaning=FORMATS.TriG) + YAML = PermissibleValue(text="YAML") + JSON = PermissibleValue(text="JSON") + + _defn = EnumDefinition( + name="FormatEnum", + ) + + @classmethod + def _addvals(cls): + setattr(cls, "JSON-LD", + PermissibleValue(text="JSON-LD", + meaning=FORMATS["JSON-LD"]) ) + setattr(cls, "N-Triples", + PermissibleValue(text="N-Triples", + meaning=FORMATS["N-Triples"]) ) + setattr(cls, "N-Quads", + PermissibleValue(text="N-Quads", + meaning=FORMATS["N-Quads"]) ) + setattr(cls, "LD Patch", + PermissibleValue(text="LD Patch", + meaning=FORMATS.LD_Patch) ) + setattr(cls, "OWL XML Serialization", + PermissibleValue(text="OWL XML Serialization", + meaning=FORMATS.OWL_XML) ) + setattr(cls, "OWL Functional Syntax", + PermissibleValue(text="OWL Functional Syntax", + meaning=FORMATS.OWL_Functional) ) + setattr(cls, "OWL Manchester Syntax", + PermissibleValue(text="OWL Manchester Syntax", + meaning=FORMATS.OWL_Manchester) ) + setattr(cls, "POWDER-S", + PermissibleValue(text="POWDER-S", + meaning=FORMATS["POWDER-S"]) ) + setattr(cls, "PROV-N", + PermissibleValue(text="PROV-N", + meaning=FORMATS["PROV-N"]) ) + setattr(cls, "PROV-XML", + PermissibleValue(text="PROV-XML", + meaning=FORMATS["PROV-XML"]) ) + setattr(cls, "RDF/JSON", + PermissibleValue(text="RDF/JSON", + meaning=FORMATS.RDF_JSON) ) + setattr(cls, "RDF/XML", + PermissibleValue(text="RDF/XML", + meaning=FORMATS.RDF_XML) ) + setattr(cls, "RIF XML Syntax", + PermissibleValue(text="RIF XML Syntax", + meaning=FORMATS.RIF_XML) ) + setattr(cls, "SPARQL Results in XML", + PermissibleValue(text="SPARQL Results in XML", + meaning=FORMATS.SPARQL_Results_XML) ) + setattr(cls, "SPARQL Results in JSON", + PermissibleValue(text="SPARQL Results in JSON", + meaning=FORMATS.SPARQL_Results_JSON) ) + setattr(cls, "SPARQL Results in CSV", + PermissibleValue(text="SPARQL Results in CSV", + meaning=FORMATS.SPARQL_Results_CSV) ) + setattr(cls, "SPARQL Results in TSV", + PermissibleValue(text="SPARQL Results in TSV", + meaning=FORMATS.SPARQL_Results_TSV) ) + +# Slots + diff --git a/linkml_runtime/linkml_model/excel/meta.xlsx b/linkml_runtime/linkml_model/excel/meta.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..1e76d2bdba07279027dd5389e0be96602c821e19 GIT binary patch literal 58381 zcmeFZV{oSJwyqu9cDlokZCf4NwrzE6Cmq{H$2K~))3I&tr~6%N?)A=H@7&+tuWJ8z zl1f#6+;xp{jWO=yJjWv^1qy}+1Ox;HB;p#T3@IRO;1Bq#7Vtp=e2i=j}cJrt)!!QU_ls=gg-{@JDLP~1P%D76l&@aJ#pz`jfCn1eL6XMVr&R(u|zjvOewcZ z5om&yVs?n)5rNP#!y9F^i*4{y%nA+Nfw&IhCL$-rCG^VY2uh#}Q}?Cc5u!!29S{gA z-DLKUYwe85`wBmU!+$tfZ< z!T9&{7RL3+^wGlw>l%-CIH&iLrRVQ_Z(*E19zG_g|*+3x#wb+YdWbXg&#G%E;13+}LVcMjg&m3m|4) zsPUKh{xtAKMlvE|#y8LfLk-MgM1BZ)v^@}Z3{C5`US9^oA#z+0zAqMW{%2v7q?@;w zTUN?s8g1QCtZ*d_C7e++;+<0*Uvy=#t%!HpoAReNNmMjK9_xM%_fngS#)rJ*phR_w z`fU@c!d9K~<6~=wx5F+dZQFG18^j%TIm^d8+dJ~VA55xN1~C!@5Ksm=5D+ThVBDPP_ zeY?b1k;anY&*G(9)49Q@k6tE3#10PG-EYom4Gx1t6R+L$mg!a(+M4J#wp1BOkOkoiYVG6(M{LnB5>SOmFK}G3X`xXHu<%Tx4ptYrmLr1)D+_1W?5@>FfizQ~H=dD9+ z#y_PbuVJhEsbP7*$n(tR=MJ`pIhGb!CIsc=Cu7pV8lj9#`#??}Tmf zu8c8{);%?s}rdL{Sov>|vVLU1atj67YL}8wM+ow@|&C zI-!O)qe36bZPR#EbJZkP0w0k?akeuY_Z_FLULXrar|*^9*YZ=;(1BC1Hkr#J2eGFV{n;&AanOmXW)KL?t(T@qB2M5k5uB2x+S8ep^HIQ+oyZ?rEB z)YCv2oOY9$X+VBeuV6{w)f+w?k8_?_h(kb**I@(v??gl_au-1`yJXr~p1m5_Tb53r zM9<;3F_X7upWt~WE9&S6u{li1T|}~Cz9U9v$ow>Q=#D@Yi|n!xX5JD4Mi}s`76RTq z4>uULFJk)9{HO53+`n6q0sBR&*!WnU3FCEi(RL zQ%&KDZB3-W(QE!4)wFzc!??Cb8Glk)^SY+ff~NspX7XLVayT0fSq1|ZMcgnEvq&=U z23xW7fJ&lYnY~MdsSzawt9@sG$X-UV8O5a$5rna&jic1Vn8CE@dXokYnp!hd9c5cu z`)vLoJ)_El$mKc3wMXyz&2B^tagXaj_f}h|%IAK4=h-HKOZ;nw`v5YqlL!cL5*`Ew zCgZN$d3-DcD)4yXi0~!IH=`mvzwghm9oKLz6zCI`yd1tF)B(XVIy0mwXyG+*;GZ!a zb}lXwELp6+^=uJdCiq;6dF+>^GQK^5ynFpMrz(N>&BoNR2J1%4z4i3 zx%;Wzz~!2-Z-$7Z;V{idRB%MW*b2<^@A0k9!JFN~Gvmd9>oBA?vgYr~z;Lgrx<9}Ebde~9)!z;FEs2t_ z#z|a@`A5joDoWdSezp+5alT8h2eDOjsz8R@^Gu4G^N8eruq2P6jvQT!hQDj z?1l%FGEk`28@S1g;+)I;SuQ;>aX=DHvm`a`bn>O3jT#PiAMTA|B^;i#|U9>^kt5g)_ff8n)Bg+5ZuS!T$C20nOwPFIlI>HMINBS#Ek-M1f<8JfkSwP$V?d_u-UI78%OEf zU9%fYIb{ah3$>J&{1XsrL)7@~Y*!D+c+rJvP;g=#q!RDR%mLzrPQp!qp3{!Ma&XCPk3j$t8$my?gb+WT29|TsxyEFBU00 z@$ruF$==j=WJ=TsKA7VkOWozvL1;MIHS}D8%P_6$(C}h2DkIzf%!AWJ{{c1=k7^xD zYE8jt+k&c021Y_`qnH~O1yyOuOKpGeJeQc+k-D@T%Lqv`wpZ_Yju%4~?PvGhrCo^V zR&nX3E8q*X*Cx>n_%I6XWbQNQ-;ccV+3>R_;K=*``N)}mA9;|%s>Pqo-$MMp+C!U2 zQqvfDrZ1<_$b;}h9z}6=)au94yN}BZZbiQA!WrJtu%xDgr7p2U9n;G5*SVkL;*wou z(|%pK5Z1$qyKr`P+N9n)NZ|-Z4ej`F=Y_z=B3UlAsbh*OH7XdUv{$%>-EWcdis@mw z>|pz4Wi7D7+}1h0;Mbn0Ks`xfS%TONI&so?$*FEQ(M3FY<&Sbp&rDol2Fb!FhwT`t zSpBJTJK@COfu<3tbDWGp5}gkP+jGoBlV_lBj>UYDO<*yoGudTZoTxEG6g7cS`y4;$ znirj1aqMB>+>cA7wb0Uw%gy?ebLEzs3&7iuRC7@ens;r1_N30Cc*k z;LgtPm~Uxua1_E^nkyfW3#*mg-B+~1+u~Ltj^5JeyxnUP(GC-!7tc4xDtr`=S8drS z48AsP(#Ja)`UX|5e#d_%l~{)%5$A_5t_I)f(2A%9#)VdiO_`m`kU&V9%#0lhBvu!b zVVy)&LOfS%24NZbK6LD(}PA_P>(NI?AaVUg*}FG(Z> z8uKLCM|#Tbx*1&MsB+}-h>y9`Y0nPk%ka}euX<+H6g8h$Bw|6E5;Hq53r26!>C9tK zYgLAQ526STJJj7MH&Zx|??k?m1)xk2p5NX`b*%RUpECJG9u~ZleOrc1>`(wZUtA zg#y9k-TJ`Yg{aF69O~a`D|>|edlnPsuv%0C$_hK!KV~t@pR$r@ZJY5si(y6~&8iX_ zWzauWF1nnRNhp_F)5&tsBe8^~8b+V3PW~d$kk0Asb-AwpfJpZe_6WlVGWBhTt(C)f z^euI+;JhRQyr&At;E>p=X<0a*LVx8E*f>HgpC>dkYd;F6(Y_@>w|IGqD-W-QMf9zU)^v9}TP>TrMd< zU)7Cw)Wx(&V)hRRSA-#s!LR6PNt8%@k0QlZ{hhm<%eF@m)q<@P6uJylY3MNP0Y*aS;NINI#I ze~U-Va*erZ^Ih8-!k3P1?0b)}GuL!x@x&QD{GKi^P@$K;&J?&gr5v9DM2xclmi9R~=K`7}y$K6G=Efw^SP ze70vqz1ikgkeDE&b~Q4!hqY#WgdY$L`K-4vQm182$kX8yX@}hdhRMk*hmTC<-~X+1 zpcLd;N&yPhI^;iwnDtMgO1h8%6sm6B!eh`W!qiYnM;^G%TE%7 zWRkL(U#yP58kCm`ea5t7gB(0#elJ>4zu+t0LLy13~xaz z9nL^Fn?lu~EYFv%5Xnrnxk&H@#9KzdGQ{JDXAklz(UFv0P9YioVd_ghej}y<+ z`!3FF{Y&r#U%GH0>*BFn13LjxmAfRpde@sBOKM9y( zt+@K9Q_>Rpb)VncX|1+_7}i8Z_4rxaI@shj^1dQj1tr_^aaiXXDlF-+xLhY#sXw>j zP6g!@NLV3=6ReJ$4pesj$ueBEt<4suykSf% zz~-Dg5~5QiA3r06x^bcG642o2f}eCcQ=6yiIb2W&%%)1PwLo-Oz@}>48Wb&IX)P}5 zfM)f1H&*$us$SXLvX@RqucLHPR*GApL^NOvQ(e3bAHM81 zR%<3?rSOZkL5{n0mK~UsmNh#9Oo4O3a-N1FBuZh%O^IAL0%=9C8u&U%bWgOfEyNg2 zqT`c}fqXtN1bgzL__7K`U|KG3sEyZIi*u$p&;TO)mJ$f1Ed@)QA@68Nxs{m5#kACN2$iEm z<`MjK?*L(30CqH0*AkA6FB(Kb6(z6CHn!CMD4QM?BQFcru6M6cMJ;{YyEo*@K!mjd zv&vsgHmizatvqYSw)6cYi@K=$E|$$;9E&hF=Jj(N@K?-Jg8O2%6-tt)GXY%$I9IM{VZoveE83QVQ+%lAF) z8ZQNeg)#(|02ouV^f3}h)pHFOrNE8N)^e0lPXEi~yP zws^rQdj8J8B`)8&XyhvrF4;NKDH)`}h2rS7^+-UY`wmNY%&Dzc2yQ-`S3+gDfCb^urilaQ2WC+3|A7fx5`z>MLs`8{gYc1dv zE*y(`zqWnH{vN-#p4l|VAE-=Mi<4v9s$;&5+;K*5Fc%;oPB`^aTKrL+E^us2u-ZCp z`}dn?l~zLh8$w_Hb9ZO|eeP8a?VG-jP z>gZ8!q~v*Fd`Dq;Lvglwc`3qMU&%rvLO;u&#g%jPC%~eELppQF(j6S?#gbiDA6&~n zz)%&$Z}JDEL*JSp1f_gRqHED%J_B>}L{ZyT^40z5OUqf@BI|DBkjodqcY2~!_Jh9k z!AMN^{kFN!zj80v8|+&VL)Xc?z;B)o9d=PH*&V#uzLH!o$tR;6Z^Bhs!>KM%+Jy#& zIH6L=@bJmpm zAR&p^0a`j3=mD3m&YXs}1_31FyL$Q;!dB->dazkwe0?1eo)cHZi;IfN}I z4;0bMTPec4S@FK+@);}vSEk|R<&CyqlfspKhow;7@1s4~VLZ zpntI<>bRa<6LEoKX#B)W>*VbtRZA}&PLg%4*uyNxetLY$df&qXx~`svrVV)0 z!nYpalvl?=pJcg}7e5^EB`S_DrBNn7*&*&V8cgJQzB!Qj#?_cjIXt~9-^b0YTLeZ6 zbRdrh(%SiSpf~CBvvzfjJUKfl#Pz+>lB>2&*SS>nznv?mrGX9my~pxAb{KXp8wP3^76B3;ylEZu;M^RwJ zEKbR#p*7PKdjjzz!4Zxkb+DJsjBk{DEOyD^Wrq$>wTm%|#nlt0eWlEbho&F#LrO(P zbckFLD9c#Xx5GLN`ayZb-_g&~)rIv~yH*w~s4W7fP%sFCm&f-oh z%P*iNO@~R>l^iEBtYA?JFgt;K%nNc z4I;Lbp1Vlc8w|TZvXJjLg;_bPHnua9pEaxsqIeLrSU6lmK`_~6 z7q;gM6EvOS>v2=^3;-1)mGtJqS{1pJ6qB>*mC*F`+S)1EC3v^2{;HrQ^aCBX8@jJz z-pZvv&8}A^PUWFQ$9M6%QzY`1*Bt=WIbN`w#OiN7$ z!??2hvr4M_&8&4L(@*1~yefT1R}LN8#;5&vl_7lN+L|fUy@3S6!)M%-^h?HW`U$o- zvQH3fdHl%x%9yFCRGHACZ%c=-6j^#|brc zDo^7)Sf`E*D4u;^*=XP))QvJN^bl?r?19R!yGt9uF_~NYg)$@BrXTHb8Qj_}5Bumi z!p5nQ`SPz7_K2cb{QcvJ1g{Qo$@IRG*pupVm9UdV#dYoRyqh0pk7>7N8|V4PndqeYWy*0Oah)?=wy$L#?EE*6eLgvVC{T9~I`ckPW~ zoFYYh)0(xHt@y52jX~g2(rF~*Jwl+iz)uAs0*R-)m2q@$a3vA@9kmmBQDTP)+nwZBorubVq4hoV?CmqT>-xr>KjSo1?A-8-H z4+kiqodUju8bG52754gZO~UIs@`0^@)JJgHax)3qpxmy~#mv3QNdvAca$`#GpsJXm zr90?b3Zgq$N|;8V^}_J5O#1Kyf?$jAV%tQ}I&zlkyM#yD4PLw^6)6FkE9lSkB$PQ+hM}e^SkU#&r zY)PWq*t8!L0%qrx1Y;MvFT*xRdyVM6&@FivTxI776O-=og0~$#kK#PRa3urB!sut*`wP0;vqz9kJV|Z&+sW+==4!`YQ)PqD8+ zTUD1S@!S%Rb(Wl44I&59nw*m))`lm-?C*`~y^O$P>Vf?P=0@xf?5SHk>cIs7eQT|z zXVQAEdBlE&jKHWrV-{uQ1`Y5cl7CPdX+@@~Epz1`>oe=$9Qdvn;ls5uUWPC0US}7o zZz&!a>Y|CEAp?%CtG7#4CFaucJ|px>(b9lTgAmK{6S6!C>62QV?GB zP^ipZkLJg(VOTkP8pkYJd&y={buG{uL8w^S1Lz!`G2h0dVMq<`1|d4&?x)doS#}SB zb9V`16j+mYB4%Yt?(zM-Qn&t~#$pF#tqp+O{8QHcf&NKJ*0!_sNPZuZiNE!(b~8!h z+UQ!~fSI}|@3OVs6}2DUgPl`X7aYZBDkNN}*#^3=Yw6yudl>73O+bk}7RImawqd90 z@{g_HG_TOV$xV<9>~^Il=I=6qXs+Cj6SaY+A)cUWOqUKIH_?gA^vcr`A{t`6K7M>MBLZ+5Y%BWxMPnFxaU@XQB0n4!K8$b%RSF1#philI z1I_{Q`pfm-I9Zm$Y)_8Pg$2Ebm)zPsBATfK$_wl@9)!oGDq8zwoL^1yyYo;XR!=7x zJTP_OHI{y7$Llvn+6g;zbtC#mim>2?s9gL?r;H(%I)PPcza8msh307)Yekza3yAaF$z zcu)@)mkPA8BP?TgMdR^vJzc};>_tYSUqf47hsEi$t7~WdN9XiRNLw>dx0P{J#EzH$ z5Iex17a*;3LGiDjT=*?rCA^aS!%-^f|PN`{Hro z#~x3)q}ob5x}*YbTrw_-0d+E9BseeIlO4h^o&sj?VemIDjGOFg+LsLhlk@r!Zg)Cf zX=BeYvAL%X%QTOh@w|s^#d`Nl(T^Hr!3g7%8q}~lQX)Y(LP|47YkUL)I&OI#h+0e? z2~z+y(`?3i5>s&3T3Ld_)bVXtZwN({!LnFUp^Voom^)5<2iLd^jqKpEBamgIkQj~X z7S4rIzoysujl-0XM3Un`KG!dEL?TRjN_!jYRO{BH#v|B)mQRw}f?2DBZ-hai1vhAl zan5u)%9aOnF~|*$r|#~JXmN2yS|s|35>s_~qQ-}I;O4w+X%RWrzf)q0+D)?(JgTP% zfOekvQ>#!W{Zvt~ya{otDmGoM#=fv!NI+trYB+((QJ}U^Ip17EkBVa{PS*v6W25H_ zC@fEun0z<3+ITM>pBO5!1f~1__IZ<9+F&d*Cfh)i{uch;zl?0Qi)5v&YSw0gq43M{ z$N`cbZ$TF>ke29k+srTodWHOl3nLZizZF^@c;)`yiYJK(de#*Qu4jZ z(vW_mJpy@tnjJG4+bMZgh+u85^34>w`~JRflJZR#Nk^Y0pB2Ne*X06|1IvB3=+*n# zuwLGi@}hA8Q)QbAB-L@tU1gRzgOdCVamNLZCb0a(k~&iGK4 z=QZZvZ%M3`mGkdW;tJ}YZ^<9Y1R(s`&e6jGit;>R%|@)-^jvuZ<{$*zeJ|^lRFdVo zWdjLq*jSWr%P|3l z%xKPE-d}@-=*h|qRDF2N#m}$Uf<*d9}=H`%~I((8|CU?YIN?@#GSRQ9*SiPo%v(cQs#tdSpGme0a+f z2@Om%~ci+_3}I#|4x zE=0RgmZ_=>kXYfsoNO!aYlh;7J{0`M8PlkP*#PE3u~G->5$%Kz7$8XffyFipW}dCb z8Y3OX;!gBH+A!dO=SBnPl3LxLz>Kx93}@9kyMv^N=(wE58K~lGeLuMFd=m0 zUbH*a(;}>oy?#rDK2~P887!&q6w@m30WM=`^>oRn&by7d26r}a5KH0V=xYI~+a2&2 z5zUIcE(O*VY9p8g^DgxUEDxjWZ?I^mgGH-VT*h8785CV}fKh^Tfoau!>}{@E^F-ql zUQux$NZ6E2Usg8B)(*(~=I6!gC?w679jfBze^aZm8oUb)055!K2>+b5f2lwzt2V3b zNc_GcQ;OiJ>oS$(>P588cDp)CPfjKlW_z?Pjm<0xCn7HcwQBuLa^04klOIQeDi3;Kkab z3f(x?>iufv%}P8=o(+F`6L3&=Yl7OVOwoRtawlPqrZ%N^EO+Y&U#w?c8lHB2SGDjg zHYdpI#jEt;g#%=G8c%1zY;M^(IN-Z0siZFi#1?6gD80zUa~I3XE{3snW)ZB3dg(Ak*RW+uCt#Q zcsg(6wqg7P>K&V74O5jKG^mGZK#eJs7k3Ub>6e1?z3)47%0i4-t8vn1)UE);3kd|s zVdD5&{PXJxwo)9H)J&PcUU+dd;YS$p zH}g4mveC4!A9T|)17@$$h8ptAH^cZsBA%AGjCdj<0pvBaZiE3MVV+5&(N2-*(w!0l z_=r?1+!Ve8zK4iE<7i9Hk<6PgofgNYn z3A23T#SF6}sF76l+jVYz4lU-!tCeV;rn4V)#ZjgST^OX+ul(+&ljN52lMQ&cIg(w0 z=*<{+UtPgDZEJoBQ_W(l3%#~P!KXgkeNLrA-D|v6Da5BJsjDe$l_7YOP>p8Zw~)g@5FB~H*ziv={-eWq|8Kt>KPL%o+KQwVR1fG(1GJm4`bpz-d^5>83}9Y3 zAB2^y#n0Yx%rF9d);0tF^3*sOq}3q2t~DyxsHfcAi-5N|cUVaz<4r7dAfQYPYl z(V3RODaA2% zGDrR*o7kr3>h}h_kfyjkgoc|#BSrJ|(FY$C1~@+*QP3BQYOh&&$GVE1mN#U;)pDN} z;O`3EP}D&yIk8r@9wCZT&#N(X(MroM*-dy6G|`>m45Va!`){SP+{ZIZz7b2`1Ph|P zgjQ5M)$}eekYKCc=Xw=u55qN7Bu^5w)Mj&k^|KSF+W3sTf_DFU(me#$X^VUWvW-An zo%{T64lV5mg!$i==cxa1C;)sn!ZI66OurCuOQ@OviyucQ} z!~jU0*mnC-Mxzinj#S9{R~;A^W2=8qgqLZh1D_-PQn3MLbWmZH1r7|Ol!kH-%wdNy zQ1NxYq8V(|;*v1Js1m^S{1l31<7IaECV~gfWZ7>mt`niuFMx`*B$p%Sb@~a?5CoO# zi8nU=9`xyTVA#2+JY%G4&29H3_oO*m;@IcMms@4~1q!(OPrE-?OQVXN7gz2=d#yF%k zf|5Xb)(O85Q^XT#+e}+~!SXK$s0_y3BoAky1yyTK^%CZS_t~l(HhkJ>b^cWeI(-|f zGEhE!D4iR`?5=!YS6VK4DlP%4nDQiJ`RhI7Tkjb=-^9bWRIR2t*zmFj19-@|s{XUr4o43n^C==5@vjF@kVIXOi+LYF&i8U6|a z=xx_0@|N#bEU|Qpo_CnuKucYPmv+I&I;?ZiH?F@4vQxN8b4TEiP=}Apl~!ztWXS5z zpjj1Te2g9v-!IakGZ}beq?&n>77@`HR3WX@q4?0-c|QFzheO4wL?A?nn}wWfMqthW*mqo0Y~1VJR{x=(LiEGJ~o_z zW5v2TQH0rg6o7lo0I`_!a{n@@Rh;nKV8x{yZ)}9osp*jeb;|-C1fqND@f9o`A%&W` z6xJc(53?(DX0@Xx{n@&+fY!4wAp``Q%PsodHiYWSjt+W!@{eBAjL5X+D|OOi9h_uiV(0UECaU^g$_`s#! z<~OsW*8Pjw@qsj70(a?tcCCIR`?*rQ8GTIm_xX{+=u}1qP#(1YLwWeah@%w704otl zuSvs%a>e4@N~CdS$lpK}=3&@XZ0aN`RyOo(aUMMvjubQ4jdhv0>Sb7SHiH0So~@DsGp3?FWrfr1j9RS7LMg-o{{=oMd(xkk2!VVl?ztAXjEQ~7es;i01k``6L@>Bl zI>d=e>*W-P=RVel{9cJr8(EA~(n=QHb@s~hC3vfEuY{@LzbU1%aJ>2y4`VTptMTg+ zL`=2`GfXyIDb5`ah48nO7tkCJ`6EJ1BjKQRUs?%^I%%2RSRb|Kfz&8oO~z{U8Y=4p zv|Y96BOr--d-pVlQs+(jNwh5%t0a{vbFJRRx5i!^FkU46*LdN5Y47*KLX?@{Hh6>h zf9ykW-`aL6{a=Fchnzb9--1xHf%N>abd&&Ed}?W8x-bG!kZB9d{!}~oq}A|q{i~#I zqh3v^{yP-^wVJ{R zSWP)|0)ztVcPNG~q zvUOKH(fL~%-h!6?Nn_?>Nwb~Y-hg2m68XN4)F^pspSCfx#c=JtINllM=i7YUUv8%0 zg|9G#uF8Hagt^qE3gicNX=SMV>H@VciKTib?jU_M7aYwFVVpAC@{H`}Bf3+i3-X z77@L=jiJ8O8fy{}I->JxO}mWZ9&q-HXRdbE@Dm)0L6yNbJ{@iloRVRcpH0~nIu3bu zuOgY%vK3yaU63^vKHARIA9>bf_wWN*ea7JVS-sem6KV_WY9>!?#rz1ROOc7PS93i5 z`j(xBe@)ma2k`n6nY{^0bZU4J4ig>TB!AUauzg%3yUZDC$~!60@yN}oj2TE54DivR zY@iR5!D_~l zNImN~c<+g<>}UUc8mv;vPh=IM-$#Rm^#Hrp*tmc1o1`RE-)R$HH}n`imbI5ox0cVK|m;7O2K@RcvzMC-)C z$2%S z_Z9YKx?8OlVVaf(ooHiWPnAcNH1??ib09k;zIO1_`!zIWvsz&RI)4AR--MaBIv2YD zJ5%+ebhZs^UT_E2qIxgAuo-B7Vkim=8OB@4d#hsP7BP%|lI86#4@2SKp&%4{P$$W!_FM6W@Qc8m1D%4gJ}PvoauV-3=QZq}Gl-uph`OA!^UB`xO1@K4RbJy_30XV9ITNXpgi86q*T2Wmy@7 zBQdt8Ov&h?;EBg0Ur-J<>W=0R*b?1BT#fzN6;^be0vCmKLyDC>a~48Ueh3A8ffEEE zks!}1@ll9}zkR~ci5mpFl&|6@?1O+>1-p}Q+R;b}KT!fuT;CI@l zrBEEd?*fdO9ulbhOq7@z;3xuAcX+=$qgNmQ(DYnlpP zc}@x@QB&LqvzAkx>j>Uh8-Nl|EA2mH(#W$VFecKdp_487@5n>}3_){jj7|hfEPfSn zY~~*1f4p#VngA~xKEMlilu%Qz^0dkE+Y5(2)GG<_!h!$s!olBeF!(9DZ~t#E+|ZE~ zFHtZqAy_}6Z%+W#FB~fM?&fQ+h^J5+mmRz6u?9Z8tP7Sq!(nTriJ$2f zp*)cM9fgc3PoNP48kl!sr`D#;egE}#aS%sGLd4onj4M*A%~r`u2kEVxJ-puG1N4P0 zt!R>@S6(n>TM4Eo9p2zg>NhEO%>+Hb0@|5d#hj_K(^UG%73zfUuc_IgCX@^K^j4A# z*wOI?5WoVO3sq{f47)rmJcKCV%Rc6)2aHl|5D(XVr~L2>nAVidZr`a?*XndpxOy8_Cf7c15=8XEMf&(QWR1_ zp>uKCP6JTGv!$O~>*>=U5u#k|FzS}n%X|BHvAVMM+n$QHwdhorRMF}s%9HJY-Ih`K z2ewNyMK$f@JyXEdzTP+h1`|F0XVog^ik$_=WKpJvcQSODH1o~`PH+f|uhw6lTLM7o z$yh|RTfD7Ue52Eb&km$-#NNQ#$YHb&7?HH%o|Yy|E!VUL5uk;$?i?a z!>MR~!Mqm!vk3G^@(?$pO%)iN%NwEZwbSC`9S4-g$J$lw;6vl>KFpxIw@bN-!#crc z-_b_tasyZdGDT^C+E59|!8&cj8f)a8`l=dc+U*D(*$K;%vJerckG+?S?;h3T6Y38{ zX-xDWq21a3jS)p#Qln9UA>U|De8DQJ>_ww!y!^we{*K|e#UC@RBe{!O`g(U^NY-AI z-igJa6fO+=Dj+DGE z!bvP;={8T15d(AieOwQy@!Y&wwl8~W%IXwp-cy|atGzRUr>cGTzIhfIx0w)9G82+{ zCNs&9d7kHznIbaJvyjLbA!9O&Oqt6Zg(y?zccK23);{lfKj;0Q=XuWA`m}s(d;Q#d zuiskh+Shg6-+N3+Y3WtThW#YKPh83NmC~WUzS4-S9qvwlB1DtGB`x`YRm)jn!sX(n zyre-g45G2PZ27y|JL%hq6^u({Zt0y8uS7C)?{Rbvep+nZvBgJz;^7ES!h-YB#VM~* z8JOgwso2S1^uCvn7ONsO!@F+TR>d)F!TPW=^CqePI>LVasuR*UL7(;f$7!D3Q?>nQ zHtM{i@{$Vldl<*}3^6n+#{JT_){p4zrN?9TuPRiNT^DE;{BlLmC30iIH3L3KP43^qz?oL{BO2p!#sD_zi%? z@Qx`YBZa$RRFJ0++{4&?RNM!d%1`>aV;&sc!`K6Zaj@@J21oG%_b}q9A$DT(btIJM zKw2IsFL|>m1*LdUi8p7P8|k((Y|ra^KCe)MCo&UsmX>Fs6jK(-<~zQJ@%Aq_Pe+|o zGosvWYSn*WMdmjgiCO+YRx8R>+mYb{0TJlNTC+^I8JiI3GW=nxN!sY#2=yFPwu8$HZtl`bn4Ht)@rqh%;ACD_ZJ)Z zmI2=rxwEbl9{JR5vu8O*JaGa+8*ct$!}j34>S4y1^Zb_DHObse<+dizG`TuDzBN{K z^m+{nY9=hOTbYz#%M4yM>RJM(+6-|pmnX4&*sonIj^AY=SsrkXZ|c?}*_1Wj+jQ7* zxLsrah)4dD?Q5bnb(?_#nKUhg1qYX470Z0>f%o#hT6zi(;%o~$;6GArKYh!cx}Q2* zal_p!?(+Mgxc&#@Ovb7)4p`D&l&Vic+B0&Qx9;Wkx2kivAM8R7tkd8=O~^>7-Ch$P zdQt_P8Yu%7m-wS>_BK=aY6kLKS#;a!h}R}7qQWO!*owY}jniGt)#>iD#&FV8ku{&n zQd_%`NjbZC!`aOIz3qK0a7!}=3<}E4^4)l<=1qo zFb2<(EM00GV8Nbw!?lT@ndK;F0?=tA#NNfUnE%fvylo#>_kV(1Z4g<`X z$JDE_TL~0P@4XJqP^@L1c|B%(z#cQ$`=&h43Em!Fd>xp#nv z_>A<(95v&N`U)q*B(mx%syQEFFZ<>6+Zw8<#&j=BcRcHw<0FMQ(a&V_WwPfMOY^*yhahw7`(H=j%0 zGkACNtfWxD=FQeEoKIg_w*&MX38IZI7=GTO@> z@+e(otNP3{;zyhV<`fcF7zZ5I3GK_}1&N&z3WP%kKMM!6u`8xI6A*4AxW}mn-sG0e z?GLLZa5qJfpvqfkdNf^+?3+m;P>rZHU7DQ5q?~cF)Wwl*U|AB&y%W#ERnImeruPH! z1|;rdRkQr6PN%-+s~NZr7mW9W7VgX{v?8rr1Q>1;{m)+cXtmbYx=33&TU1IZw&hDC z@i8(;y$M)W9x9qJ6ks7B`1UyEoZ(lY1)1EP>wbz3Rb98xHxA9c>s}k-=%ix{U<-3` z&iP+G%ap;MDG-sifbWxrwp=f@wAD7weT6jbM!8n++Bq=1>J{kuk1n;*T|jj zO`YkybsYksdDNzc*(#z}%;_E5*B9qaj$ZJx;~g*hJD)*EWgm*_h)?@vB$O{RM0@xQ z*L-nItt_3g`=_KL4KuLUN!qE^3YJEs(XoAU5;>Ky$Z#I|2d-i>4Ht-_Q%u42?`W1} zYoYH?3Oy{6GQ(^g(P&q+{7Rcrxl`faZI|r#X0?ZwREu3bBQ7vdXveETvzJ`suvHa( zK4rT3&_a9fjlsGkH(f37KqYo^K;#*MZjBjkJ4#>nHO{7s-}+7OPvMIkNPHCz#7^jL z%H%(V2u#d3~zjHXc>-3^+LO>zSi|Ftao(OkD zqxvdvGwg=mH_vfW6NwoCN_Dv6N6l_x3O+1oM)0BioaRY`B}rLb4}@fCgV2Z*$eTAO zTp2I3Vf1ZAwVi!KKkty>l+pFT8je*tcS@+rfE zaLjk4f@j~|TBV5y$>){b9UeA%@>$Ui*${t3LB>Qqj(XhylGZxb;6DU3(bCD@RDVUV znnCaVqFv$fEMD}SmN-hD{@(W9w7dK|E#;MqOS=3H?XSx`?Ni1aAUNZRLP9|AMA|4aN8a+DfxZF0!e=dn@w>`nd9ZZpkSXy?<&k=%f4v+J`;bRG{2CIrgGg4~| z>fzm`Ns1OK5jW8|F%jyiR@`R)VZ}ketH?NoJ(csyg=N0l8k9lTfO)o&x=tk>ellLy z)eJ1=G~5Jl_-JqI(PWr<-IN`4Zg^Y8Z(>nsMVEeV?&XMN9+8O-?;yp1wH~o4sZwX% zh+-}B3`)JruOAB8G(icM?*&m}@ne{uY1oHgzF<{D?}(X)MdZY7#E7s|rV7j@V#kE_w2$;$F^jN2Brobsgd zZtP;8=&HaZE?qR&X3XmgKEvWuco9+H5~Y*Ylb3Em=N*f6KO9XklEi1XsfsQBa=qmS zZx_Z94QR}`4o$(wH_$h5vh^}AQnoKa_186BF0V4uw#PFCdtV@Mo3``<f$ z{WmhJ=Fcc6D=L3W#P9Erz!mFxMewN|8yh=hFiHk@p+|c4Y{H{xtnuFHJje$3#|kzn zU%X-ae<3+sKQb!qBZVdiNSDw_H&5SA+>GcyYcL{_yCuyrZ1B1Whsk?}Sbm_DpeOx9 zSg^tC8+=tF0Jdw5saZ;8SAWjuT+ci~nM>~ClTESWwX93lz4lp)4U!F)+dISjEDg+S z6N)P^FeP>A^IRTv%FY6k)_2Wt*V*4lH{x8*Ce1?{BZobx)Z8J$R>I6#YKtA z9=;F5Mml;|2-ZxZ%E!?icXD1p0`6f|GpS-(~3w zGo8rQGj|SL;fT3ccexxkMioSGJik#qIh||yPc*M{{HTt>n%7~?>wk~tb?Zv2C1xPa zL<#_8p!832{AgZRCSyC|Dw|TJlkxSxVwE;Qh!(l2g)!Ijeu=kQX8Ps5=E2C>WoBDE zDPfF$GEM#ix{*k)vHdC>S9=uikw#Kt)NQPik;}oFT@88PT6iWG;(~D0X}DgM-Is?` za}DQe9@Aa9do(ercw!^vp8iAyFfnN@ym?TIFc$UJo=5n~T+&0#t10?JN?5z0iH-D= zYNBvlz{I5T?-P?qW*^n=_by|64Ai!aZ!K84*k!V`uVaxs=vNcxi-1UYo-Fv_Y6A@< zN=}J!%QAmEYDmn+%l0*uE2hwwP&I#1TN|g)XTk?;Z!F?-2PXs4(i(0nucV3q1ew77 z$@v>n&nPzY*CVw1gqHg*00bFNfFQFF9pLFhAZ$VW_V%6+r|uBFv0)}LF3FN&BcsW( zlU8&ob|Os}UEepE1onXTD|>YMF|JSi4T4f%KBUJYs_eKnzw`{4wkdFdpcvm>$$-!) ziWh~Su$JUvg<|&{agcauVCR;`6$u&FY+T^u)cF@*%IBx~@H=~GlO|SxT+_1ZY&?~N zLyR@n;=J}#SB(}Ia(I%3$4K(N6>~B@kR_3IV=^kU?9L{R$!sKviNIjl#UhG+_73@* zeZnZ!cogu_9bz`JI`z83B9B0%8)Rd+f!V}%E+t#q zs%q!kr9!m8=Z)NogGM`HVmIG%j>=y#p_AFPm~+XLD}H6_s-B7diT?d^|-Vo z#+gtN{{{*LTBY_1?xr)^1J1!wW2Ll81JazKg`9;&^yJLJ{Noi_CiDSv+07A|jfbMK zi7AhA*DQz2U9haw#WO0R6~;!t3Ma%C@F}epXf2%=?^?NlPE=OIrV}DFPk|OdmkR&J z+6m7jHrq-j`d~gM`X>#u#(3iM7=8I&k~s{aS^>v170CKenMcidlaVQ8nYm)>4#oT6qwnG#h_repI-P*fT)t?iwI zpUpBqT*v1!cF#mtvCVWwkA5E_Pn=5--5Z(xzHXn?11ipl@e64Y7M+jc2_Wj5RlCyG zt)pgeU51p`HDRTk=<@+Cflbb~XC1zF+fjc3Fxgn$4&BKZ=q~_fwZ)Kz#F??9cA5*0 zU5oFkXe*x6YHYbiW;(@*+2kCb{Jh@-FBt(D8=1oQTD|@m8DzDkj%B~Wy><)gv@qB2 z?FCc%4?jsfACN!lZfsOu4`#7*M8LUsdw+I1f?6r&3{L{)X{cK6g8I4@Rq5s5;vgehTP_4+`sd|isqci>36ARZzmps*AtkPob8RmRe#^i z;oA4+MpGt<#L+EG90H%Ztn_SA9a~IEq}{}_>`Q#W%(ZW5Zm9@YHw%NZH^$mZqFM7( z7v+(vrAQHS1As}%EP8dqB*f|AWl!-1XN)+T-oC!ji`93(dj;q#$lP+sm_#nu_!viD zmD~Ke)tUX=>`vhA)*G_@JWN`cmf1I&_hSdl?00pn-lir)+OFI&Q-F|rz;ap!O6T7q3MuPx?RoF?BqreW``rw87dSpLQ z7L#cLw?27ULm{FYk4fE7ZhwR{6bh`Vj{0Jf>P%;JH>Ztsef5TL99Tjci2;I@6>dfE zwgx~fNo)|3jsS=y*hd|92K3dmPrh9wjnG@h-*;F_o3mE+Mo!ewQA&C+aWaE~f&8Gc zmD#;kf>X!wS9CX&TMXw3cIM|K7#O?z-^=cXb{tNSGJhNg7`*%c1H2pB zdwyIWg3-JG0(v*JBXWXPf#JJh`0jrMz8jj2kF(CO*~9-M_}$Qs@k!1W2JnUfy#L(* zZ)gtuo_~cAykP`y7{UABL-2-n>cJAT|635=&>V1*n1wOCVGM5=!yCr%K3NBm^EfFU z3S)Tx0~p?1C(Ile!~4I;@a8&BT*DaNFoyR(iQ&z4GBpIo@P;wG|2r7oT>q+T{0n~q zV|c?D-Y|yuZ_9{t{o1S#V|c?D-v0=OH`hra2*&V+F}z_6@4pkno9nnf2CKsVW2^B0 z35GYaXJvj@P;wGVGQrT zj^WMoJwps*c>h%lZ=RFfFpS|1V|c?D-Y|wYjN$#)GQ4?CY9cU(H;m!^-^TFf`O!QN zV|c?D-hW$$H_wmi7>wZ!V|f2#7~VWTn%7|rZy3WH#_;|(FuZw=i+3=F_y1moH_ve) z494(=F}wpPTiX6c3~!#}@*s@i{kLX#_aT3gPzDwWki>w41J+`JbF;ea=;Ur??8xF~ zZS_ulEEt$kzE3!VlN%MESV`xeOQUGk+4xyhZ%$JI=|yE}4c-2Z1>OAfq#5NM^`yy! zD|{TLS!~^Tt_y|RapMPtYsgiq0Nc>tdF6&`cbWcm58BwRd;^6pjyX)@~@! z1uWdLD$`R)(I}}{;?(nyvxQ7ebq=&}kH0S`6HSVlEuak~+!bX_{|E!fQ z=L4DUvfkAySM3f{z9On+9UsG_rqIJa|ErH5zRA(xN@VL=Q1lsdV%x5tUvA2`PeYvu zKXdTrCGUZeJM+Vr*Ph!VXU^kit0v(26auc1IIa*SU7J#D*#rZyE=4wt`9 zY*uw~t%h-OQ~j+W3E}vw%ycR#G(tSo!AuLU>NR{sRyJ<0cx<==kKWhn?BL+@`U^>UpEc{JD8#!h#YzGJNv z3D-wRB31Oh?l3x92Q>|D$J#fVyK7fFyC(Q- zNv~r>EWU6oGj_!w*nt05_$rZBMpSFW-kU@AuxtDc#z109(bJ{9$6Tv9uh%xH!!sqt z?JllIWXU~ni7paMeOH&YmThQI<~Ff#xYmdylwF|^6xKn`K|SW z0}>qEIS3pa&dFKkYU^NWU~6l6be@IAFWZc969n2e_aMI>bR}zo52hRQrOzjJ-G0;N zB(I8hHL^pps4hCWiBE9g!G0n6S^H#H$yP996^ntwjp zE-^f@uKWC8R6R+8*UPN#&4x?<1^4Xy!ia(-h6mzoJf%bm9|u1Vyq7>7J=7nmjW95D zReq5pm`<88x-h+0TN;zl)hapKo_CmiVCD5exZU&)c@I^0YP4Edp898J66^^}k}lG> zc@q24NycUOOxk??XLdakHxpVJ4<+5E%Q0uN|cW17q z+oU?lV&GXsy>I8zvZ!i8I{K(w6b=h57`kHYzT!NpuC=JgA-@*3ZFcUJR*hG;R&Sf} zdbW#3pSr~IZo*dcH%p!*QT=X2$$n1L4n0<$B*es9qw2f829T|nQgE~h20iS`-cpEY z@9MZ;Jc}zY-rQ+szI6%N1TJ14v1qIi{i{PmC;a863vl`ICIyzuzBPEO9p>*VhHA0C z3c|l!nH28VPc>Jdfy42Fd`h5i+ksEg<#X>WdwYT7%I)t9LYH!KD z<9tyYrC{YT6C&KU9WP6zJq>ZEbnGp%9I>r3L}2ItV6jDk$AWB5;aJ3Q^OA&MtMl~br}U!<`{P7)9od^|p1?$q5H z%?3Y`?2xqkShtd3)}ccu)x#r))x$1hsM{%KF=X81NldXJUMb(4dQr6`GlR*!8ilH% z{Z|55BFc}oKeeldpUYM$T(2+KDT?xHF9~8gdgh(LUEm#R+?k_v4DV&)No<*LOU94r zAtAmU?TwCdBSjwNW4}Ro-wj5YdycI7=c+lv3qGzTQ0rGpeB=ue%`>Ie?tge*ita87 zJ9l{+b;JS5&>GSRh;o)zMdEM`ArQto%LCNHif1SlR>q>$)!4LsFdy1YX*~COd z6g{=POQt)^6b}{>|%O`<*SEp-zFwjJ+o{VFjdZHL7H|!=X8~4ZJGnfaT#A3a zNF866yGCVg9tjZyOchWQ;c9QGDKK|4M#Vb1vO|KJ9Z?5hX$Fu0*bo z_CYU$>gsAW`Kb9sO3S-Cs{E~)DbB)A?>IN=6HT;NI!Y*3UeqObYjD4_vwFPdFwA|o z+S9TkJEHkq;*^WT{x>`RXScT(I$h7ZBz1Y}q`uflGrS_Nhh=l%@@lM-**Gsh&Sf~( zT#aYt-r~oSZGo)nwb>W9J$2r`TC>c{|KLT8PJk{PArgT{Ktezw93dKkPk>B-EUXlm zDW_QGpGhy=dzIiFK0!7zUeztL#FDN_7m-SQzj5@B3Ro@-P5f*NDd8(kldd8S_wG7*oT)G)-2f&oqADyw+_XAt!dyhWuYP8cy0Io^+FFFse8P%%o^PobqZihYf2DPlehvb>}Raw{PF-&(sa&xzJ$UU39o%x}~zE5!Y;ZFDE&9D@&fL z@5YFt#!@rUTHiH(0g65Q>uj48YCJ3-R%|Yg4cpvex`q{3k4A%!wEE7qIQJ7N(*AK5L6KUHQ zZd&U$2w~O_IeC~cqy(cy6WQ>oFPr*HNdB!5HP)63 z5W|y)u??RFvZ=p<2 zBM=}G0G2_66L$?#Llu@c@Bw}*0si9x|9^aW1M5%0!5P^aDmvKOIbPPcvpe$C>AfjM zK9+t0p4SOH`|OWhf$!e%MZfNCXzO4MwtIqhGA%9&99%NPiHmDCo^Mf zMMfp?eV`}%A@Z0GGGPXVgJcHGB!S|)}+>+)GZ=E&ed%n9zgEfExJps?9$~6T%2C1L|N%+1+dd;3yHCIXxN?W^fr$3;%jL{r;lHfQS&p zHf*3CJ`Gg)`J(Ds!DT>A4Ba=v?BFt>F0QHRBF4oyP^HvFv z3H?K6j}u%5)Wx{oA$+$03E%IFasGU7{JFtpKwZpaw4|T_j7Iy9(U4sMmjQLLz`AXn zDyU34AGi#tixVmWqceb!O#N|cG7EsqfV#Nj)~2%sAmjJPdxLllTn5y|3A9+PM;D6S zKV-6m!DT>QOmflRPY!r*H2-*uwZy<>KwaEotjFgM$ngGg5q&2PE(7Y~f}|e8>wpB( zA7^;HB&ZArsEec7sPklj(Ww0Kq9|p-Wk6l5Y^*n}i3|sa0enjQ{hUgd1D64HG46;) z^;KXb-G5w*FDrw~fV#Lsr`W_6kV*XGfIm_NmjQJ#^lP!S2Dl8Ui%&0U{__k!ya6r) z>f&Dmf#2U^eI0NaP#2$G{P*W*4E4ZeKwW%#sn(w|d-~uqpf3J3j{W^bH5r1+oU9vq zI->YBko{do&KO(<)WyF>vcJnTn1IWGy7<>n_IDX&GjJJD7el}Kl30SvfV%kCVD|UX z>|24$fV%kCX!ds*FI#Y#|3??^IDpH5y7~3If2W7x)^#ud)6IX2GqsS1C!d@ zpfV?m0GxI)^ne!G16&5w#n1!VYEN((P!~fFXfODH%YeEV`bAXHA6y31#n1yeh4lD>SE{tt$Y}`45*8t2eb|0pfV>Mv(qky z9?(ifg3Exq7SE{ttx+tv45*8t2ed13;4+{th91ziCW6a=x)^#uYnB2o z1L|Vv0WD=ZxD2R^p$D`X8Q?OYE`}b^YCi&(0d+C-fOa|uROV!^Q z3_YM-D*%@PbusjS*0dO02GqsSuf^EUz-2&P3_YNIRSqr#>SE{tEqxWZ45*8t2eb^; z;4+{th91y1)Pl=^y7+Y4%)jDd`1|$8GC!MWPFt?xRMW%HU6C7qYk@eucrQmm3=X7D_rw&yIXqiS)78%HZ!@;Qo{~~}?rpfE0 GpZ*V$52*eC literal 0 HcmV?d00001 diff --git a/linkml_runtime/linkml_model/json/datasets.json b/linkml_runtime/linkml_model/json/datasets.json new file mode 100644 index 00000000..e5a8d87e --- /dev/null +++ b/linkml_runtime/linkml_model/json/datasets.json @@ -0,0 +1,1171 @@ +{ + "name": "datasets", + "description": "A datamodel for datasets", + "title": "LinkML Datasets Datamodel", + "see_also": [ + "https://specs.frictionlessdata.io/data-resource", + "https://www.w3.org/TR/void/", + "https://www.w3.org/TR/hcls-dataset/" + ], + "id": "https://w3id.org/linkml/datasets", + "imports": [ + "linkml:types" + ], + "license": "https://creativecommons.org/publicdomain/zero/1.0/", + "prefixes": [ + { + "prefix_prefix": "linkml", + "prefix_reference": "https://w3id.org/linkml/" + }, + { + "prefix_prefix": "datasets", + "prefix_reference": "https://w3id.org/linkml/report" + }, + { + "prefix_prefix": "skos", + "prefix_reference": "http://www.w3.org/2004/02/skos/core#" + }, + { + "prefix_prefix": "pav", + "prefix_reference": "http://purl.org/pav/" + }, + { + "prefix_prefix": "schema", + "prefix_reference": "http://schema.org/" + }, + { + "prefix_prefix": "sh", + "prefix_reference": "https://w3id.org/shacl/" + }, + { + "prefix_prefix": "void", + "prefix_reference": "http://rdfs.org/ns/void#" + }, + { + "prefix_prefix": "frictionless", + "prefix_reference": "https://specs.frictionlessdata.io/" + }, + { + "prefix_prefix": "formats", + "prefix_reference": "http://www.w3.org/ns/formats/" + }, + { + "prefix_prefix": "csvw", + "prefix_reference": "http://www.w3.org/ns/csvw#" + }, + { + "prefix_prefix": "dcat", + "prefix_reference": "http://www.w3.org/ns/dcat#" + }, + { + "prefix_prefix": "mediatypes", + "prefix_reference": "https://www.iana.org/assignments/media-types/" + } + ], + "emit_prefixes": [ + "linkml", + "rdf", + "rdfs", + "xsd", + "owl" + ], + "default_curi_maps": [ + "semweb_context" + ], + "default_prefix": "datasets", + "default_range": "string", + "types": [ + { + "name": "string", + "definition_uri": "https://w3id.org/linkml/String", + "description": "A character string", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "str", + "uri": "http://www.w3.org/2001/XMLSchema#string", + "@type": "TypeDefinition" + }, + { + "name": "integer", + "definition_uri": "https://w3id.org/linkml/Integer", + "description": "An integer", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "int", + "uri": "http://www.w3.org/2001/XMLSchema#integer", + "@type": "TypeDefinition" + }, + { + "name": "boolean", + "definition_uri": "https://w3id.org/linkml/Boolean", + "description": "A binary (true or false) value", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "Bool", + "uri": "http://www.w3.org/2001/XMLSchema#boolean", + "repr": "bool", + "@type": "TypeDefinition" + }, + { + "name": "float", + "definition_uri": "https://w3id.org/linkml/Float", + "description": "A real number that conforms to the xsd:float specification", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "float", + "uri": "http://www.w3.org/2001/XMLSchema#float", + "@type": "TypeDefinition" + }, + { + "name": "double", + "definition_uri": "https://w3id.org/linkml/Double", + "description": "A real number that conforms to the xsd:double specification", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "float", + "uri": "http://www.w3.org/2001/XMLSchema#double", + "@type": "TypeDefinition" + }, + { + "name": "decimal", + "definition_uri": "https://w3id.org/linkml/Decimal", + "description": "A real number with arbitrary precision that conforms to the xsd:decimal specification", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "Decimal", + "uri": "http://www.w3.org/2001/XMLSchema#decimal", + "@type": "TypeDefinition" + }, + { + "name": "time", + "definition_uri": "https://w3id.org/linkml/Time", + "description": "A time object represents a (local) time of day, independent of any particular day", + "notes": [ + "URI is dateTime because OWL reasoners don't work with straight date or time" + ], + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "XSDTime", + "uri": "http://www.w3.org/2001/XMLSchema#dateTime", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "date", + "definition_uri": "https://w3id.org/linkml/Date", + "description": "a date (year, month and day) in an idealized calendar", + "notes": [ + "URI is dateTime because OWL reasoners don't work with straight date or time" + ], + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "XSDDate", + "uri": "http://www.w3.org/2001/XMLSchema#date", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "datetime", + "definition_uri": "https://w3id.org/linkml/Datetime", + "description": "The combination of a date and time", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "XSDDateTime", + "uri": "http://www.w3.org/2001/XMLSchema#dateTime", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "date_or_datetime", + "definition_uri": "https://w3id.org/linkml/DateOrDatetime", + "description": "Either a date or a datetime", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "str", + "uri": "https://w3id.org/linkml/DateOrDatetime", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "uriorcurie", + "definition_uri": "https://w3id.org/linkml/Uriorcurie", + "description": "a URI or a CURIE", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "URIorCURIE", + "uri": "http://www.w3.org/2001/XMLSchema#anyURI", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "uri", + "definition_uri": "https://w3id.org/linkml/Uri", + "description": "a complete URI", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "URI", + "uri": "http://www.w3.org/2001/XMLSchema#anyURI", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "ncname", + "definition_uri": "https://w3id.org/linkml/Ncname", + "description": "Prefix part of CURIE", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "NCName", + "uri": "http://www.w3.org/2001/XMLSchema#string", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "objectidentifier", + "definition_uri": "https://w3id.org/linkml/Objectidentifier", + "description": "A URI or CURIE that represents an object in the model.", + "comments": [ + "Used for inheritence and type checking" + ], + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "ElementIdentifier", + "uri": "http://www.w3.org/ns/shex#iri", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "nodeidentifier", + "definition_uri": "https://w3id.org/linkml/Nodeidentifier", + "description": "A URI, CURIE or BNODE that represents a node in a model.", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "NodeIdentifier", + "uri": "http://www.w3.org/ns/shex#nonLiteral", + "repr": "str", + "@type": "TypeDefinition" + } + ], + "enums": [ + { + "name": "TestRole", + "definition_uri": "https://w3id.org/linkml/reportTestRole", + "from_schema": "https://w3id.org/linkml/datasets", + "permissible_values": [ + { + "text": "Example" + }, + { + "text": "CounterExample" + } + ] + }, + { + "name": "MediaTypeEnum", + "definition_uri": "https://w3id.org/linkml/reportMediaTypeEnum", + "from_schema": "https://w3id.org/linkml/datasets", + "exact_mappings": [ + "dcterms:MediaType" + ], + "permissible_values": [ + { + "text": "csv", + "meaning": "mediatypes:text/csv" + }, + { + "text": "rdf-xml", + "meaning": "mediatypes:application/rdf+xml" + } + ] + }, + { + "name": "FormatEnum", + "definition_uri": "https://w3id.org/linkml/reportFormatEnum", + "from_schema": "https://w3id.org/linkml/datasets", + "permissible_values": [ + { + "text": "JSON-LD", + "meaning": "formats:JSON-LD" + }, + { + "text": "N3", + "meaning": "formats:N3" + }, + { + "text": "N-Triples", + "meaning": "formats:N-Triples" + }, + { + "text": "N-Quads", + "meaning": "formats:N-Quads" + }, + { + "text": "LD Patch", + "meaning": "formats:LD_Patch" + }, + { + "text": "Microdata", + "meaning": "formats:microdata" + }, + { + "text": "OWL XML Serialization", + "meaning": "formats:OWL_XML" + }, + { + "text": "OWL Functional Syntax", + "meaning": "formats:OWL_Functional" + }, + { + "text": "OWL Manchester Syntax", + "meaning": "formats:OWL_Manchester" + }, + { + "text": "POWDER", + "meaning": "formats:POWDER" + }, + { + "text": "POWDER-S", + "meaning": "formats:POWDER-S" + }, + { + "text": "PROV-N", + "meaning": "formats:PROV-N" + }, + { + "text": "PROV-XML", + "meaning": "formats:PROV-XML" + }, + { + "text": "RDFa", + "meaning": "formats:RDFa" + }, + { + "text": "RDF/JSON", + "meaning": "formats:RDF_JSON" + }, + { + "text": "RDF/XML", + "meaning": "formats:RDF_XML" + }, + { + "text": "RIF XML Syntax", + "meaning": "formats:RIF_XML" + }, + { + "text": "SPARQL Results in XML", + "meaning": "formats:SPARQL_Results_XML" + }, + { + "text": "SPARQL Results in JSON", + "meaning": "formats:SPARQL_Results_JSON" + }, + { + "text": "SPARQL Results in CSV", + "meaning": "formats:SPARQL_Results_CSV" + }, + { + "text": "SPARQL Results in TSV", + "meaning": "formats:SPARQL_Results_TSV" + }, + { + "text": "Turtle", + "meaning": "formats:Turtle" + }, + { + "text": "TriG", + "meaning": "formats:TriG" + }, + { + "text": "YAML" + }, + { + "text": "JSON" + } + ] + } + ], + "slots": [ + { + "name": "id", + "definition_uri": "https://w3id.org/linkml/reportid", + "description": "the unique name of th dataset", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/dc/terms/identifier" + ], + "exact_mappings": [ + "http://schema.org/name" + ], + "slot_uri": "http://purl.org/dc/terms/identifier", + "identifier": true, + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "string", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "title", + "definition_uri": "https://w3id.org/linkml/reporttitle", + "description": "the official title of the element", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/dc/terms/title" + ], + "slot_uri": "http://purl.org/dc/terms/title", + "owner": "DataResource", + "domain_of": [ + "Information", + "DataResource" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "description", + "definition_uri": "https://w3id.org/linkml/reportdescription", + "description": "human readable description of the information", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/dc/terms/description" + ], + "slot_uri": "http://purl.org/dc/terms/description", + "owner": "DataResource", + "domain_of": [ + "Information", + "DataResource" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "language", + "definition_uri": "https://w3id.org/linkml/reportlanguage", + "description": "language in which the information is expressed", + "from_schema": "https://w3id.org/linkml/datasets", + "slot_uri": "https://w3id.org/linkml/reportlanguage", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "publisher", + "definition_uri": "https://w3id.org/linkml/reportpublisher", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/dc/terms/publisher" + ], + "slot_uri": "http://purl.org/dc/terms/publisher", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "issued", + "definition_uri": "https://w3id.org/linkml/reportissued", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/dc/terms/issued" + ], + "slot_uri": "http://purl.org/dc/terms/issued", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "datetime", + "@type": "SlotDefinition" + }, + { + "name": "page", + "definition_uri": "https://w3id.org/linkml/reportpage", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://www.w3.org/ns/dcat#landingPage" + ], + "slot_uri": "http://www.w3.org/ns/dcat#landingPage", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "dialect", + "definition_uri": "https://w3id.org/linkml/reportdialect", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://www.w3.org/ns/csvw#dialect" + ], + "slot_uri": "http://www.w3.org/ns/csvw#dialect", + "owner": "DataResource", + "domain_of": [ + "DataResource" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "bytes", + "definition_uri": "https://w3id.org/linkml/reportbytes", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://www.w3.org/ns/dcat#byteSize" + ], + "slot_uri": "http://www.w3.org/ns/dcat#byteSize", + "owner": "DataResource", + "domain_of": [ + "DataResource" + ], + "range": "integer", + "@type": "SlotDefinition" + }, + { + "name": "path", + "definition_uri": "https://w3id.org/linkml/reportpath", + "from_schema": "https://w3id.org/linkml/datasets", + "close_mappings": [ + "https://specs.frictionlessdata.io/path" + ], + "slot_uri": "https://w3id.org/linkml/reportpath", + "owner": "DataResource", + "domain_of": [ + "DataResource" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "download_url", + "definition_uri": "https://w3id.org/linkml/reportdownload_url", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://www.w3.org/ns/dcat#downloadURL" + ], + "exact_mappings": [ + "http://schema.org/url" + ], + "close_mappings": [ + "https://specs.frictionlessdata.io/path" + ], + "slot_uri": "http://www.w3.org/ns/dcat#downloadURL", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "uri", + "@type": "SlotDefinition" + }, + { + "name": "format", + "definition_uri": "https://w3id.org/linkml/reportformat", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/dc/terms/format" + ], + "slot_uri": "http://purl.org/dc/terms/format", + "owner": "DataResource", + "domain_of": [ + "DataResource" + ], + "range": "FormatEnum", + "@type": "SlotDefinition" + }, + { + "name": "compression", + "definition_uri": "https://w3id.org/linkml/reportcompression", + "from_schema": "https://w3id.org/linkml/datasets", + "slot_uri": "https://w3id.org/linkml/reportcompression", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "encoding", + "definition_uri": "https://w3id.org/linkml/reportencoding", + "from_schema": "https://w3id.org/linkml/datasets", + "slot_uri": "https://w3id.org/linkml/reportencoding", + "owner": "DataResource", + "domain_of": [ + "DataResource" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "hash", + "definition_uri": "https://w3id.org/linkml/reporthash", + "notes": [ + "we recommend using a more specific slot such as sha256 or md5" + ], + "from_schema": "https://w3id.org/linkml/datasets", + "slot_uri": "https://w3id.org/linkml/reporthash", + "owner": "DataResource", + "domain_of": [ + "DataResource" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "sha256", + "definition_uri": "https://w3id.org/linkml/reportsha256", + "from_schema": "https://w3id.org/linkml/datasets", + "is_a": "hash", + "slot_uri": "https://w3id.org/linkml/reportsha256", + "owner": "DataResource", + "domain_of": [ + "DataResource" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "md5", + "definition_uri": "https://w3id.org/linkml/reportmd5", + "from_schema": "https://w3id.org/linkml/datasets", + "is_a": "hash", + "slot_uri": "https://w3id.org/linkml/reportmd5", + "owner": "DataResource", + "domain_of": [ + "DataResource" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "media_type", + "definition_uri": "https://w3id.org/linkml/reportmedia_type", + "examples": [ + { + "value": "text/csv", + "@type": "Example" + }, + { + "value": "application/json", + "@type": "Example" + } + ], + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://www.w3.org/ns/dcat#mediaType" + ], + "exact_mappings": [ + "https://specs.frictionlessdata.io/mediatype", + "http://schema.org/encodingFormat" + ], + "slot_uri": "http://www.w3.org/ns/dcat#mediaType", + "owner": "DataResource", + "domain_of": [ + "DataResource" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "conforms_to", + "definition_uri": "https://w3id.org/linkml/reportconforms_to", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/dc/terms/conformsTo" + ], + "slot_uri": "http://purl.org/dc/terms/conformsTo", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "conforms_to_schema", + "definition_uri": "https://w3id.org/linkml/reportconforms_to_schema", + "from_schema": "https://w3id.org/linkml/datasets", + "exact_mappings": [ + "https://specs.frictionlessdata.io/schema" + ], + "is_a": "conforms_to", + "slot_uri": "https://w3id.org/linkml/reportconforms_to_schema", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "conforms_to_class", + "definition_uri": "https://w3id.org/linkml/reportconforms_to_class", + "description": "class in schema which the data object instantiates", + "from_schema": "https://w3id.org/linkml/datasets", + "is_a": "conforms_to", + "slot_uri": "https://w3id.org/linkml/reportconforms_to_class", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "profile", + "definition_uri": "https://w3id.org/linkml/reportprofile", + "from_schema": "https://w3id.org/linkml/datasets", + "exact_mappings": [ + "https://specs.frictionlessdata.io/profiles" + ], + "slot_uri": "https://w3id.org/linkml/reportprofile", + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "keywords", + "definition_uri": "https://w3id.org/linkml/reportkeywords", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://www.w3.org/ns/dcat#keyword" + ], + "exact_mappings": [ + "http://schema.org/keywords" + ], + "singular_name": "keyword", + "slot_uri": "http://www.w3.org/ns/dcat#keyword", + "multivalued": true, + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "themes", + "definition_uri": "https://w3id.org/linkml/reportthemes", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://www.w3.org/ns/dcat#theme" + ], + "singular_name": "theme", + "slot_uri": "http://www.w3.org/ns/dcat#theme", + "multivalued": true, + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "resources", + "definition_uri": "https://w3id.org/linkml/reportresources", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://www.w3.org/ns/dcat#distribution" + ], + "exact_mappings": [ + "http://schema.org/distribution" + ], + "slot_uri": "http://www.w3.org/ns/dcat#distribution", + "multivalued": true, + "owner": "DataPackage", + "domain_of": [ + "DataPackage" + ], + "range": "DataResource", + "@type": "SlotDefinition" + }, + { + "name": "test_roles", + "definition_uri": "https://w3id.org/linkml/reporttest_roles", + "from_schema": "https://w3id.org/linkml/datasets", + "slot_uri": "https://w3id.org/linkml/reporttest_roles", + "multivalued": true, + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "TestRole", + "@type": "SlotDefinition" + }, + { + "name": "created_by", + "definition_uri": "https://w3id.org/linkml/reportcreated_by", + "description": "agent that created the element", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/pav/createdBy" + ], + "slot_uri": "http://purl.org/pav/createdBy", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "created_on", + "definition_uri": "https://w3id.org/linkml/reportcreated_on", + "description": "time at which the element was created", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/pav/createdOn" + ], + "slot_uri": "http://purl.org/pav/createdOn", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "datetime", + "@type": "SlotDefinition" + }, + { + "name": "last_updated_on", + "definition_uri": "https://w3id.org/linkml/reportlast_updated_on", + "description": "time at which the element was last updated", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/pav/lastUpdatedOn" + ], + "slot_uri": "http://purl.org/pav/lastUpdatedOn", + "range": "datetime", + "@type": "SlotDefinition" + }, + { + "name": "modified_by", + "definition_uri": "https://w3id.org/linkml/reportmodified_by", + "description": "agent that modified the element", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://example.org/UNKNOWN/oslc/modifiedBy" + ], + "slot_uri": "http://example.org/UNKNOWN/oslc/modifiedBy", + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "status", + "definition_uri": "https://w3id.org/linkml/reportstatus", + "description": "status of the element", + "examples": [ + { + "value": "bibo:draft", + "@type": "Example" + } + ], + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://example.org/UNKNOWN/bibo/status" + ], + "slot_uri": "http://example.org/UNKNOWN/bibo/status", + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "license", + "definition_uri": "https://w3id.org/linkml/reportlicense", + "description": "license for the data", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/dc/terms/license" + ], + "exact_mappings": [ + "https://specs.frictionlessdata.io/licenses" + ], + "slot_uri": "http://purl.org/dc/terms/license", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "version", + "definition_uri": "https://w3id.org/linkml/reportversion", + "description": "particular version of schema", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://purl.org/pav/version" + ], + "exact_mappings": [ + "http://schema.org/version", + "http://purl.org/dc/terms/hasVersion" + ], + "slot_uri": "http://purl.org/pav/version", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "was_derived_from", + "definition_uri": "https://w3id.org/linkml/reportwas_derived_from", + "description": "A derivation is a transformation of an entity into another, an update of an entity resulting in a new one, or the construction of a new entity based on a pre-existing entity.@en", + "from_schema": "https://w3id.org/linkml/datasets", + "mappings": [ + "http://www.w3.org/ns/prov#wasDerivedFrom" + ], + "slot_uri": "http://www.w3.org/ns/prov#wasDerivedFrom", + "owner": "Information", + "domain_of": [ + "Information" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "formatDialect__comment_prefix", + "from_schema": "https://w3id.org/linkml/datasets", + "slot_uri": "https://w3id.org/linkml/reportcomment_prefix", + "alias": "comment_prefix", + "owner": "FormatDialect", + "domain_of": [ + "FormatDialect" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "formatDialect__delimiter", + "from_schema": "https://w3id.org/linkml/datasets", + "slot_uri": "https://w3id.org/linkml/reportdelimiter", + "alias": "delimiter", + "owner": "FormatDialect", + "domain_of": [ + "FormatDialect" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "formatDialect__double_quote", + "from_schema": "https://w3id.org/linkml/datasets", + "slot_uri": "https://w3id.org/linkml/reportdouble_quote", + "alias": "double_quote", + "owner": "FormatDialect", + "domain_of": [ + "FormatDialect" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "formatDialect__header", + "from_schema": "https://w3id.org/linkml/datasets", + "slot_uri": "https://w3id.org/linkml/reportheader", + "alias": "header", + "owner": "FormatDialect", + "domain_of": [ + "FormatDialect" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "formatDialect__quote_char", + "from_schema": "https://w3id.org/linkml/datasets", + "slot_uri": "https://w3id.org/linkml/reportquote_char", + "alias": "quote_char", + "owner": "FormatDialect", + "domain_of": [ + "FormatDialect" + ], + "range": "string", + "@type": "SlotDefinition" + } + ], + "classes": [ + { + "name": "Information", + "definition_uri": "https://w3id.org/linkml/reportInformation", + "description": "Grouping for datasets and data files", + "from_schema": "https://w3id.org/linkml/datasets", + "close_mappings": [ + "schema:CreativeWork" + ], + "abstract": true, + "slots": [ + "id", + "download_url", + "license", + "title", + "description", + "conforms_to", + "conforms_to_schema", + "conforms_to_class", + "version", + "language", + "publisher", + "keywords", + "issued", + "created_by", + "created_on", + "compression", + "was_derived_from", + "page", + "test_roles" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/reportInformation", + "@type": "ClassDefinition" + }, + { + "name": "DataPackage", + "definition_uri": "https://w3id.org/linkml/reportDataPackage", + "description": "A collection of data resources", + "from_schema": "https://w3id.org/linkml/datasets", + "see_also": [ + "https://specs.frictionlessdata.io/data-package" + ], + "aliases": [ + "dataset", + "file collection", + "data resource collection" + ], + "mappings": [ + "void:Dataset" + ], + "exact_mappings": [ + "dcat:Dataset" + ], + "close_mappings": [ + "dcat:Catalog" + ], + "is_a": "Information", + "slots": [ + "id", + "download_url", + "license", + "title", + "description", + "conforms_to", + "conforms_to_schema", + "conforms_to_class", + "version", + "language", + "publisher", + "keywords", + "issued", + "created_by", + "created_on", + "compression", + "was_derived_from", + "page", + "test_roles", + "resources" + ], + "slot_usage": {}, + "class_uri": "http://rdfs.org/ns/void#Dataset", + "@type": "ClassDefinition" + }, + { + "name": "DataResource", + "definition_uri": "https://w3id.org/linkml/reportDataResource", + "description": "An individual file or table", + "from_schema": "https://w3id.org/linkml/datasets", + "see_also": [ + "https://specs.frictionlessdata.io/data-resource" + ], + "mappings": [ + "dcat:Distribution" + ], + "exact_mappings": [ + "schema:DataDownload" + ], + "is_a": "Information", + "slots": [ + "id", + "download_url", + "license", + "conforms_to", + "conforms_to_schema", + "conforms_to_class", + "version", + "language", + "publisher", + "keywords", + "issued", + "created_by", + "created_on", + "compression", + "was_derived_from", + "page", + "test_roles", + "path", + "title", + "description", + "format", + "media_type", + "encoding", + "bytes", + "hash", + "md5", + "sha256", + "dialect" + ], + "slot_usage": {}, + "class_uri": "http://www.w3.org/ns/dcat#Distribution", + "@type": "ClassDefinition" + }, + { + "name": "FormatDialect", + "definition_uri": "https://w3id.org/linkml/reportFormatDialect", + "description": "Additional format information for a file", + "from_schema": "https://w3id.org/linkml/datasets", + "slots": [ + "formatDialect__comment_prefix", + "formatDialect__delimiter", + "formatDialect__double_quote", + "formatDialect__header", + "formatDialect__quote_char" + ], + "slot_usage": {}, + "attributes": [ + { + "name": "comment_prefix", + "@type": "SlotDefinition" + }, + { + "name": "delimiter", + "@type": "SlotDefinition" + }, + { + "name": "double_quote", + "@type": "SlotDefinition" + }, + { + "name": "header", + "@type": "SlotDefinition" + }, + { + "name": "quote_char", + "@type": "SlotDefinition" + } + ], + "class_uri": "https://w3id.org/linkml/reportFormatDialect", + "@type": "ClassDefinition" + } + ], + "metamodel_version": "1.7.0", + "source_file": "datasets.yaml", + "source_file_date": "2022-07-14T00:55:10", + "source_file_size": 7804, + "generation_date": "2022-07-14T00:56:05", + "@type": "SchemaDefinition", + "@context": [ + "https://w3id.org/linkml/types.context.jsonld", + { + "@base": "https://w3id.org/linkml/report" + } + ] +} + diff --git a/linkml_runtime/linkml_model/json/meta.json b/linkml_runtime/linkml_model/json/meta.json index a82df6ce..506ececa 100644 --- a/linkml_runtime/linkml_model/json/meta.json +++ b/linkml_runtime/linkml_model/json/meta.json @@ -6861,9 +6861,9 @@ ], "metamodel_version": "1.7.0", "source_file": "meta.yaml", - "source_file_date": "2022-07-13T17:52:28", + "source_file_date": "2022-07-14T00:55:10", "source_file_size": 71464, - "generation_date": "2022-07-13T17:56:42", + "generation_date": "2022-07-14T00:56:03", "@type": "SchemaDefinition", "@context": [ "https://w3id.org/linkml/types.context.jsonld", diff --git a/linkml_runtime/linkml_model/jsonld/datasets.context.jsonld b/linkml_runtime/linkml_model/jsonld/datasets.context.jsonld new file mode 100644 index 00000000..262f0574 --- /dev/null +++ b/linkml_runtime/linkml_model/jsonld/datasets.context.jsonld @@ -0,0 +1,138 @@ +{ + "_comments": "Auto generated from datasets.yaml by jsonldcontextgen.py version: 0.1.1\n Generation date: 2022-07-14T00:56:17\n Schema: datasets\n metamodel version: 1.7.0\n model version: None\n \n id: https://w3id.org/linkml/datasets\n description: A datamodel for datasets\n license: https://creativecommons.org/publicdomain/zero/1.0/\n ", + "@context": { + "bibo": "http://example.org/UNKNOWN/bibo/", + "csvw": "http://www.w3.org/ns/csvw#", + "datasets": { + "@id": "https://w3id.org/linkml/report", + "@prefix": true + }, + "dcat": "http://www.w3.org/ns/dcat#", + "dcterms": "http://purl.org/dc/terms/", + "formats": "http://www.w3.org/ns/formats/", + "frictionless": "https://specs.frictionlessdata.io/", + "linkml": "https://w3id.org/linkml/", + "mediatypes": "https://www.iana.org/assignments/media-types/", + "oslc": "http://example.org/UNKNOWN/oslc/", + "owl": "http://www.w3.org/2002/07/owl#", + "pav": "http://purl.org/pav/", + "prov": "http://www.w3.org/ns/prov#", + "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#", + "rdfs": "http://www.w3.org/2000/01/rdf-schema#", + "schema": "http://schema.org/", + "sh": "https://w3id.org/shacl/", + "skos": "http://www.w3.org/2004/02/skos/core#", + "void": "http://rdfs.org/ns/void#", + "xsd": "http://www.w3.org/2001/XMLSchema#", + "@vocab": "https://w3id.org/linkml/report", + "bytes": { + "@type": "xsd:integer", + "@id": "dcat:byteSize" + }, + "conforms_to": { + "@type": "@id", + "@id": "dcterms:conformsTo" + }, + "conforms_to_class": { + "@type": "@id" + }, + "conforms_to_schema": { + "@type": "@id" + }, + "created_by": { + "@type": "@id", + "@id": "pav:createdBy" + }, + "created_on": { + "@type": "xsd:dateTime", + "@id": "pav:createdOn" + }, + "description": { + "@id": "dcterms:description" + }, + "dialect": { + "@id": "csvw:dialect" + }, + "download_url": { + "@type": "@id", + "@id": "dcat:downloadURL" + }, + "format": { + "@context": { + "@vocab": "@null", + "text": "skos:notation", + "description": "skos:prefLabel", + "meaning": "@id" + }, + "@id": "dcterms:format" + }, + "id": "@id", + "issued": { + "@type": "xsd:dateTime", + "@id": "dcterms:issued" + }, + "keywords": { + "@id": "dcat:keyword" + }, + "last_updated_on": { + "@type": "xsd:dateTime", + "@id": "pav:lastUpdatedOn" + }, + "license": { + "@id": "dcterms:license" + }, + "media_type": { + "@id": "dcat:mediaType" + }, + "modified_by": { + "@type": "@id", + "@id": "oslc:modifiedBy" + }, + "page": { + "@id": "dcat:landingPage" + }, + "profile": { + "@type": "@id" + }, + "publisher": { + "@type": "@id", + "@id": "dcterms:publisher" + }, + "resources": { + "@type": "@id", + "@id": "dcat:distribution" + }, + "status": { + "@type": "@id", + "@id": "bibo:status" + }, + "test_roles": { + "@context": { + "@vocab": "@null", + "text": "skos:notation", + "description": "skos:prefLabel", + "meaning": "@id" + } + }, + "themes": { + "@type": "@id", + "@id": "dcat:theme" + }, + "title": { + "@id": "dcterms:title" + }, + "version": { + "@id": "pav:version" + }, + "was_derived_from": { + "@id": "prov:wasDerivedFrom" + }, + "DataPackage": { + "@id": "void:Dataset" + }, + "DataResource": { + "@id": "dcat:Distribution" + } + } +} + diff --git a/linkml_runtime/linkml_model/jsonld/datasets.model.context.jsonld b/linkml_runtime/linkml_model/jsonld/datasets.model.context.jsonld new file mode 100644 index 00000000..b332709d --- /dev/null +++ b/linkml_runtime/linkml_model/jsonld/datasets.model.context.jsonld @@ -0,0 +1,138 @@ +{ + "_comments": "Auto generated from datasets.yaml by jsonldcontextgen.py version: 0.1.1\n Generation date: 2022-07-14T00:56:28\n Schema: datasets\n metamodel version: 1.7.0\n model version: None\n \n id: https://w3id.org/linkml/datasets\n description: A datamodel for datasets\n license: https://creativecommons.org/publicdomain/zero/1.0/\n ", + "@context": { + "bibo": "http://example.org/UNKNOWN/bibo/", + "csvw": "http://www.w3.org/ns/csvw#", + "datasets": { + "@id": "https://w3id.org/linkml/report", + "@prefix": true + }, + "dcat": "http://www.w3.org/ns/dcat#", + "dcterms": "http://purl.org/dc/terms/", + "formats": "http://www.w3.org/ns/formats/", + "frictionless": "https://specs.frictionlessdata.io/", + "linkml": "https://w3id.org/linkml/", + "mediatypes": "https://www.iana.org/assignments/media-types/", + "oslc": "http://example.org/UNKNOWN/oslc/", + "owl": "http://www.w3.org/2002/07/owl#", + "pav": "http://purl.org/pav/", + "prov": "http://www.w3.org/ns/prov#", + "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#", + "rdfs": "http://www.w3.org/2000/01/rdf-schema#", + "schema": "http://schema.org/", + "sh": "https://w3id.org/shacl/", + "skos": "http://www.w3.org/2004/02/skos/core#", + "void": "http://rdfs.org/ns/void#", + "xsd": "http://www.w3.org/2001/XMLSchema#", + "@vocab": "https://w3id.org/linkml/report", + "bytes": { + "@type": "xsd:integer", + "@id": "dcat:byteSize" + }, + "conforms_to": { + "@type": "@id", + "@id": "dcterms:conformsTo" + }, + "conforms_to_class": { + "@type": "@id" + }, + "conforms_to_schema": { + "@type": "@id" + }, + "created_by": { + "@type": "@id", + "@id": "pav:createdBy" + }, + "created_on": { + "@type": "xsd:dateTime", + "@id": "pav:createdOn" + }, + "description": { + "@id": "dcterms:description" + }, + "dialect": { + "@id": "csvw:dialect" + }, + "download_url": { + "@type": "@id", + "@id": "dcat:downloadURL" + }, + "format": { + "@context": { + "@vocab": "@null", + "text": "skos:notation", + "description": "skos:prefLabel", + "meaning": "@id" + }, + "@id": "dcterms:format" + }, + "id": "@id", + "issued": { + "@type": "xsd:dateTime", + "@id": "dcterms:issued" + }, + "keywords": { + "@id": "dcat:keyword" + }, + "last_updated_on": { + "@type": "xsd:dateTime", + "@id": "pav:lastUpdatedOn" + }, + "license": { + "@id": "dcterms:license" + }, + "media_type": { + "@id": "dcat:mediaType" + }, + "modified_by": { + "@type": "@id", + "@id": "oslc:modifiedBy" + }, + "page": { + "@id": "dcat:landingPage" + }, + "profile": { + "@type": "@id" + }, + "publisher": { + "@type": "@id", + "@id": "dcterms:publisher" + }, + "resources": { + "@type": "@id", + "@id": "dcat:distribution" + }, + "status": { + "@type": "@id", + "@id": "bibo:status" + }, + "test_roles": { + "@context": { + "@vocab": "@null", + "text": "skos:notation", + "description": "skos:prefLabel", + "meaning": "@id" + } + }, + "themes": { + "@type": "@id", + "@id": "dcat:theme" + }, + "title": { + "@id": "dcterms:title" + }, + "version": { + "@id": "pav:version" + }, + "was_derived_from": { + "@id": "prov:wasDerivedFrom" + }, + "DataPackage": { + "@id": "void:Dataset" + }, + "DataResource": { + "@id": "dcat:Distribution" + } + } +} + diff --git a/linkml_runtime/linkml_model/jsonld/meta.context.jsonld b/linkml_runtime/linkml_model/jsonld/meta.context.jsonld index b3da9a94..3a67944d 100644 --- a/linkml_runtime/linkml_model/jsonld/meta.context.jsonld +++ b/linkml_runtime/linkml_model/jsonld/meta.context.jsonld @@ -1,5 +1,5 @@ { - "_comments": "Auto generated from meta.yaml by jsonldcontextgen.py version: 0.1.1\n Generation date: 2022-12-09T13:58:21\n Schema: meta\n metamodel version: 1.7.0\n model version: 2.0.0\n \n id: https://w3id.org/linkml/meta\n description: The metamodel for schemas defined using the Linked Data Modeling Language framework.\n\nFor more information on LinkML:\n\n* [linkml.io](https://linkml.io) main website\n* [specification](https://linkml.io/linkml-model/docs/specification/)\n\nLinkML is self-describing. Every LinkML schema consists of elements\nthat instantiate classes in this metamodel.\n\nCore metaclasses:\n\n* [SchemaDefinition](https://w3id.org/linkml/SchemaDefinition)\n* [ClassDefinition](https://w3id.org/linkml/ClassDefinition)\n* [SlotDefinition](https://w3id.org/linkml/SlotDefinition)\n* [TypeDefinition](https://w3id.org/linkml/TypeDefinition)\n\nThere are many subsets of *profiles* of the metamodel, for different purposes:\n\n* [MinimalSubset](https://w3id.org/linkml/MinimalSubset)\n* [BasicSubset](https://w3id.org/linkml/BasicSubset)\n* [BasicSubset](https://w3id.org/linkml/BasicSubset)\n\nFor canonical reference documentation on any metamodel construct,\nrefer to the official URI for each construct, e.g.\n[https://w3id.org/linkml/is_a](https://w3id.org/linkml/is_a)\n license: https://creativecommons.org/publicdomain/zero/1.0/\n ", + "_comments": "Auto generated from meta.yaml by jsonldcontextgen.py version: 0.1.1\n Generation date: 2022-12-09T14:56:37\n Schema: meta\n metamodel version: 1.7.0\n model version: 2.0.0\n \n id: https://w3id.org/linkml/meta\n description: The metamodel for schemas defined using the Linked Data Modeling Language framework.\n\nFor more information on LinkML:\n\n* [linkml.io](https://linkml.io) main website\n* [specification](https://linkml.io/linkml-model/docs/specification/)\n\nLinkML is self-describing. Every LinkML schema consists of elements\nthat instantiate classes in this metamodel.\n\nCore metaclasses:\n\n* [SchemaDefinition](https://w3id.org/linkml/SchemaDefinition)\n* [ClassDefinition](https://w3id.org/linkml/ClassDefinition)\n* [SlotDefinition](https://w3id.org/linkml/SlotDefinition)\n* [TypeDefinition](https://w3id.org/linkml/TypeDefinition)\n\nThere are many subsets of *profiles* of the metamodel, for different purposes:\n\n* [MinimalSubset](https://w3id.org/linkml/MinimalSubset)\n* [BasicSubset](https://w3id.org/linkml/BasicSubset)\n* [BasicSubset](https://w3id.org/linkml/BasicSubset)\n\nFor canonical reference documentation on any metamodel construct,\nrefer to the official URI for each construct, e.g.\n[https://w3id.org/linkml/is_a](https://w3id.org/linkml/is_a)\n license: https://creativecommons.org/publicdomain/zero/1.0/\n ", "@context": { "IAO": { "@id": "http://purl.obolibrary.org/obo/IAO_", diff --git a/linkml_runtime/linkml_model/jsonld/meta.jsonld b/linkml_runtime/linkml_model/jsonld/meta.jsonld new file mode 100644 index 00000000..eb6b1181 --- /dev/null +++ b/linkml_runtime/linkml_model/jsonld/meta.jsonld @@ -0,0 +1,7379 @@ +{ + "name": "meta", + "description": "The metamodel for schemas defined using the Linked Data Modeling Language framework.\n\nFor more information on LinkML:\n\n* [linkml.io](https://linkml.io) main website\n* [specification](https://linkml.io/linkml-model/docs/specification/)\n\nLinkML is self-describing. Every LinkML schema consists of elements\nthat instantiate classes in this metamodel.\n\nCore metaclasses:\n\n* [SchemaDefinition](https://w3id.org/linkml/SchemaDefinition)\n* [ClassDefinition](https://w3id.org/linkml/ClassDefinition)\n* [SlotDefinition](https://w3id.org/linkml/SlotDefinition)\n* [TypeDefinition](https://w3id.org/linkml/TypeDefinition)\n\nThere are many subsets of *profiles* of the metamodel, for different purposes:\n\n* [MinimalSubset](https://w3id.org/linkml/MinimalSubset)\n* [BasicSubset](https://w3id.org/linkml/BasicSubset)\n* [BasicSubset](https://w3id.org/linkml/BasicSubset)\n\nFor canonical reference documentation on any metamodel construct,\nrefer to the official URI for each construct, e.g.\n[https://w3id.org/linkml/is_a](https://w3id.org/linkml/is_a)", + "title": "LinkML Schema Metamodel", + "id": "https://w3id.org/linkml/meta", + "version": "2.0.0", + "imports": [ + "linkml:types", + "linkml:mappings", + "linkml:extensions", + "linkml:annotations", + "linkml:units" + ], + "license": "https://creativecommons.org/publicdomain/zero/1.0/", + "prefixes": [ + { + "prefix_prefix": "linkml", + "prefix_reference": "https://w3id.org/linkml/" + }, + { + "prefix_prefix": "skos", + "prefix_reference": "http://www.w3.org/2004/02/skos/core#" + }, + { + "prefix_prefix": "skosxl", + "prefix_reference": "http://www.w3.org/2008/05/skos-xl#" + }, + { + "prefix_prefix": "OIO", + "prefix_reference": "http://www.geneontology.org/formats/oboInOwl#" + }, + { + "prefix_prefix": "NCIT", + "prefix_reference": "http://ncicb.nci.nih.gov/xml/owl/EVS/Thesaurus.owl#" + }, + { + "prefix_prefix": "pav", + "prefix_reference": "http://purl.org/pav/" + }, + { + "prefix_prefix": "oslc", + "prefix_reference": "http://open-services.net/ns/core#" + }, + { + "prefix_prefix": "schema", + "prefix_reference": "http://schema.org/" + }, + { + "prefix_prefix": "bibo", + "prefix_reference": "http://purl.org/ontology/bibo/" + }, + { + "prefix_prefix": "swrl", + "prefix_reference": "http://www.w3.org/2003/11/swrl#" + }, + { + "prefix_prefix": "sh", + "prefix_reference": "https://w3id.org/shacl/" + }, + { + "prefix_prefix": "owl", + "prefix_reference": "http://www.w3.org/2002/07/owl#" + }, + { + "prefix_prefix": "qb", + "prefix_reference": "http://purl.org/linked-data/cube#" + }, + { + "prefix_prefix": "prov", + "prefix_reference": "http://www.w3.org/ns/prov#" + }, + { + "prefix_prefix": "vann", + "prefix_reference": "https://vocab.org/vann/" + }, + { + "prefix_prefix": "qudt", + "prefix_reference": "http://qudt.org/schema/qudt/" + } + ], + "emit_prefixes": [ + "linkml", + "rdf", + "rdfs", + "xsd", + "skos", + "dcterms", + "OIO", + "owl", + "pav", + "IAO" + ], + "default_curi_maps": [ + "semweb_context" + ], + "default_prefix": "linkml", + "default_range": "string", + "subsets": [ + { + "name": "MinimalSubset", + "definition_uri": "https://w3id.org/linkml/MinimalSubset", + "description": "The absolute minimal set of elements necessary for defining any schema.\n\nschemas conforming to the minimal subset consist of classes, with all slots\ninlined as attributes. There are no enums.", + "title": "minimal subset", + "from_schema": "https://w3id.org/linkml/meta", + "rank": 0, + "@type": "SubsetDefinition" + }, + { + "name": "BasicSubset", + "definition_uri": "https://w3id.org/linkml/BasicSubset", + "description": "An extension of MinimalSubset that avoids advanced constructs and can be implemented by a broad variety of tools.\n\nThis subset roughly corresponds to the union of most standard constructs used in relational datamodel modeling,\nobject oriented modeling, and simple JSON-style modeling, while avoiding more advanced constructs from these languages.\n\nIt is often possible to translate from a more expressive schema to a BasicSubset schema, through a schema derivation\nprocess", + "title": "basic subset", + "from_schema": "https://w3id.org/linkml/meta", + "rank": 1, + "@type": "SubsetDefinition" + }, + { + "name": "SpecificationSubset", + "definition_uri": "https://w3id.org/linkml/SpecificationSubset", + "description": "A subset that includes all the metamodel elements that form part of the normative LinkML specification.\n\nThe complete LinkML specification can be found at [linkml:specification](https://w3id.org/linkml/specification)", + "title": "specification subset", + "from_schema": "https://w3id.org/linkml/meta", + "rank": 2, + "@type": "SubsetDefinition" + }, + { + "name": "RelationalModelProfile", + "definition_uri": "https://w3id.org/linkml/RelationalModelProfile", + "description": "A profile that includes all the metamodel elements whose semantics can be expressed using the classic Relational Model.\nThe Relational Model excludes collections (multivalued slots) as first class entities. Instead, these must be\nmapped to backreferences\n\nThe classic Relational Model excludes inheritance and polymorphism -- these must be rolled down to\nconcrete classes or otherwise transformed.", + "title": "relational model profile", + "from_schema": "https://w3id.org/linkml/meta", + "rank": 3, + "@type": "SubsetDefinition" + }, + { + "name": "ObjectOrientedProfile", + "definition_uri": "https://w3id.org/linkml/ObjectOrientedProfile", + "description": "A profile that includes all the metamodel elements whose semantics can be expressed using a minimal\nimplementation of the object oriented metamodel as employed by languages such as Java and Python, or\nin modeling frameworks like UML", + "title": "object oriented profile", + "from_schema": "https://w3id.org/linkml/meta", + "rank": 4, + "@type": "SubsetDefinition" + }, + { + "name": "OwlProfile", + "definition_uri": "https://w3id.org/linkml/OwlProfile", + "description": "A profile that includes all the metamodel elements whose semantics can be expressed in OWL", + "title": "owl profile", + "from_schema": "https://w3id.org/linkml/meta", + "@type": "SubsetDefinition" + } + ], + "types": [ + { + "name": "string", + "definition_uri": "https://w3id.org/linkml/String", + "description": "A character string", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "str", + "uri": "http://www.w3.org/2001/XMLSchema#string", + "@type": "TypeDefinition" + }, + { + "name": "integer", + "definition_uri": "https://w3id.org/linkml/Integer", + "description": "An integer", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "int", + "uri": "http://www.w3.org/2001/XMLSchema#integer", + "@type": "TypeDefinition" + }, + { + "name": "boolean", + "definition_uri": "https://w3id.org/linkml/Boolean", + "description": "A binary (true or false) value", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "Bool", + "uri": "http://www.w3.org/2001/XMLSchema#boolean", + "repr": "bool", + "@type": "TypeDefinition" + }, + { + "name": "float", + "definition_uri": "https://w3id.org/linkml/Float", + "description": "A real number that conforms to the xsd:float specification", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "float", + "uri": "http://www.w3.org/2001/XMLSchema#float", + "@type": "TypeDefinition" + }, + { + "name": "double", + "definition_uri": "https://w3id.org/linkml/Double", + "description": "A real number that conforms to the xsd:double specification", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "float", + "uri": "http://www.w3.org/2001/XMLSchema#double", + "@type": "TypeDefinition" + }, + { + "name": "decimal", + "definition_uri": "https://w3id.org/linkml/Decimal", + "description": "A real number with arbitrary precision that conforms to the xsd:decimal specification", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "Decimal", + "uri": "http://www.w3.org/2001/XMLSchema#decimal", + "@type": "TypeDefinition" + }, + { + "name": "time", + "definition_uri": "https://w3id.org/linkml/Time", + "description": "A time object represents a (local) time of day, independent of any particular day", + "notes": [ + "URI is dateTime because OWL reasoners do not work with straight date or time" + ], + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "XSDTime", + "uri": "http://www.w3.org/2001/XMLSchema#dateTime", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "date", + "definition_uri": "https://w3id.org/linkml/Date", + "description": "a date (year, month and day) in an idealized calendar", + "notes": [ + "URI is dateTime because OWL reasoners don't work with straight date or time" + ], + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "XSDDate", + "uri": "http://www.w3.org/2001/XMLSchema#date", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "datetime", + "definition_uri": "https://w3id.org/linkml/Datetime", + "description": "The combination of a date and time", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "XSDDateTime", + "uri": "http://www.w3.org/2001/XMLSchema#dateTime", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "date_or_datetime", + "definition_uri": "https://w3id.org/linkml/DateOrDatetime", + "description": "Either a date or a datetime", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "str", + "uri": "https://w3id.org/linkml/DateOrDatetime", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "uriorcurie", + "definition_uri": "https://w3id.org/linkml/Uriorcurie", + "description": "a URI or a CURIE", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "URIorCURIE", + "uri": "http://www.w3.org/2001/XMLSchema#anyURI", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "uri", + "definition_uri": "https://w3id.org/linkml/Uri", + "description": "a complete URI", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "URI", + "uri": "http://www.w3.org/2001/XMLSchema#anyURI", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "ncname", + "definition_uri": "https://w3id.org/linkml/Ncname", + "description": "Prefix part of CURIE", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "NCName", + "uri": "http://www.w3.org/2001/XMLSchema#string", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "objectidentifier", + "definition_uri": "https://w3id.org/linkml/Objectidentifier", + "description": "A URI or CURIE that represents an object in the model.", + "comments": [ + "Used for inheritence and type checking" + ], + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "ElementIdentifier", + "uri": "http://www.w3.org/ns/shex#iri", + "repr": "str", + "@type": "TypeDefinition" + }, + { + "name": "nodeidentifier", + "definition_uri": "https://w3id.org/linkml/Nodeidentifier", + "description": "A URI, CURIE or BNODE that represents a node in a model.", + "from_schema": "https://w3id.org/linkml/types", + "imported_from": "linkml:types", + "base": "NodeIdentifier", + "uri": "http://www.w3.org/ns/shex#nonLiteral", + "repr": "str", + "@type": "TypeDefinition" + } + ], + "enums": [ + { + "name": "pv_formula_options", + "definition_uri": "https://w3id.org/linkml/PvFormulaOptions", + "description": "The formula used to generate the set of permissible values from the code_set values", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 1, + "permissible_values": [ + { + "text": "CODE", + "description": "The permissible values are the set of possible codes in the code set" + }, + { + "text": "CURIE", + "description": "The permissible values are the set of CURIES in the code set" + }, + { + "text": "URI", + "description": "The permissible values are the set of code URIs in the code set" + }, + { + "text": "FHIR_CODING", + "description": "The permissible values are the set of FHIR coding elements derived from the code set" + } + ] + }, + { + "name": "presence_enum", + "definition_uri": "https://w3id.org/linkml/PresenceEnum", + "description": "enumeration of conditions by which a slot value should be set", + "from_schema": "https://w3id.org/linkml/meta", + "rank": 11, + "permissible_values": [ + { + "text": "UNCOMMITTED" + }, + { + "text": "PRESENT" + }, + { + "text": "ABSENT" + } + ] + }, + { + "name": "relational_role_enum", + "definition_uri": "https://w3id.org/linkml/RelationalRoleEnum", + "description": "enumeration of roles a slot on a relationship class can play", + "from_schema": "https://w3id.org/linkml/meta", + "rank": 3, + "permissible_values": [ + { + "text": "SUBJECT", + "description": "a slot with this role connects a relationship to its subject/source node", + "meaning": "rdf:subject" + }, + { + "text": "OBJECT", + "description": "a slot with this role connects a relationship to its object/target node", + "meaning": "rdf:object" + }, + { + "text": "PREDICATE", + "description": "a slot with this role connects a relationship to its predicate/property", + "meaning": "rdf:predicate" + }, + { + "text": "NODE", + "description": "a slot with this role connects a symmetric relationship to a node that represents either subject or object node" + }, + { + "text": "OTHER_ROLE", + "description": "a slot with this role connects a relationship to a node that is not subject/object/predicate" + } + ] + }, + { + "name": "alias_predicate_enum", + "definition_uri": "https://w3id.org/linkml/AliasPredicateEnum", + "from_schema": "https://w3id.org/linkml/meta", + "rank": 5, + "permissible_values": [ + { + "text": "EXACT_SYNONYM", + "meaning": "skos:exactMatch" + }, + { + "text": "RELATED_SYNONYM", + "meaning": "skos:relatedMatch" + }, + { + "text": "BROAD_SYNONYM", + "meaning": "skos:broaderMatch" + }, + { + "text": "NARROW_SYNONYM", + "meaning": "skos:narrowerMatch" + } + ] + } + ], + "slots": [ + { + "name": "name", + "definition_uri": "https://w3id.org/linkml/name", + "description": "the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class.", + "in_subset": [ + "SpecificationSubset", + "OwlProfile", + "MinimalSubset", + "BasicSubset", + "RelationalModelProfile", + "ObjectOrientedProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Data_element_name" + ], + "aliases": [ + "short name", + "unique name" + ], + "mappings": [ + "http://www.w3.org/2000/01/rdf-schema#label" + ], + "exact_mappings": [ + "http://schema.org/name" + ], + "rank": 1, + "domain": "Element", + "slot_uri": "http://www.w3.org/2000/01/rdf-schema#label", + "identifier": true, + "owner": "Element", + "domain_of": [ + "Element" + ], + "range": "string", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "title", + "definition_uri": "https://w3id.org/linkml/title", + "description": "the official title of the element", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "long name" + ], + "mappings": [ + "http://purl.org/dc/terms/title" + ], + "rank": 3, + "domain": "Element", + "slot_uri": "http://purl.org/dc/terms/title", + "owner": "title", + "domain_of": [ + "CommonMetadata" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "conforms_to", + "definition_uri": "https://w3id.org/linkml/conforms_to", + "description": "An established standard to which the element conforms.", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://purl.org/dc/terms/conformsTo" + ], + "domain": "Element", + "slot_uri": "http://purl.org/dc/terms/conformsTo", + "owner": "Element", + "domain_of": [ + "Element" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "categories", + "definition_uri": "https://w3id.org/linkml/categories", + "description": "controlled terms used to categorize an element", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://purl.org/dc/terms/subject" + ], + "singular_name": "category", + "slot_uri": "http://purl.org/dc/terms/subject", + "multivalued": true, + "owner": "StructuredAlias", + "domain_of": [ + "SchemaDefinition", + "StructuredAlias" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "keywords", + "definition_uri": "https://w3id.org/linkml/keywords", + "description": "Keywords or tags used to describe the element", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://schema.org/keywords" + ], + "singular_name": "keyword", + "domain": "Element", + "slot_uri": "http://schema.org/keywords", + "multivalued": true, + "owner": "keywords", + "domain_of": [ + "SchemaDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "definition_uri", + "definition_uri": "https://w3id.org/linkml/definition_uri", + "description": "the \"native\" URI of the element", + "comments": [ + "Formed by combining the default_prefix with the mangled element" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Element", + "slot_uri": "https://w3id.org/linkml/definition_uri", + "readonly": "filled in by the schema loader", + "owner": "Element", + "domain_of": [ + "Element" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "id_prefixes", + "definition_uri": "https://w3id.org/linkml/id_prefixes", + "description": "the identifier of this class or slot must begin with the URIs referenced by this prefix", + "comments": [ + "Order of elements may be used to indicate priority order", + "If identifiers are treated as CURIEs, then the CURIE must start with one of the indicated prefixes followed by `:` (_should_ start if the list is open)", + "If identifiers are treated as URIs, then the URI string must start with the expanded for of the prefix (_should_ start if the list is open)" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://github.com/linkml/linkml/issues/194", + "https://github.com/linkml/linkml-model/issues/28" + ], + "domain": "Element", + "slot_uri": "https://w3id.org/linkml/id_prefixes", + "multivalued": true, + "owner": "Element", + "domain_of": [ + "Element" + ], + "range": "ncname", + "@type": "SlotDefinition" + }, + { + "name": "description", + "definition_uri": "https://w3id.org/linkml/description", + "description": "a description of the element's purpose and use", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "definition" + ], + "mappings": [ + "http://www.w3.org/2004/02/skos/core#definition" + ], + "exact_mappings": [ + "http://purl.org/dc/terms/description", + "http://schema.org/description" + ], + "rank": 5, + "domain": "Element", + "slot_uri": "http://www.w3.org/2004/02/skos/core#definition", + "owner": "description", + "domain_of": [ + "CommonMetadata", + "PermissibleValue" + ], + "range": "string", + "recommended": true, + "@type": "SlotDefinition" + }, + { + "name": "structured_aliases", + "definition_uri": "https://w3id.org/linkml/structured_aliases", + "description": "A list of structured_alias objects.", + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2008/05/skos-xl#altLabel" + ], + "slot_uri": "http://www.w3.org/2008/05/skos-xl#altLabel", + "multivalued": true, + "owner": "CommonMetadata", + "domain_of": [ + "CommonMetadata" + ], + "range": "StructuredAlias", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "aliases", + "definition_uri": "https://w3id.org/linkml/aliases", + "description": "Alaternate names for the element", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "synonyms", + "alternate names", + "alternative labels", + "designations" + ], + "mappings": [ + "http://www.w3.org/2004/02/skos/core#altLabel" + ], + "exact_mappings": [ + "http://schema.org/alternateName" + ], + "domain": "Element", + "slot_uri": "http://www.w3.org/2004/02/skos/core#altLabel", + "multivalued": true, + "owner": "aliases", + "domain_of": [ + "CommonMetadata" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "deprecated", + "definition_uri": "https://w3id.org/linkml/deprecated", + "description": "Description of why and when this element will no longer be used", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "close_mappings": [ + "http://www.w3.org/2002/07/owl#deprecated" + ], + "domain": "Element", + "slot_uri": "https://w3id.org/linkml/deprecated", + "owner": "deprecated", + "domain_of": [ + "CommonMetadata" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "todos", + "definition_uri": "https://w3id.org/linkml/todos", + "description": "Outstanding issue that needs resolution", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Element", + "slot_uri": "https://w3id.org/linkml/todos", + "multivalued": true, + "owner": "todos", + "domain_of": [ + "CommonMetadata" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "notes", + "definition_uri": "https://w3id.org/linkml/notes", + "description": "editorial notes about an element intended for internal consumption", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#editorialNote" + ], + "domain": "Element", + "slot_uri": "http://www.w3.org/2004/02/skos/core#editorialNote", + "multivalued": true, + "owner": "notes", + "domain_of": [ + "CommonMetadata" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "comments", + "definition_uri": "https://w3id.org/linkml/comments", + "description": "notes and comments about an element intended for external consumption", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#note" + ], + "exact_mappings": [ + "http://www.w3.org/2000/01/rdf-schema#comment" + ], + "domain": "Element", + "slot_uri": "http://www.w3.org/2004/02/skos/core#note", + "multivalued": true, + "owner": "comments", + "domain_of": [ + "CommonMetadata" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "in_subset", + "definition_uri": "https://w3id.org/linkml/in_subset", + "description": "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.geneontology.org/formats/oboInOwl#inSubset" + ], + "domain": "Element", + "slot_uri": "http://www.geneontology.org/formats/oboInOwl#inSubset", + "multivalued": true, + "owner": "in_subset", + "domain_of": [ + "CommonMetadata" + ], + "range": "SubsetDefinition", + "@type": "SlotDefinition" + }, + { + "name": "from_schema", + "definition_uri": "https://w3id.org/linkml/from_schema", + "description": "id of the schema that defined the element", + "notes": [ + "A stronger model would be range schema_definition, but this doesn't address the import model" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#inScheme" + ], + "domain": "Element", + "slot_uri": "http://www.w3.org/2004/02/skos/core#inScheme", + "readonly": "supplied by the schema loader", + "owner": "from_schema", + "domain_of": [ + "CommonMetadata" + ], + "range": "uri", + "@type": "SlotDefinition" + }, + { + "name": "imported_from", + "definition_uri": "https://w3id.org/linkml/imported_from", + "description": "the imports entry that this element was derived from. Empty means primary source", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Element", + "slot_uri": "https://w3id.org/linkml/imported_from", + "readonly": "supplied by the schema loader", + "owner": "imported_from", + "domain_of": [ + "CommonMetadata" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "see_also", + "definition_uri": "https://w3id.org/linkml/see_also", + "description": "a reference", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2000/01/rdf-schema#seeAlso" + ], + "domain": "Element", + "slot_uri": "http://www.w3.org/2000/01/rdf-schema#seeAlso", + "multivalued": true, + "owner": "see_also", + "domain_of": [ + "CommonMetadata" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "owned_by", + "definition_uri": "https://w3id.org/linkml/owned_by", + "description": "agent that owns or is the steward of the element", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "steward", + "owner" + ], + "close_mappings": [ + "http://www.w3.org/2000/01/rdf-schema#isDefinedBy" + ], + "domain": "Element", + "slot_uri": "https://w3id.org/linkml/owned_by", + "owner": "owned_by", + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "created_by", + "definition_uri": "https://w3id.org/linkml/created_by", + "description": "agent that created the element", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://purl.org/pav/createdBy" + ], + "domain": "Element", + "slot_uri": "http://purl.org/pav/createdBy", + "owner": "created_by", + "domain_of": [ + "Definition" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "created_on", + "definition_uri": "https://w3id.org/linkml/created_on", + "description": "time at which the element was created", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://purl.org/pav/createdOn" + ], + "domain": "Element", + "slot_uri": "http://purl.org/pav/createdOn", + "owner": "created_on", + "domain_of": [ + "Definition" + ], + "range": "datetime", + "@type": "SlotDefinition" + }, + { + "name": "last_updated_on", + "definition_uri": "https://w3id.org/linkml/last_updated_on", + "description": "time at which the element was last updated", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://purl.org/pav/lastUpdatedOn" + ], + "domain": "Element", + "slot_uri": "http://purl.org/pav/lastUpdatedOn", + "owner": "last_updated_on", + "domain_of": [ + "Definition" + ], + "range": "datetime", + "@type": "SlotDefinition" + }, + { + "name": "modified_by", + "definition_uri": "https://w3id.org/linkml/modified_by", + "description": "agent that modified the element", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://open-services.net/ns/core#modifiedBy" + ], + "domain": "Element", + "slot_uri": "http://open-services.net/ns/core#modifiedBy", + "owner": "modified_by", + "domain_of": [ + "Definition" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "status", + "definition_uri": "https://w3id.org/linkml/status", + "description": "status of the element", + "examples": [ + { + "value": "bibo:draft", + "@type": "Example" + } + ], + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://www.hl7.org/fhir/valueset-publication-status.html", + "https://www.hl7.org/fhir/versions.html#std-process" + ], + "aliases": [ + "workflow status" + ], + "mappings": [ + "http://purl.org/ontology/bibo/status" + ], + "domain": "Element", + "slot_uri": "http://purl.org/ontology/bibo/status", + "owner": "status", + "domain_of": [ + "Definition" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "literal_form", + "definition_uri": "https://w3id.org/linkml/literal_form", + "description": "The literal lexical form of a structured alias", + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "alias_name", + "string_value" + ], + "mappings": [ + "http://www.w3.org/2008/05/skos-xl#literalForm" + ], + "domain": "StructuredAlias", + "slot_uri": "http://www.w3.org/2008/05/skos-xl#literalForm", + "owner": "StructuredAlias", + "domain_of": [ + "StructuredAlias" + ], + "range": "string", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "alias_predicate", + "definition_uri": "https://w3id.org/linkml/alias_predicate", + "description": "The relationship between an element and its alias ", + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate" + ], + "domain": "StructuredAlias", + "slot_uri": "http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate", + "alias": "predicate", + "owner": "StructuredAlias", + "domain_of": [ + "StructuredAlias" + ], + "range": "alias_predicate_enum", + "recommended": true, + "@type": "SlotDefinition" + }, + { + "name": "in_language", + "definition_uri": "https://w3id.org/linkml/in_language", + "notes": [ + "Use a string from IETF BCP 47" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://schema.org/inLanguage" + ], + "slot_uri": "http://schema.org/inLanguage", + "owner": "CommonMetadata", + "domain_of": [ + "CommonMetadata" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "source", + "definition_uri": "https://w3id.org/linkml/source", + "description": "A related resource from which the element is derived.", + "comments": [ + "The described resource may be derived from the related resource in whole or in part" + ], + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "origin", + "derived from" + ], + "mappings": [ + "http://purl.org/dc/terms/source" + ], + "close_mappings": [ + "http://www.w3.org/ns/prov#wasDerivedFrom", + "http://schema.org/isBasedOn" + ], + "domain": "Element", + "slot_uri": "http://purl.org/dc/terms/source", + "owner": "source", + "domain_of": [ + "CommonMetadata" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "publisher", + "definition_uri": "https://w3id.org/linkml/publisher", + "description": "An entity responsible for making the resource available", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://purl.org/dc/terms/publisher" + ], + "domain": "Element", + "slot_uri": "http://purl.org/dc/terms/publisher", + "owner": "publisher", + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "is_a", + "definition_uri": "https://w3id.org/linkml/is_a", + "description": "A primary parent class or slot from which inheritable metaslots are propagated from. While multiple inheritance is not allowed, mixins can be provided effectively providing the same thing. The semantics are the same when translated to formalisms that allow MI (e.g. RDFS/OWL). When translating to a SI framework (e.g. java classes, python classes) then is a is used. When translating a framework without polymorphism (e.g. json-schema, solr document schema) then is a and mixins are recursively unfolded", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 11, + "abstract": true, + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/is_a", + "owner": "AnonymousClassExpression", + "domain_of": [ + "Definition", + "AnonymousClassExpression" + ], + "range": "Definition", + "@type": "SlotDefinition" + }, + { + "name": "abstract", + "definition_uri": "https://w3id.org/linkml/abstract", + "description": "Indicates the class or slot cannot be directly instantiated and is intended for grouping and specifying core inherited metaslots", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/abstract", + "owner": "Definition", + "domain_of": [ + "Definition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "mixin", + "definition_uri": "https://w3id.org/linkml/mixin", + "description": "Indicates the class or slot is intended to be inherited from without being an is_a parent. mixins should not be inherited from using is_a, except by other mixins.", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Mixin" + ], + "aliases": [ + "trait" + ], + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/mixin", + "owner": "Definition", + "domain_of": [ + "Definition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "mixins", + "definition_uri": "https://w3id.org/linkml/mixins", + "description": "A collection of secondary parent classes or slots from which inheritable metaslots are propagated from.", + "comments": [ + "mixins act in the same way as parents (is_a). They allow a model to have a primary strict hierachy, while keeping the benefits of multiple inheritance" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Mixin" + ], + "aliases": [ + "traits" + ], + "rank": 13, + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/mixins", + "multivalued": true, + "owner": "Definition", + "domain_of": [ + "Definition" + ], + "range": "Definition", + "@type": "SlotDefinition" + }, + { + "name": "apply_to", + "definition_uri": "https://w3id.org/linkml/apply_to", + "description": "Used to extend class or slot definitions. For example, if we have a core schema where a gene has two slots for identifier and symbol, and we have a specialized schema for my_organism where we wish to add a slot systematic_name, we can avoid subclassing by defining a class gene_my_organism, adding the slot to this class, and then adding an apply_to pointing to the gene class. The new slot will be 'injected into' the gene class.", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/apply_to", + "multivalued": true, + "owner": "Definition", + "domain_of": [ + "Definition" + ], + "range": "Definition", + "@type": "SlotDefinition" + }, + { + "name": "values_from", + "definition_uri": "https://w3id.org/linkml/values_from", + "description": "The identifier of a \"value set\" -- a set of identifiers that form the possible values for the range of a slot. Note: this is different than 'subproperty_of' in that 'subproperty_of' is intended to be a single ontology term while 'values_from' is the identifier of an entire value set. Additionally, this is different than an enumeration in that in an enumeration, the values of the enumeration are listed directly in the model itself. Setting this property on a slot does not guarantee an expansion of the ontological hiearchy into an enumerated list of possible values in every serialization of the model.", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/values_from", + "multivalued": true, + "owner": "Definition", + "domain_of": [ + "Definition" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "code_set", + "definition_uri": "https://w3id.org/linkml/code_set", + "description": "the identifier of an enumeration code set.", + "todos": [ + "this should be able to connect to an existing code set from TCCM" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/code_set", + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "code_set_version", + "definition_uri": "https://w3id.org/linkml/code_set_version", + "description": "the version identifier of the enumeration code set", + "comments": [ + "we assume that version identifiers lexically sort in temporal order. Recommend semver when possible" + ], + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/code_set_version", + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "code_set_tag", + "definition_uri": "https://w3id.org/linkml/code_set_tag", + "description": "the version tag of the enumeration code set", + "comments": [ + "enum_expression cannot have both a code_set_tag and a code_set_version" + ], + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/code_set_tag", + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "pv_formula", + "definition_uri": "https://w3id.org/linkml/pv_formula", + "description": "Defines the specific formula to be used to generate the permissible values.", + "comments": [ + "you cannot have BOTH the permissible_values and permissible_value_formula tag", + "code_set must be supplied for this to be valid" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/pv_formula", + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "pv_formula_options", + "@type": "SlotDefinition" + }, + { + "name": "permissible_values", + "definition_uri": "https://w3id.org/linkml/permissible_values", + "description": "A list of possible values for a slot range", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/permissible_values", + "multivalued": true, + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "PermissibleValue", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "enum_uri", + "definition_uri": "https://w3id.org/linkml/enum_uri", + "description": "URI of the enum that provides a semantic interpretation of the element in a linked data context. The URI may come from any namespace and may be shared between schemas", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "public ID" + ], + "domain": "EnumDefinition", + "slot_uri": "https://w3id.org/linkml/enum_uri", + "ifabsent": "class_curie", + "owner": "EnumDefinition", + "domain_of": [ + "EnumDefinition" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "include", + "definition_uri": "https://w3id.org/linkml/include", + "description": "An enum expression that yields a list of permissible values that are to be included, after subtracting the minus set", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/include", + "multivalued": true, + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "AnonymousEnumExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "minus", + "definition_uri": "https://w3id.org/linkml/minus", + "description": "An enum expression that yields a list of permissible values that are to be subtracted from the enum", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/minus", + "multivalued": true, + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "AnonymousEnumExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "inherits", + "definition_uri": "https://w3id.org/linkml/inherits", + "description": "An enum definition that is used as the basis to create a new enum", + "comments": [ + "All permissible values for all inherited enums are copied to form the initial seed set" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/inherits", + "multivalued": true, + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "EnumDefinition", + "@type": "SlotDefinition" + }, + { + "name": "matches", + "definition_uri": "https://w3id.org/linkml/matches", + "description": "Specifies a match query that is used to calculate the list of permissible values", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/matches", + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "MatchQuery", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "identifier_pattern", + "definition_uri": "https://w3id.org/linkml/identifier_pattern", + "description": "A regular expression that is used to obtain a set of identifiers from a source_ontology to construct a set of permissible values", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "MatchQuery", + "slot_uri": "https://w3id.org/linkml/identifier_pattern", + "owner": "MatchQuery", + "domain_of": [ + "MatchQuery" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "concepts", + "definition_uri": "https://w3id.org/linkml/concepts", + "description": "A list of identifiers that are used to construct a set of permissible values", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/concepts", + "multivalued": true, + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "reachable_from", + "definition_uri": "https://w3id.org/linkml/reachable_from", + "description": "Specifies a query for obtaining a list of permissible values based on graph reachability", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "EnumExpression", + "slot_uri": "https://w3id.org/linkml/reachable_from", + "owner": "EnumExpression", + "domain_of": [ + "EnumExpression" + ], + "range": "ReachabilityQuery", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "source_ontology", + "definition_uri": "https://w3id.org/linkml/source_ontology", + "description": "An ontology or vocabulary or terminology that is used in a query to obtain a set of permissible values", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "terminology", + "vocabulary" + ], + "slot_uri": "https://w3id.org/linkml/source_ontology", + "owner": "ReachabilityQuery", + "domain_of": [ + "MatchQuery", + "ReachabilityQuery" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "is_direct", + "definition_uri": "https://w3id.org/linkml/is_direct", + "description": "True if the reachability query should only include directly related nodes, if False then include also transitively connected", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "non-transitive" + ], + "domain": "ReachabilityQuery", + "slot_uri": "https://w3id.org/linkml/is_direct", + "owner": "ReachabilityQuery", + "domain_of": [ + "ReachabilityQuery" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "traverse_up", + "definition_uri": "https://w3id.org/linkml/traverse_up", + "description": "True if the direction of the reachability query is reversed and ancestors are retrieved", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "ancestors" + ], + "domain": "ReachabilityQuery", + "slot_uri": "https://w3id.org/linkml/traverse_up", + "owner": "ReachabilityQuery", + "domain_of": [ + "ReachabilityQuery" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "include_self", + "definition_uri": "https://w3id.org/linkml/include_self", + "description": "True if the query is reflexive", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "reflexive" + ], + "domain": "ReachabilityQuery", + "slot_uri": "https://w3id.org/linkml/include_self", + "owner": "ReachabilityQuery", + "domain_of": [ + "ReachabilityQuery" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "relationship_types", + "definition_uri": "https://w3id.org/linkml/relationship_types", + "description": "A list of relationship types (properties) that are used in a reachability query", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "predicates", + "properties" + ], + "domain": "ReachabilityQuery", + "slot_uri": "https://w3id.org/linkml/relationship_types", + "multivalued": true, + "owner": "ReachabilityQuery", + "domain_of": [ + "ReachabilityQuery" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "source_nodes", + "definition_uri": "https://w3id.org/linkml/source_nodes", + "description": "A list of nodes that are used in the reachability query", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "ReachabilityQuery", + "slot_uri": "https://w3id.org/linkml/source_nodes", + "multivalued": true, + "owner": "ReachabilityQuery", + "domain_of": [ + "ReachabilityQuery" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "text", + "definition_uri": "https://w3id.org/linkml/text", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "value" + ], + "close_mappings": [ + "http://www.w3.org/2004/02/skos/core#notation" + ], + "rank": 21, + "domain": "PermissibleValue", + "slot_uri": "https://w3id.org/linkml/text", + "identifier": true, + "owner": "PermissibleValue", + "domain_of": [ + "PermissibleValue" + ], + "range": "string", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "meaning", + "definition_uri": "https://w3id.org/linkml/meaning", + "description": "the value meaning of a permissible value", + "notes": [ + "we may want to change the range of this (and other) elements in the model to an entitydescription type construct" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/ISO/IEC_11179" + ], + "aliases": [ + "PV meaning" + ], + "rank": 23, + "domain": "PermissibleValue", + "slot_uri": "https://w3id.org/linkml/meaning", + "owner": "PermissibleValue", + "domain_of": [ + "PermissibleValue" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "id", + "definition_uri": "https://w3id.org/linkml/id", + "description": "The official schema URI", + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 0, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/id", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "uri", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "emit_prefixes", + "definition_uri": "https://w3id.org/linkml/emit_prefixes", + "description": "a list of Curie prefixes that are used in the representation of instances of the model. All prefixes in this list are added to the prefix sections of the target models.", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/emit_prefixes", + "multivalued": true, + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "ncname", + "@type": "SlotDefinition" + }, + { + "name": "version", + "definition_uri": "https://w3id.org/linkml/version", + "description": "particular version of schema", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://purl.org/pav/version" + ], + "exact_mappings": [ + "http://schema.org/schemaVersion" + ], + "domain": "SchemaDefinition", + "slot_uri": "http://purl.org/pav/version", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "imports", + "definition_uri": "https://w3id.org/linkml/imports", + "description": "other schemas that are included in this schema", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 21, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/imports", + "multivalued": true, + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "structured_imports", + "definition_uri": "https://w3id.org/linkml/structured_imports", + "description": "other schemas that are included in this schema", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/structured_imports", + "multivalued": true, + "owner": "structured_imports", + "range": "ImportExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "license", + "definition_uri": "https://w3id.org/linkml/license", + "description": "license for the schema", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://purl.org/dc/terms/license" + ], + "rank": 31, + "domain": "SchemaDefinition", + "slot_uri": "http://purl.org/dc/terms/license", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "default_curi_maps", + "definition_uri": "https://w3id.org/linkml/default_curi_maps", + "description": "ordered list of prefixcommon biocontexts to be fetched to resolve id prefixes and inline prefix variables", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/default_curi_maps", + "multivalued": true, + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "default_prefix", + "definition_uri": "https://w3id.org/linkml/default_prefix", + "description": "default and base prefix -- used for ':' identifiers, @base and @vocab", + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 11, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/default_prefix", + "ifabsent": "default_ns", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "default_range", + "definition_uri": "https://w3id.org/linkml/default_range", + "description": "default slot range to be used if range element is omitted from a slot definition", + "notes": [ + "restricted to type definitions for the time being. Could be broadened if required" + ], + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 13, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/default_range", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "TypeDefinition", + "@type": "SlotDefinition" + }, + { + "name": "subsets", + "definition_uri": "https://w3id.org/linkml/subsets", + "description": "An index to the collection of all subset definitions in the schema", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "http://www.geneontology.org/formats/oboInOwl#hasSubset" + ], + "rank": 8, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/subsets", + "multivalued": true, + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "SubsetDefinition", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "types", + "definition_uri": "https://w3id.org/linkml/types", + "description": "An index to the collection of all type definitions in the schema", + "in_subset": [ + "BasicSubset", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 6, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/types", + "multivalued": true, + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "TypeDefinition", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "enums", + "definition_uri": "https://w3id.org/linkml/enums", + "description": "An index to the collection of all enum definitions in the schema", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 5, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/enums", + "multivalued": true, + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "EnumDefinition", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "slot_definitions", + "definition_uri": "https://w3id.org/linkml/slot_definitions", + "description": "An index to the collection of all slot definitions in the schema", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 4, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/slots", + "multivalued": true, + "alias": "slots", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "SlotDefinition", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "classes", + "definition_uri": "https://w3id.org/linkml/classes", + "description": "An index to the collection of all class definitions in the schema", + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset", + "RelationalModelProfile", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 3, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/classes", + "multivalued": true, + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "ClassDefinition", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "metamodel_version", + "definition_uri": "https://w3id.org/linkml/metamodel_version", + "description": "Version of the metamodel used to load the schema", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/metamodel_version", + "readonly": "supplied by the schema loader", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "source_file", + "definition_uri": "https://w3id.org/linkml/source_file", + "description": "name, uri or description of the source of the schema", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/source_file", + "readonly": "suppplied by the schema loader", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "source_file_date", + "definition_uri": "https://w3id.org/linkml/source_file_date", + "description": "modification date of the source of the schema", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/source_file_date", + "readonly": "supplied by the loader", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "datetime", + "@type": "SlotDefinition" + }, + { + "name": "source_file_size", + "definition_uri": "https://w3id.org/linkml/source_file_size", + "description": "size in bytes of the source of the schema", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/source_file_size", + "readonly": "supplied by the schema loader", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "integer", + "@type": "SlotDefinition" + }, + { + "name": "generation_date", + "definition_uri": "https://w3id.org/linkml/generation_date", + "description": "date and time that the schema was loaded/generated", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/generation_date", + "readonly": "supplied by the schema loader", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "datetime", + "@type": "SlotDefinition" + }, + { + "name": "slots", + "definition_uri": "https://w3id.org/linkml/slots", + "description": "collection of slot names that are applicable to a class", + "comments": [ + "This defines the set of slots that are allowed to be used for a given class. The final list of slots for a class is the combination of the parent (is a) slots, mixins slots, apply to slots minus the slot usage entries. Formally," + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 19, + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/slots", + "multivalued": true, + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "slot_usage", + "definition_uri": "https://w3id.org/linkml/slot_usage", + "description": "the refinement of a slot in the context of the containing class definition.", + "comments": [ + "Many slots may be re-used across different classes, but the meaning of the slot may be refined by context. For example, a generic association model may use slots subject/predicate/object with generic semantics and minimal constraints. When this is subclasses, e.g. to disease-phenotype associations then slot usage may specify both local naming (e.g. subject=disease) and local constraints" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 23, + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/slot_usage", + "multivalued": true, + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "SlotDefinition", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "enum_range", + "definition_uri": "https://w3id.org/linkml/enum_range", + "description": "An inlined enumeration", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "slot_uri": "https://w3id.org/linkml/enum_range", + "owner": "SlotExpression", + "domain_of": [ + "SlotExpression" + ], + "range": "EnumExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "range_expression", + "definition_uri": "https://w3id.org/linkml/range_expression", + "description": "A range that is described as a boolean expression combining existing ranges", + "comments": [ + "one use for this is being able to describe a range using any_of expressions, for example to combine two enums" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotExpression", + "slot_uri": "https://w3id.org/linkml/range_expression", + "owner": "SlotExpression", + "domain_of": [ + "PathExpression", + "SlotExpression" + ], + "range": "AnonymousClassExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "boolean_slot", + "definition_uri": "https://w3id.org/linkml/boolean_slot", + "description": "A grouping of slots that expression a boolean operator over a list of operands", + "from_schema": "https://w3id.org/linkml/meta", + "abstract": true, + "slot_uri": "https://w3id.org/linkml/boolean_slot", + "multivalued": true, + "range": "Expression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "any_of", + "definition_uri": "https://w3id.org/linkml/any_of", + "description": "holds if at least one of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/or" + ], + "rank": 101, + "is_a": "boolean_slot", + "slot_uri": "https://w3id.org/linkml/any_of", + "multivalued": true, + "owner": "ClassExpression", + "domain_of": [ + "TypeExpression", + "PathExpression", + "SlotExpression", + "ClassExpression" + ], + "range": "Expression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "exactly_one_of", + "definition_uri": "https://w3id.org/linkml/exactly_one_of", + "description": "holds if only one of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/xone" + ], + "rank": 103, + "is_a": "boolean_slot", + "slot_uri": "https://w3id.org/linkml/exactly_one_of", + "multivalued": true, + "owner": "ClassExpression", + "domain_of": [ + "TypeExpression", + "PathExpression", + "SlotExpression", + "ClassExpression" + ], + "range": "Expression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "none_of", + "definition_uri": "https://w3id.org/linkml/none_of", + "description": "holds if none of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/not" + ], + "rank": 105, + "is_a": "boolean_slot", + "slot_uri": "https://w3id.org/linkml/none_of", + "multivalued": true, + "owner": "ClassExpression", + "domain_of": [ + "TypeExpression", + "PathExpression", + "SlotExpression", + "ClassExpression" + ], + "range": "Expression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "all_of", + "definition_uri": "https://w3id.org/linkml/all_of", + "description": "holds if all of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/and" + ], + "rank": 107, + "is_a": "boolean_slot", + "slot_uri": "https://w3id.org/linkml/all_of", + "multivalued": true, + "owner": "ClassExpression", + "domain_of": [ + "TypeExpression", + "PathExpression", + "SlotExpression", + "ClassExpression" + ], + "range": "Expression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "preconditions", + "definition_uri": "https://w3id.org/linkml/preconditions", + "description": "an expression that must hold in order for the rule to be applicable to an instance", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "if", + "body", + "antecedents" + ], + "mappings": [ + "https://w3id.org/shacl/condition" + ], + "close_mappings": [ + "http://www.w3.org/2003/11/swrl#body" + ], + "rank": 111, + "slot_uri": "https://w3id.org/shacl/condition", + "owner": "ClassRule", + "domain_of": [ + "ClassRule" + ], + "range": "AnonymousClassExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "postconditions", + "definition_uri": "https://w3id.org/linkml/postconditions", + "description": "an expression that must hold for an instance of the class, if the preconditions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "then", + "head", + "consequents" + ], + "close_mappings": [ + "http://www.w3.org/2003/11/swrl#body" + ], + "rank": 113, + "slot_uri": "https://w3id.org/linkml/postconditions", + "owner": "ClassRule", + "domain_of": [ + "ClassRule" + ], + "range": "AnonymousClassExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "elseconditions", + "definition_uri": "https://w3id.org/linkml/elseconditions", + "description": "an expression that must hold for an instance of the class, if the preconditions no not hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "else" + ], + "rank": 115, + "slot_uri": "https://w3id.org/linkml/elseconditions", + "owner": "ClassRule", + "domain_of": [ + "ClassRule" + ], + "range": "AnonymousClassExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "bidirectional", + "definition_uri": "https://w3id.org/linkml/bidirectional", + "description": "in addition to preconditions entailing postconditions, the postconditions entail the preconditions", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "iff", + "if and only if" + ], + "slot_uri": "https://w3id.org/linkml/bidirectional", + "owner": "ClassRule", + "domain_of": [ + "ClassRule" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "open_world", + "definition_uri": "https://w3id.org/linkml/open_world", + "description": "if true, the the postconditions may be omitted in instance data, but it is valid for an inference engine to add these", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "slot_uri": "https://w3id.org/linkml/open_world", + "owner": "ClassRule", + "domain_of": [ + "ClassRule" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "rank", + "definition_uri": "https://w3id.org/linkml/rank", + "description": "the relative order in which the element occurs, lower values are given precedence", + "comments": [ + "the rank of an element does not affect the semantics" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "order", + "precedence", + "display order" + ], + "mappings": [ + "https://w3id.org/shacl/order" + ], + "exact_mappings": [ + "http://qudt.org/schema/qudt/order", + "http://purl.org/linked-data/cube#order" + ], + "rank": 51, + "slot_uri": "https://w3id.org/shacl/order", + "owner": "ClassRule", + "domain_of": [ + "CommonMetadata", + "ClassRule" + ], + "range": "integer", + "@type": "SlotDefinition" + }, + { + "name": "deactivated", + "definition_uri": "https://w3id.org/linkml/deactivated", + "description": "a deactivated rule is not executed by the rules engine", + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "https://w3id.org/shacl/deactivated" + ], + "slot_uri": "https://w3id.org/shacl/deactivated", + "owner": "ClassRule", + "domain_of": [ + "ClassRule" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "rules", + "definition_uri": "https://w3id.org/linkml/rules", + "description": "the collection of rules that apply to all members of this class", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "https://w3id.org/shacl/rule" + ], + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/shacl/rule", + "multivalued": true, + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "ClassRule", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "classification_rules", + "definition_uri": "https://w3id.org/linkml/classification_rules", + "description": "the collection of classification rules that apply to all members of this class", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/classification_rules", + "multivalued": true, + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "AnonymousClassExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "slot_conditions", + "definition_uri": "https://w3id.org/linkml/slot_conditions", + "description": "expresses constraints on a group of slots for a class expression", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "ClassExpression", + "slot_uri": "https://w3id.org/linkml/slot_conditions", + "multivalued": true, + "owner": "ClassExpression", + "domain_of": [ + "ClassExpression" + ], + "range": "SlotDefinition", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "attributes", + "definition_uri": "https://w3id.org/linkml/attributes", + "description": "Inline definition of slots", + "comments": [ + "attributes are an alternative way of defining new slots. An attribute adds a slot to the global space in the form __ (lower case, double underscores). Attributes can be specialized via slot_usage." + ], + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset", + "RelationalModelProfile", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 29, + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/attributes", + "multivalued": true, + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "SlotDefinition", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "class_uri", + "definition_uri": "https://w3id.org/linkml/class_uri", + "description": "URI of the class that provides a semantic interpretation of the element in a linked data context. The URI may come from any namespace and may be shared between schemas", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "public ID" + ], + "rank": 2, + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/class_uri", + "ifabsent": "class_curie", + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "subclass_of", + "definition_uri": "https://w3id.org/linkml/subclass_of", + "description": "rdfs:subClassOf to be emitted in OWL generation", + "deprecated": "Use is_a instead", + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2000/01/rdf-schema#subClassOf" + ], + "domain": "ClassDefinition", + "slot_uri": "http://www.w3.org/2000/01/rdf-schema#subClassOf", + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "defining_slots", + "definition_uri": "https://w3id.org/linkml/defining_slots", + "description": "The combination of is a plus defining slots form a genus-differentia definition, or the set of necessary and sufficient conditions that can be transformed into an OWL equivalence axiom", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/defining_slots", + "multivalued": true, + "inherited": true, + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "union_of", + "definition_uri": "https://w3id.org/linkml/union_of", + "description": "indicates that the domain element consists exactly of the members of the element in the range.", + "notes": [ + "this only applies in the OWL generation" + ], + "in_subset": [ + "SpecificationSubset", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Element", + "slot_uri": "https://w3id.org/linkml/union_of", + "multivalued": true, + "owner": "union_of", + "domain_of": [ + "TypeDefinition", + "SlotDefinition", + "ClassDefinition" + ], + "range": "Element", + "@type": "SlotDefinition" + }, + { + "name": "tree_root", + "definition_uri": "https://w3id.org/linkml/tree_root", + "description": "indicator that this is the root class in tree structures", + "notes": [ + "each schema should have at most one tree root" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 31, + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/tree_root", + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "unique_keys", + "definition_uri": "https://w3id.org/linkml/unique_keys", + "description": "A collection of unique keys for this class. Unique keys may be singular or compound.", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "RelationalModelProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "http://www.w3.org/2002/07/owl#hasKey" + ], + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/unique_keys", + "multivalued": true, + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "UniqueKey", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "unique_key_name", + "definition_uri": "https://w3id.org/linkml/unique_key_name", + "description": "name of the unique key", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "RelationalModelProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "UniqueKey", + "slot_uri": "https://w3id.org/linkml/unique_key_name", + "key": true, + "owner": "UniqueKey", + "domain_of": [ + "UniqueKey" + ], + "range": "string", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "unique_key_slots", + "definition_uri": "https://w3id.org/linkml/unique_key_slots", + "description": "list of slot names that form a key", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "RelationalModelProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "UniqueKey", + "slot_uri": "https://w3id.org/linkml/unique_key_slots", + "multivalued": true, + "owner": "UniqueKey", + "domain_of": [ + "UniqueKey" + ], + "range": "SlotDefinition", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "slot_names_unique", + "definition_uri": "https://w3id.org/linkml/slot_names_unique", + "description": "if true then induced/mangled slot names are not created for class_usage and attributes", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/slot_names_unique", + "owner": "slot_names_unique", + "domain_of": [ + "SchemaDefinition", + "ClassDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "domain", + "definition_uri": "https://w3id.org/linkml/domain", + "description": "defines the type of the subject of the slot. Given the following slot definition\n S1:\n domain: C1\n range: C2\nthe declaration\n X:\n S1: Y\n\nimplicitly asserts that X is an instance of C1\n", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/domain", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "ClassDefinition", + "@type": "SlotDefinition" + }, + { + "name": "range", + "definition_uri": "https://w3id.org/linkml/range", + "description": "defines the type of the object of the slot. Given the following slot definition\n S1:\n domain: C1\n range: C2\nthe declaration\n X:\n S1: Y\n\nimplicitly asserts Y is an instance of C2\n", + "comments": [ + "range is underspecified, as not all elements can appear as the range of a slot." + ], + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset", + "RelationalModelProfile", + "ObjectOrientedProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "value domain" + ], + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/range", + "inherited": true, + "ifabsent": "default_range", + "owner": "range", + "domain_of": [ + "SlotExpression" + ], + "range": "Element", + "@type": "SlotDefinition" + }, + { + "name": "slot_uri", + "definition_uri": "https://w3id.org/linkml/slot_uri", + "description": "predicate of this slot for semantic web application", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "public ID" + ], + "rank": 2, + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/slot_uri", + "ifabsent": "slot_curie", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "multivalued", + "definition_uri": "https://w3id.org/linkml/multivalued", + "description": "true means that slot can have more than one value", + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset", + "ObjectOrientedProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 7, + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/multivalued", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "inherited", + "definition_uri": "https://w3id.org/linkml/inherited", + "description": "true means that the *value* of a slot is inherited by subclasses", + "comments": [ + "Inherited applies to slot values. Parent *slots* are always inherited by subclasses" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/inherited", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "readonly", + "definition_uri": "https://w3id.org/linkml/readonly", + "description": "If present, slot is read only. Text explains why", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/readonly", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "ifabsent", + "definition_uri": "https://w3id.org/linkml/ifabsent", + "description": "function that provides a default value for the slot. Possible values for this slot are defined in\nlinkml_runtime.utils.ifabsent_functions.default_library:\n * [Tt]rue -- boolean True\n * [Ff]alse -- boolean False\n * int(value) -- integer value\n * str(value) -- string value\n * default_range -- schema default range\n * bnode -- blank node identifier\n * slot_uri -- URI for the slot\n * class_curie -- CURIE for the containing class\n * class_uri -- URI for the containing class", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "close_mappings": [ + "https://w3id.org/shacl/defaultValue" + ], + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/ifabsent", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "implicit_prefix", + "definition_uri": "https://w3id.org/linkml/implicit_prefix", + "description": "Causes the slot value to be interpreted as a uriorcurie after prefixing with this string", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotExpression", + "slot_uri": "https://w3id.org/linkml/implicit_prefix", + "owner": "SlotExpression", + "domain_of": [ + "TypeExpression", + "SlotExpression" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "value_specification_constant", + "definition_uri": "https://w3id.org/linkml/value_specification_constant", + "description": "Grouping for metamodel slots that constrain the a slot value to equal a specified constant", + "from_schema": "https://w3id.org/linkml/meta", + "abstract": true, + "status": "testing", + "slot_uri": "https://w3id.org/linkml/value_specification_constant", + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "list_value_specification_constant", + "definition_uri": "https://w3id.org/linkml/list_value_specification_constant", + "description": "Grouping for metamodel slots that constrain members of a multivalued slot value to equal a specified constant", + "from_schema": "https://w3id.org/linkml/meta", + "abstract": true, + "status": "testing", + "slot_uri": "https://w3id.org/linkml/list_value_specification_constant", + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "value_presence", + "definition_uri": "https://w3id.org/linkml/value_presence", + "description": "if true then a value must be present (for lists there must be at least one value). If false then a value must be absent (for lists, must be empty)", + "comments": [ + "if set to true this has the same effect as required=true. In contrast, required=false allows a value to be present" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "list_value_specification_constant", + "status": "unstable", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/value_presence", + "inherited": true, + "owner": "value_presence", + "domain_of": [ + "SlotExpression" + ], + "range": "presence_enum", + "@type": "SlotDefinition" + }, + { + "name": "equals_string", + "definition_uri": "https://w3id.org/linkml/equals_string", + "description": "the slot must have range string and the value of the slot must equal the specified value", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "list_value_specification_constant", + "slot_uri": "https://w3id.org/linkml/equals_string", + "inherited": true, + "owner": "SlotExpression", + "domain_of": [ + "TypeExpression", + "SlotExpression" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "equals_number", + "definition_uri": "https://w3id.org/linkml/equals_number", + "description": "the slot must have range of a number and the value of the slot must equal the specified value", + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "list_value_specification_constant", + "status": "unstable", + "slot_uri": "https://w3id.org/linkml/equals_number", + "inherited": true, + "owner": "SlotExpression", + "domain_of": [ + "TypeExpression", + "SlotExpression" + ], + "range": "integer", + "@type": "SlotDefinition" + }, + { + "name": "equals_expression", + "definition_uri": "https://w3id.org/linkml/equals_expression", + "description": "the value of the slot must equal the value of the evaluated expression", + "todos": [ + "specify expression language" + ], + "comments": [ + "for example, a 'length' slot may have an equals_expression with value '(end-start)+1'" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://github.com/linkml/linkml/issues/75" + ], + "is_a": "list_value_specification_constant", + "slot_uri": "https://w3id.org/linkml/equals_expression", + "inherited": true, + "owner": "SlotExpression", + "domain_of": [ + "SlotExpression" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "minimum_cardinality", + "definition_uri": "https://w3id.org/linkml/minimum_cardinality", + "description": "the minimum number of entries for a multivalued slot", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "list_value_specification_constant", + "status": "testing", + "slot_uri": "https://w3id.org/linkml/minimum_cardinality", + "inherited": true, + "owner": "SlotExpression", + "domain_of": [ + "SlotExpression" + ], + "range": "integer", + "@type": "SlotDefinition" + }, + { + "name": "maximum_cardinality", + "definition_uri": "https://w3id.org/linkml/maximum_cardinality", + "description": "the maximum number of entries for a multivalued slot", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "list_value_specification_constant", + "status": "testing", + "slot_uri": "https://w3id.org/linkml/maximum_cardinality", + "inherited": true, + "owner": "SlotExpression", + "domain_of": [ + "SlotExpression" + ], + "range": "integer", + "@type": "SlotDefinition" + }, + { + "name": "equals_string_in", + "definition_uri": "https://w3id.org/linkml/equals_string_in", + "description": "the slot must have range string and the value of the slot must equal one of the specified values", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "list_value_specification_constant", + "status": "testing", + "slot_uri": "https://w3id.org/linkml/equals_string_in", + "multivalued": true, + "inherited": true, + "owner": "SlotExpression", + "domain_of": [ + "TypeExpression", + "SlotExpression" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "equals_number_in", + "definition_uri": "https://w3id.org/linkml/equals_number_in", + "description": "the slot must have range number and the value of the slot must equal one of the specified values", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "list_value_specification_constant", + "status": "testing", + "slot_uri": "https://w3id.org/linkml/equals_number_in", + "multivalued": true, + "inherited": true, + "range": "integer", + "@type": "SlotDefinition" + }, + { + "name": "has_member", + "definition_uri": "https://w3id.org/linkml/has_member", + "description": "the value of the slot is multivalued with at least one member satisfying the condition", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "list_value_specification_constant", + "status": "testing", + "slot_uri": "https://w3id.org/linkml/has_member", + "owner": "SlotExpression", + "domain_of": [ + "SlotExpression" + ], + "range": "AnonymousSlotExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "all_members", + "definition_uri": "https://w3id.org/linkml/all_members", + "description": "the value of the slot is multivalued with all members satisfying the condition", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "list_value_specification_constant", + "status": "testing", + "slot_uri": "https://w3id.org/linkml/all_members", + "owner": "SlotExpression", + "domain_of": [ + "SlotExpression" + ], + "range": "AnonymousSlotExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "singular_name", + "definition_uri": "https://w3id.org/linkml/singular_name", + "description": "a name that is used in the singular form", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#altLabel" + ], + "domain": "SlotDefinition", + "slot_uri": "http://www.w3.org/2004/02/skos/core#altLabel", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "required", + "definition_uri": "https://w3id.org/linkml/required", + "description": "true means that the slot must be present in the loaded definition", + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset", + "RelationalModelProfile", + "ObjectOrientedProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 8, + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/required", + "inherited": true, + "owner": "required", + "domain_of": [ + "SlotExpression" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "recommended", + "definition_uri": "https://w3id.org/linkml/recommended", + "description": "true means that the slot should be present in the loaded definition, but this is not required", + "comments": [ + "This is to be used where not all data is expected to conform to having a required field", + "If a slot is recommended, and it is not populated, applications must not treat this as an error. Applications may use this to inform the user of missing data" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://github.com/linkml/linkml/issues/177" + ], + "rank": 9, + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/recommended", + "inherited": true, + "owner": "recommended", + "domain_of": [ + "SlotExpression" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "inapplicable", + "definition_uri": "https://w3id.org/linkml/inapplicable", + "description": "true means that the slot must not be present", + "comments": [ + "By default all slots are applicable. The main use case for this slot is as an override in a subclass" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/inapplicable", + "inherited": true, + "owner": "inapplicable", + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "inlined", + "definition_uri": "https://w3id.org/linkml/inlined", + "description": "True means that keyed or identified slot appears in an outer structure by value. False means that only the key or identifier for the slot appears within the domain, referencing a structure that appears elsewhere.", + "comments": [ + "classes without keys or identifiers are necessarily inlined as lists" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 25, + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/inlined", + "inherited": true, + "owner": "inlined", + "domain_of": [ + "SlotExpression" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "inlined_as_list", + "definition_uri": "https://w3id.org/linkml/inlined_as_list", + "description": "True means that an inlined slot is represented as a list of range instances. False means that an inlined slot is represented as a dictionary, whose key is the slot key or identifier and whose value is the range instance.", + "comments": [ + "The default loader will accept either list or dictionary form as input. This parameter controls internal\nrepresentation and output.", + "A keyed or identified class with one additional slot can be input in a third form, a dictionary whose key\nis the key or identifier and whose value is the one additional element. This form is still stored according\nto the inlined_as_list setting." + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 27, + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/inlined_as_list", + "inherited": true, + "owner": "inlined_as_list", + "domain_of": [ + "SlotExpression" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "list_elements_ordered", + "definition_uri": "https://w3id.org/linkml/list_elements_ordered", + "description": "If True, then the order of elements of a multivalued slot is guaranteed to be preserved. If False, the order may still be preserved but this is not guaranteed", + "comments": [ + "should only be used with multivalued slots" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/list_elements_ordered", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "list_elements_unique", + "definition_uri": "https://w3id.org/linkml/list_elements_unique", + "description": "If True, then there must be no duplicates in the elements of a multivalued slot", + "comments": [ + "should only be used with multivalued slots" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/list_elements_unique", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "shared", + "definition_uri": "https://w3id.org/linkml/shared", + "description": "If True, then the relationship between the slot domain and range is many to one or many to many", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "inverse functional", + "many to one or many" + ], + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/shared", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "key", + "definition_uri": "https://w3id.org/linkml/key", + "description": "True means that the key slot(s) uniquely identify the container.", + "comments": [ + "see also 'unique_key'", + "key is inherited", + "a given domain can have at most one key slot (restriction to be removed in the future)", + "identifiers and keys are mutually exclusive. A given domain cannot have both", + "a key slot is automatically required. Keys cannot be optional" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "RelationalModelProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/key", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "identifier", + "definition_uri": "https://w3id.org/linkml/identifier", + "description": "True means that the key slot(s) uniquely identify the container. There can be at most one identifier or key per container", + "comments": [ + "identifier is inherited", + "a key slot is automatically required. Identifiers cannot be optional", + "a given domain can have at most one identifier", + "identifiers and keys are mutually exclusive. A given domain cannot have both" + ], + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset", + "RelationalModelProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Identifier" + ], + "aliases": [ + "primary key", + "ID", + "UID", + "code" + ], + "rank": 5, + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/identifier", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "designates_type", + "definition_uri": "https://w3id.org/linkml/designates_type", + "description": "True means that the key slot(s) is used to determine the instantiation (types) relation between objects and a ClassDefinition", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "type designator" + ], + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/designates_type", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "alias", + "definition_uri": "https://w3id.org/linkml/alias", + "description": "the name used for a slot in the context of its owning class. If present, this is used instead of the actual slot name.", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#prefLabel" + ], + "rank": 6, + "domain": "SlotDefinition", + "slot_uri": "http://www.w3.org/2004/02/skos/core#prefLabel", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "owner", + "definition_uri": "https://w3id.org/linkml/owner", + "description": "the \"owner\" of the slot. It is the class if it appears in the slots list, otherwise the declaring slot", + "deprecated": "Will be replaced by domain_of and eventually removed", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/owner", + "readonly": "filled in by loader -- either class domain or slot domain", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "Definition", + "@type": "SlotDefinition" + }, + { + "name": "domain_of", + "definition_uri": "https://w3id.org/linkml/domain_of", + "description": "the class(es) that reference the slot in a \"slots\" or \"slot_usage\" context", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/domain_of", + "multivalued": true, + "readonly": "filled in by the loader", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "ClassDefinition", + "@type": "SlotDefinition" + }, + { + "name": "is_usage_slot", + "definition_uri": "https://w3id.org/linkml/is_usage_slot", + "description": "True means that this slot was defined in a slot_usage situation", + "deprecated": "Replaced by usage_slot_name", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/is_usage_slot", + "readonly": "filled in by the loader", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "usage_slot_name", + "definition_uri": "https://w3id.org/linkml/usage_slot_name", + "description": "The name of the slot referenced in the slot_usage", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/usage_slot_name", + "readonly": "filled in by the loader", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "subproperty_of", + "definition_uri": "https://w3id.org/linkml/subproperty_of", + "description": "Ontology property which this slot is a subproperty of. Note: setting this property on a slot does not guarantee an expansion of the ontological hiearchy into an enumerated list of possible values in every serialization of the model.", + "examples": [ + { + "value": "RO:HOM0000001", + "description": "this is the RO term for \"in homology relationship with\", and used as a value of subproperty of this means that any ontological child (related to RO:HOM0000001 via an is_a relationship), is a valid value for the slot that declares this with the subproperty_of tag. This differs from the 'values_from' meta model component in that 'values_from' requires the id of a value set (said another way, if an entire ontology had a curie/identifier that was the identifier for the entire ontology, then that identifier would be used in 'values_from.')", + "@type": "Example" + } + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2000/01/rdf-schema#subPropertyOf" + ], + "domain": "SlotDefinition", + "slot_uri": "http://www.w3.org/2000/01/rdf-schema#subPropertyOf", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "disjoint_with", + "definition_uri": "https://w3id.org/linkml/disjoint_with", + "description": "Two classes are disjoint if they have no instances in common, two slots are disjoint if they can never hold between the same two instances", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/disjoint_with", + "multivalued": true, + "owner": "disjoint_with", + "domain_of": [ + "SlotDefinition", + "ClassDefinition" + ], + "range": "Definition", + "@type": "SlotDefinition" + }, + { + "name": "children_are_mutually_disjoint", + "definition_uri": "https://w3id.org/linkml/children_are_mutually_disjoint", + "description": "If true then all direct is_a children are mutually disjoint and share no instances in common", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/children_are_mutually_disjoint", + "owner": "children_are_mutually_disjoint", + "domain_of": [ + "SlotDefinition", + "ClassDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "relational_logical_characteristic", + "definition_uri": "https://w3id.org/linkml/relational_logical_characteristic", + "description": "A property of a slot that pertains to its logical properties", + "from_schema": "https://w3id.org/linkml/meta", + "abstract": true, + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/relational_logical_characteristic", + "owner": "relational_logical_characteristic", + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "symmetric", + "definition_uri": "https://w3id.org/linkml/symmetric", + "description": "If s is symmetric, and i.s=v, then v.s=i", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "close_mappings": [ + "http://www.w3.org/2002/07/owl#SymmetricProperty" + ], + "is_a": "relational_logical_characteristic", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/symmetric", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "asymmetric", + "definition_uri": "https://w3id.org/linkml/asymmetric", + "description": "If s is antisymmetric, and i.s=v where i is different from v, v.s cannot have value i", + "comments": [ + "asymmetry is the combination of antisymmetry and irreflexivity" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "close_mappings": [ + "http://www.w3.org/2002/07/owl#AsymmetricProperty" + ], + "is_a": "relational_logical_characteristic", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/asymmetric", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "reflexive", + "definition_uri": "https://w3id.org/linkml/reflexive", + "description": "If s is reflexive, then i.s=i for all instances i", + "comments": [ + "it is rare for a property to be reflexive, this characteristic is added for completeness, consider instead locally_reflexive" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "close_mappings": [ + "http://www.w3.org/2002/07/owl#ReflexiveProperty" + ], + "is_a": "relational_logical_characteristic", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/reflexive", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "irreflexive", + "definition_uri": "https://w3id.org/linkml/irreflexive", + "description": "If s is irreflexive, then there exists no i such i.s=i", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "close_mappings": [ + "http://www.w3.org/2002/07/owl#IrreflexiveProperty" + ], + "is_a": "relational_logical_characteristic", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/irreflexive", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "locally_reflexive", + "definition_uri": "https://w3id.org/linkml/locally_reflexive", + "description": "If s is locally_reflexive, then i.s=i for all instances i where s is a class slot for the type of i", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "relational_logical_characteristic", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/locally_reflexive", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "transitive", + "definition_uri": "https://w3id.org/linkml/transitive", + "description": "If s is transitive, and i.s=z, and s.s=j, then i.s=j", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "close_mappings": [ + "http://www.w3.org/2002/07/owl#TransitiveProperty" + ], + "is_a": "relational_logical_characteristic", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/transitive", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "transitive_form_of", + "definition_uri": "https://w3id.org/linkml/transitive_form_of", + "description": "If s transitive_form_of d, then (1) s holds whenever d holds (2) s is transitive (3) d holds whenever s holds and there are no intermediates, and s is not reflexive", + "comments": [ + "{'Example': 'ancestor_of is the transitive_form_of parent_of'}" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "slot_uri": "https://w3id.org/linkml/transitive_form_of", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "reflexive_transitive_form_of", + "definition_uri": "https://w3id.org/linkml/reflexive_transitive_form_of", + "description": "transitive_form_of including the reflexive case", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "transitive_form_of", + "slot_uri": "https://w3id.org/linkml/reflexive_transitive_form_of", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "inverse", + "definition_uri": "https://w3id.org/linkml/inverse", + "description": "indicates that any instance of d s r implies that there is also an instance of r s' d", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2002/07/owl#inverseOf" + ], + "domain": "SlotDefinition", + "slot_uri": "http://www.w3.org/2002/07/owl#inverseOf", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "is_class_field", + "definition_uri": "https://w3id.org/linkml/is_class_field", + "description": "indicates that for any instance, i, the domain of this slot will include an assertion of i s range", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/is_class_field", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "role", + "definition_uri": "https://w3id.org/linkml/role", + "description": "a textual descriptor that indicates the role played by the slot range", + "comments": [ + "the primary use case for this slot is to provide a textual descriptor of a generic slot name when used in the context of a more specific class" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/role", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "minimum_value", + "definition_uri": "https://w3id.org/linkml/minimum_value", + "description": "for slots with ranges of type number, the value must be equal to or higher than this", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "low value" + ], + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/minimum_value", + "inherited": true, + "owner": "minimum_value", + "domain_of": [ + "TypeExpression", + "SlotExpression" + ], + "range": "integer", + "@type": "SlotDefinition" + }, + { + "name": "maximum_value", + "definition_uri": "https://w3id.org/linkml/maximum_value", + "description": "for slots with ranges of type number, the value must be equal to or lowe than this", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "high value" + ], + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/maximum_value", + "inherited": true, + "owner": "maximum_value", + "domain_of": [ + "TypeExpression", + "SlotExpression" + ], + "range": "integer", + "@type": "SlotDefinition" + }, + { + "name": "interpolated", + "definition_uri": "https://w3id.org/linkml/interpolated", + "description": "if true then the pattern is first string interpolated", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "PatternExpression", + "slot_uri": "https://w3id.org/linkml/interpolated", + "owner": "PatternExpression", + "domain_of": [ + "PatternExpression" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "partial_match", + "definition_uri": "https://w3id.org/linkml/partial_match", + "description": "if true then the pattern must match the whole string, as if enclosed in ^...$", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "PatternExpression", + "slot_uri": "https://w3id.org/linkml/partial_match", + "owner": "PatternExpression", + "domain_of": [ + "PatternExpression" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "pattern", + "definition_uri": "https://w3id.org/linkml/pattern", + "description": "the string value of the slot must conform to this regular expression expressed in the string", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 35, + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/pattern", + "inherited": true, + "owner": "pattern", + "domain_of": [ + "TypeExpression", + "SlotExpression" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "syntax", + "definition_uri": "https://w3id.org/linkml/syntax", + "description": "the string value of the slot must conform to this regular expression expressed in the string. May be interpolated.", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "PatternExpression", + "slot_uri": "https://w3id.org/linkml/syntax", + "inherited": true, + "owner": "PatternExpression", + "domain_of": [ + "PatternExpression" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "structured_pattern", + "definition_uri": "https://w3id.org/linkml/structured_pattern", + "description": "the string value of the slot must conform to the regular expression in the pattern expression", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/structured_pattern", + "inherited": true, + "owner": "structured_pattern", + "domain_of": [ + "TypeExpression", + "SlotExpression" + ], + "range": "PatternExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "string_serialization", + "definition_uri": "https://w3id.org/linkml/string_serialization", + "description": "Used on a slot that stores the string serialization of the containing object. The syntax follows python formatted strings, with slot names enclosed in {}s. These are expanded using the values of those slots.\nWe call the slot with the serialization the s-slot, the slots used in the {}s are v-slots. If both s-slots and v-slots are populated on an object then the value of the s-slot should correspond to the expansion.\nImplementations of frameworks may choose to use this property to either (a) PARSE: implement automated normalizations by parsing denormalized strings into complex objects (b) GENERARE: implement automated to_string labeling of complex objects\nFor example, a Measurement class may have 3 fields: unit, value, and string_value. The string_value slot may have a string_serialization of {value}{unit} such that if unit=cm and value=2, the value of string_value shouldd be 2cm", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://github.com/linkml/issues/128" + ], + "domain": "Definition", + "slot_uri": "https://w3id.org/linkml/string_serialization", + "owner": "Definition", + "domain_of": [ + "Definition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "typeof", + "definition_uri": "https://w3id.org/linkml/typeof", + "description": "Names a parent type", + "comments": [ + "the target type definition of the typeof slot is referred to as the \"parent type\"", + "the type definition containing the typeof slot is referred to as the \"child type\"", + "type definitions without a typeof slot are referred to as a \"root type\"" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 7, + "domain": "TypeDefinition", + "slot_uri": "https://w3id.org/linkml/typeof", + "owner": "TypeDefinition", + "domain_of": [ + "TypeDefinition" + ], + "range": "TypeDefinition", + "@type": "SlotDefinition" + }, + { + "name": "base", + "definition_uri": "https://w3id.org/linkml/base", + "description": "python base type that implements this type definition", + "comments": [ + "every root type must have a base", + "the base is inherited by child types but may be overriden. Base compatibility is not checked." + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 8, + "domain": "TypeDefinition", + "slot_uri": "https://w3id.org/linkml/base", + "inherited": true, + "owner": "TypeDefinition", + "domain_of": [ + "TypeDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "type_uri", + "definition_uri": "https://w3id.org/linkml/type_uri", + "description": "The uri that defines the possible values for the type definition", + "comments": [ + "uri is typically drawn from the set of URI's defined in OWL (https://www.w3.org/TR/2012/REC-owl2-syntax-20121211/#Datatype_Maps)", + "every root type must have a type uri" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 2, + "domain": "TypeDefinition", + "slot_uri": "https://w3id.org/linkml/uri", + "inherited": true, + "alias": "uri", + "owner": "TypeDefinition", + "domain_of": [ + "TypeDefinition" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "repr", + "definition_uri": "https://w3id.org/linkml/repr", + "description": "the name of the python object that implements this type definition", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 10, + "domain": "TypeDefinition", + "slot_uri": "https://w3id.org/linkml/repr", + "inherited": true, + "owner": "TypeDefinition", + "domain_of": [ + "TypeDefinition" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "alt_description_text", + "definition_uri": "https://w3id.org/linkml/alt_description_text", + "description": "text of an attributed description", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "AltDescription", + "slot_uri": "https://w3id.org/linkml/description", + "alias": "description", + "owner": "AltDescription", + "domain_of": [ + "AltDescription" + ], + "range": "string", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "alt_description_source", + "definition_uri": "https://w3id.org/linkml/alt_description_source", + "description": "the source of an attributed description", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "AltDescription", + "slot_uri": "https://w3id.org/linkml/source", + "key": true, + "alias": "source", + "owner": "AltDescription", + "domain_of": [ + "AltDescription" + ], + "range": "string", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "alt_descriptions", + "definition_uri": "https://w3id.org/linkml/alt_descriptions", + "description": "A sourced alternative description for an element", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "alternate definitions" + ], + "domain": "Element", + "slot_uri": "https://w3id.org/linkml/alt_descriptions", + "multivalued": true, + "owner": "alt_descriptions", + "domain_of": [ + "CommonMetadata" + ], + "range": "AltDescription", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "value", + "definition_uri": "https://w3id.org/linkml/value", + "description": "example value", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#example" + ], + "domain": "Example", + "slot_uri": "http://www.w3.org/2004/02/skos/core#example", + "owner": "Example", + "domain_of": [ + "Example" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "value_description", + "definition_uri": "https://w3id.org/linkml/value_description", + "description": "description of what the value is doing", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Example", + "slot_uri": "https://w3id.org/linkml/description", + "alias": "description", + "owner": "Example", + "domain_of": [ + "Example" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "examples", + "definition_uri": "https://w3id.org/linkml/examples", + "description": "example usages of an element", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "close_mappings": [ + "https://vocab.org/vann/example" + ], + "singular_name": "example", + "domain": "Element", + "slot_uri": "https://w3id.org/linkml/examples", + "multivalued": true, + "owner": "examples", + "domain_of": [ + "CommonMetadata" + ], + "range": "Example", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "prefix_prefix", + "definition_uri": "https://w3id.org/linkml/prefix_prefix", + "description": "the nsname (sans ':' for a given prefix)", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "https://w3id.org/shacl/prefix" + ], + "rank": 1, + "domain": "Prefix", + "slot_uri": "https://w3id.org/shacl/prefix", + "key": true, + "owner": "Prefix", + "domain_of": [ + "Prefix" + ], + "range": "ncname", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "prefix_reference", + "definition_uri": "https://w3id.org/linkml/prefix_reference", + "description": "A URI associated with a given prefix", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "https://w3id.org/shacl/namespace" + ], + "rank": 2, + "domain": "Prefix", + "slot_uri": "https://w3id.org/shacl/namespace", + "owner": "Prefix", + "domain_of": [ + "Prefix" + ], + "range": "uri", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "prefixes", + "definition_uri": "https://w3id.org/linkml/prefixes", + "description": "prefix / URI definitions to be added to the context beyond those fetched from prefixcommons in id prefixes", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "https://w3id.org/shacl/declare" + ], + "rank": 10, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/shacl/declare", + "multivalued": true, + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "Prefix", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "setting_key", + "definition_uri": "https://w3id.org/linkml/setting_key", + "description": "the variable name for a setting", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Setting", + "slot_uri": "https://w3id.org/linkml/setting_key", + "key": true, + "owner": "Setting", + "domain_of": [ + "Setting" + ], + "range": "ncname", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "setting_value", + "definition_uri": "https://w3id.org/linkml/setting_value", + "description": "The value assigned for a setting", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Setting", + "slot_uri": "https://w3id.org/linkml/setting_value", + "owner": "Setting", + "domain_of": [ + "Setting" + ], + "range": "string", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "settings", + "definition_uri": "https://w3id.org/linkml/settings", + "description": "A collection of global variable settings", + "comments": [ + "global variables are used in string interpolation" + ], + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 20, + "domain": "SchemaDefinition", + "slot_uri": "https://w3id.org/linkml/settings", + "multivalued": true, + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "range": "Setting", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "import_from", + "definition_uri": "https://w3id.org/linkml/import_from", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "ImportExpression", + "slot_uri": "https://w3id.org/linkml/import_from", + "owner": "ImportExpression", + "domain_of": [ + "ImportExpression" + ], + "range": "uriorcurie", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "import_as", + "definition_uri": "https://w3id.org/linkml/import_as", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "ImportExpression", + "slot_uri": "https://w3id.org/linkml/import_as", + "owner": "ImportExpression", + "domain_of": [ + "ImportExpression" + ], + "range": "ncname", + "@type": "SlotDefinition" + }, + { + "name": "import_map", + "definition_uri": "https://w3id.org/linkml/import_map", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "ImportExpression", + "slot_uri": "https://w3id.org/linkml/import_map", + "multivalued": true, + "owner": "ImportExpression", + "domain_of": [ + "ImportExpression" + ], + "range": "Setting", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "local_name_source", + "definition_uri": "https://w3id.org/linkml/local_name_source", + "description": "the ncname of the source of the name", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "LocalName", + "slot_uri": "https://w3id.org/linkml/local_name_source", + "key": true, + "owner": "LocalName", + "domain_of": [ + "LocalName" + ], + "range": "ncname", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "local_name_value", + "definition_uri": "https://w3id.org/linkml/local_name_value", + "description": "a name assigned to an element in a given ontology", + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#altLabel" + ], + "domain": "LocalName", + "slot_uri": "http://www.w3.org/2004/02/skos/core#altLabel", + "owner": "LocalName", + "domain_of": [ + "LocalName" + ], + "range": "string", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "local_names", + "definition_uri": "https://w3id.org/linkml/local_names", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "Element", + "slot_uri": "https://w3id.org/linkml/local_names", + "multivalued": true, + "owner": "Element", + "domain_of": [ + "Element" + ], + "range": "LocalName", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "slot_group", + "definition_uri": "https://w3id.org/linkml/slot_group", + "description": "allows for grouping of related slots into a grouping slot that serves the role of a group", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "https://w3id.org/shacl/group" + ], + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/shacl/group", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "SlotDefinition", + "range_expression": { + "slot_conditions": [ + { + "name": "is_grouping_slot", + "equals_expression": "True", + "@type": "SlotDefinition" + } + ], + "@type": "AnonymousClassExpression" + }, + "@type": "SlotDefinition" + }, + { + "name": "is_grouping_slot", + "definition_uri": "https://w3id.org/linkml/is_grouping_slot", + "description": "true if this slot is a grouping slot", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "close_mappings": [ + "https://w3id.org/shacl/PropertyGroup" + ], + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/is_grouping_slot", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "followed_by", + "definition_uri": "https://w3id.org/linkml/followed_by", + "description": "in a sequential list, this indicates the next member", + "from_schema": "https://w3id.org/linkml/meta", + "slot_uri": "https://w3id.org/linkml/followed_by", + "owner": "PathExpression", + "domain_of": [ + "PathExpression" + ], + "range": "Expression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "reversed", + "definition_uri": "https://w3id.org/linkml/reversed", + "description": "true if the slot is to be inversed", + "from_schema": "https://w3id.org/linkml/meta", + "slot_uri": "https://w3id.org/linkml/reversed", + "owner": "PathExpression", + "domain_of": [ + "PathExpression" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "traverse", + "definition_uri": "https://w3id.org/linkml/traverse", + "description": "the slot to traverse", + "from_schema": "https://w3id.org/linkml/meta", + "slot_uri": "https://w3id.org/linkml/traverse", + "owner": "PathExpression", + "domain_of": [ + "PathExpression" + ], + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "path_rule", + "definition_uri": "https://w3id.org/linkml/path_rule", + "description": "a rule for inferring a slot assignment based on evaluating a path through a sequence of slot assignemnts", + "from_schema": "https://w3id.org/linkml/meta", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/path_rule", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "PathExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "represents_relationship", + "definition_uri": "https://w3id.org/linkml/represents_relationship", + "description": "true if this class represents a relationship rather than an entity", + "comments": [ + "in the context of Entity-Relationship (ER) modeling, this is used to state that a class models a relationship between entities, and should be drawn with a diamond", + "in the context of RDF, this should be used when instances of the class are `rdf:Statement`s", + "in the context of property graphs, this should be used when a class is used to represent an edge that connects nodes" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "rdf:Statement", + "https://patterns.dataincubator.org/book/qualified-relation.html" + ], + "aliases": [ + "is_reified" + ], + "status": "testing", + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/represents_relationship", + "inherited": true, + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "range": "boolean", + "@type": "SlotDefinition" + }, + { + "name": "relational_role", + "definition_uri": "https://w3id.org/linkml/relational_role", + "description": "the role a slot on a relationship class plays, for example, the subject, object or predicate roles", + "comments": [ + "this should only be used on slots that are applicable to class that represent relationships", + "in the context of RDF, this should be used for slots that can be modeled using the RDF reification vocabulary", + "in the context of property graphs, this should be used on edge classes to indicate which slots represent the input and output nodes" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "reification_role" + ], + "status": "testing", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/relational_role", + "inherited": true, + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "range": "relational_role_enum", + "@type": "SlotDefinition" + }, + { + "name": "mappings", + "definition_uri": "https://w3id.org/linkml/mappings", + "description": "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective.", + "from_schema": "https://w3id.org/linkml/mappings", + "imported_from": "linkml:mappings", + "aliases": [ + "xrefs", + "identifiers", + "alternate identifiers", + "alternate ids" + ], + "mappings": [ + "http://www.w3.org/2004/02/skos/core#mappingRelation" + ], + "slot_uri": "http://www.w3.org/2004/02/skos/core#mappingRelation", + "multivalued": true, + "owner": "CommonMetadata", + "domain_of": [ + "CommonMetadata" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "exact_mappings", + "definition_uri": "https://w3id.org/linkml/exact_mappings", + "description": "A list of terms from different schemas or terminology systems that have identical meaning.", + "from_schema": "https://w3id.org/linkml/mappings", + "imported_from": "linkml:mappings", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#exactMatch" + ], + "is_a": "mappings", + "slot_uri": "http://www.w3.org/2004/02/skos/core#exactMatch", + "multivalued": true, + "owner": "UnitOfMeasure", + "domain_of": [ + "CommonMetadata", + "UnitOfMeasure" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "close_mappings", + "definition_uri": "https://w3id.org/linkml/close_mappings", + "description": "A list of terms from different schemas or terminology systems that have close meaning.", + "from_schema": "https://w3id.org/linkml/mappings", + "imported_from": "linkml:mappings", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#closeMatch" + ], + "is_a": "mappings", + "slot_uri": "http://www.w3.org/2004/02/skos/core#closeMatch", + "multivalued": true, + "owner": "CommonMetadata", + "domain_of": [ + "CommonMetadata" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "related_mappings", + "definition_uri": "https://w3id.org/linkml/related_mappings", + "description": "A list of terms from different schemas or terminology systems that have related meaning.", + "from_schema": "https://w3id.org/linkml/mappings", + "imported_from": "linkml:mappings", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#relatedMatch" + ], + "is_a": "mappings", + "slot_uri": "http://www.w3.org/2004/02/skos/core#relatedMatch", + "multivalued": true, + "owner": "CommonMetadata", + "domain_of": [ + "CommonMetadata" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "narrow_mappings", + "definition_uri": "https://w3id.org/linkml/narrow_mappings", + "description": "A list of terms from different schemas or terminology systems that have narrower meaning.", + "from_schema": "https://w3id.org/linkml/mappings", + "imported_from": "linkml:mappings", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#narrowMatch" + ], + "is_a": "mappings", + "slot_uri": "http://www.w3.org/2004/02/skos/core#narrowMatch", + "multivalued": true, + "owner": "CommonMetadata", + "domain_of": [ + "CommonMetadata" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "broad_mappings", + "definition_uri": "https://w3id.org/linkml/broad_mappings", + "description": "A list of terms from different schemas or terminology systems that have broader meaning.", + "from_schema": "https://w3id.org/linkml/mappings", + "imported_from": "linkml:mappings", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#broadMatch" + ], + "is_a": "mappings", + "slot_uri": "http://www.w3.org/2004/02/skos/core#broadMatch", + "multivalued": true, + "owner": "CommonMetadata", + "domain_of": [ + "CommonMetadata" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "deprecated_element_has_exact_replacement", + "definition_uri": "https://w3id.org/linkml/deprecated_element_has_exact_replacement", + "description": "When an element is deprecated, it can be automatically replaced by this uri or curie", + "from_schema": "https://w3id.org/linkml/mappings", + "imported_from": "linkml:mappings", + "mappings": [ + "http://purl.obolibrary.org/obo/IAO_0100001" + ], + "slot_uri": "https://w3id.org/linkml/deprecated_element_has_exact_replacement", + "owner": "CommonMetadata", + "domain_of": [ + "CommonMetadata" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "deprecated_element_has_possible_replacement", + "definition_uri": "https://w3id.org/linkml/deprecated_element_has_possible_replacement", + "description": "When an element is deprecated, it can be potentially replaced by this uri or curie", + "from_schema": "https://w3id.org/linkml/mappings", + "imported_from": "linkml:mappings", + "mappings": [ + "http://www.geneontology.org/formats/oboInOwl#consider" + ], + "slot_uri": "https://w3id.org/linkml/deprecated_element_has_possible_replacement", + "owner": "CommonMetadata", + "domain_of": [ + "CommonMetadata" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "extensions", + "definition_uri": "https://w3id.org/linkml/extensions", + "description": "a tag/text tuple attached to an arbitrary element", + "from_schema": "https://w3id.org/linkml/extensions", + "imported_from": "linkml:extensions", + "domain": "Extensible", + "slot_uri": "https://w3id.org/linkml/extensions", + "multivalued": true, + "owner": "Extensible", + "domain_of": [ + "Extension", + "Extensible" + ], + "range": "Extension", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "extension_tag", + "definition_uri": "https://w3id.org/linkml/extension_tag", + "description": "a tag associated with an extension", + "from_schema": "https://w3id.org/linkml/extensions", + "imported_from": "linkml:extensions", + "domain": "Extension", + "slot_uri": "https://w3id.org/linkml/tag", + "key": true, + "alias": "tag", + "owner": "Extension", + "domain_of": [ + "Extension" + ], + "range": "uriorcurie", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "extension_value", + "definition_uri": "https://w3id.org/linkml/extension_value", + "description": "the actual annotation", + "from_schema": "https://w3id.org/linkml/extensions", + "imported_from": "linkml:extensions", + "domain": "Extension", + "slot_uri": "https://w3id.org/linkml/value", + "alias": "value", + "owner": "Extension", + "domain_of": [ + "Extension" + ], + "range": "string", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "annotations", + "definition_uri": "https://w3id.org/linkml/annotations", + "description": "a collection of tag/text tuples with the semantics of OWL Annotation", + "from_schema": "https://w3id.org/linkml/annotations", + "imported_from": "linkml:annotations", + "is_a": "extensions", + "domain": "Annotatable", + "slot_uri": "https://w3id.org/linkml/annotations", + "multivalued": true, + "owner": "Annotation", + "domain_of": [ + "Annotatable", + "Annotation" + ], + "range": "Annotation", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "unit", + "definition_uri": "https://w3id.org/linkml/unit", + "description": "an encoding of a unit", + "from_schema": "https://w3id.org/linkml/units", + "imported_from": "linkml:units", + "mappings": [ + "http://qudt.org/schema/qudt/unit" + ], + "slot_uri": "http://qudt.org/schema/qudt/unit", + "owner": "PermissibleValue", + "domain_of": [ + "TypeExpression", + "SlotExpression", + "PermissibleValue" + ], + "range": "UnitOfMeasure", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "ucum_code", + "definition_uri": "https://w3id.org/linkml/ucum_code", + "description": "associates a QUDT unit with its UCUM code (case-sensitive).", + "from_schema": "https://w3id.org/linkml/units", + "imported_from": "linkml:units", + "mappings": [ + "http://qudt.org/schema/qudt/ucumCode" + ], + "domain": "UnitOfMeasure", + "slot_uri": "http://qudt.org/schema/qudt/ucumCode", + "owner": "UnitOfMeasure", + "domain_of": [ + "UnitOfMeasure" + ], + "range": "string", + "recommended": true, + "@type": "SlotDefinition" + }, + { + "name": "derivation", + "definition_uri": "https://w3id.org/linkml/derivation", + "description": "Expression for deriving this unit from other units", + "from_schema": "https://w3id.org/linkml/units", + "imported_from": "linkml:units", + "slot_uri": "https://w3id.org/linkml/derivation", + "owner": "UnitOfMeasure", + "domain_of": [ + "UnitOfMeasure" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "has_quantity_kind", + "definition_uri": "https://w3id.org/linkml/has_quantity_kind", + "description": "Concept in a vocabulary or ontology that denotes the kind of quanity being measured, e.g. length", + "comments": [ + "Potential ontologies include but are not limited to PATO, NCIT, OBOE, qudt.quantityKind" + ], + "from_schema": "https://w3id.org/linkml/units", + "imported_from": "linkml:units", + "mappings": [ + "http://qudt.org/schema/qudt/hasQuantityKind" + ], + "slot_uri": "http://qudt.org/schema/qudt/hasQuantityKind", + "owner": "UnitOfMeasure", + "domain_of": [ + "UnitOfMeasure" + ], + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "iec61360code", + "definition_uri": "https://w3id.org/linkml/iec61360code", + "from_schema": "https://w3id.org/linkml/units", + "imported_from": "linkml:units", + "mappings": [ + "http://qudt.org/schema/qudt/iec61360Code" + ], + "slot_uri": "http://qudt.org/schema/qudt/iec61360Code", + "owner": "UnitOfMeasure", + "domain_of": [ + "UnitOfMeasure" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "symbol", + "definition_uri": "https://w3id.org/linkml/symbol", + "description": "name of the unit encoded as a symbol", + "from_schema": "https://w3id.org/linkml/units", + "imported_from": "linkml:units", + "mappings": [ + "http://qudt.org/schema/qudt/symbol" + ], + "slot_uri": "http://qudt.org/schema/qudt/symbol", + "owner": "UnitOfMeasure", + "domain_of": [ + "UnitOfMeasure" + ], + "range": "string", + "@type": "SlotDefinition" + }, + { + "name": "schema_definition_name", + "definition_uri": "https://w3id.org/linkml/name", + "description": "a unique name for the schema that is both human-readable and consists of only characters from the NCName set", + "in_subset": [ + "SpecificationSubset", + "OwlProfile", + "MinimalSubset", + "BasicSubset", + "RelationalModelProfile", + "ObjectOrientedProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Data_element_name" + ], + "aliases": [ + "short name", + "unique name" + ], + "mappings": [ + "http://www.w3.org/2000/01/rdf-schema#label" + ], + "exact_mappings": [ + "http://schema.org/name" + ], + "rank": 1, + "is_a": "name", + "domain": "SchemaDefinition", + "slot_uri": "http://www.w3.org/2000/01/rdf-schema#label", + "identifier": true, + "alias": "name", + "owner": "SchemaDefinition", + "domain_of": [ + "SchemaDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "name", + "range": "ncname", + "required": true, + "@type": "SlotDefinition" + }, + { + "name": "type_expression_any_of", + "definition_uri": "https://w3id.org/linkml/any_of", + "description": "holds if at least one of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/or" + ], + "rank": 101, + "is_a": "any_of", + "domain": "TypeExpression", + "slot_uri": "https://w3id.org/linkml/any_of", + "multivalued": true, + "alias": "any_of", + "owner": "TypeExpression", + "domain_of": [ + "TypeExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "any_of", + "range": "AnonymousTypeExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "type_expression_all_of", + "definition_uri": "https://w3id.org/linkml/all_of", + "description": "holds if all of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/and" + ], + "rank": 107, + "is_a": "all_of", + "domain": "TypeExpression", + "slot_uri": "https://w3id.org/linkml/all_of", + "multivalued": true, + "alias": "all_of", + "owner": "TypeExpression", + "domain_of": [ + "TypeExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "all_of", + "range": "AnonymousTypeExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "type_expression_exactly_one_of", + "definition_uri": "https://w3id.org/linkml/exactly_one_of", + "description": "holds if only one of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/xone" + ], + "rank": 103, + "is_a": "exactly_one_of", + "domain": "TypeExpression", + "slot_uri": "https://w3id.org/linkml/exactly_one_of", + "multivalued": true, + "alias": "exactly_one_of", + "owner": "TypeExpression", + "domain_of": [ + "TypeExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "exactly_one_of", + "range": "AnonymousTypeExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "type_expression_none_of", + "definition_uri": "https://w3id.org/linkml/none_of", + "description": "holds if none of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/not" + ], + "rank": 105, + "is_a": "none_of", + "domain": "TypeExpression", + "slot_uri": "https://w3id.org/linkml/none_of", + "multivalued": true, + "alias": "none_of", + "owner": "TypeExpression", + "domain_of": [ + "TypeExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "none_of", + "range": "AnonymousTypeExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "type_definition_union_of", + "definition_uri": "https://w3id.org/linkml/union_of", + "description": "indicates that the domain element consists exactly of the members of the element in the range.", + "notes": [ + "this only applies in the OWL generation" + ], + "in_subset": [ + "SpecificationSubset", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "union_of", + "domain": "TypeDefinition", + "slot_uri": "https://w3id.org/linkml/union_of", + "multivalued": true, + "alias": "union_of", + "owner": "TypeDefinition", + "domain_of": [ + "TypeDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "union_of", + "range": "TypeDefinition", + "@type": "SlotDefinition" + }, + { + "name": "structured_alias_categories", + "definition_uri": "https://w3id.org/linkml/categories", + "description": "The category or categories of an alias. This can be drawn from any relevant vocabulary", + "examples": [ + { + "value": "https://w3id.org/mod#acronym", + "description": "An acronym", + "@type": "Example" + } + ], + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "http://purl.org/dc/terms/subject" + ], + "is_a": "categories", + "singular_name": "category", + "domain": "StructuredAlias", + "slot_uri": "http://purl.org/dc/terms/subject", + "multivalued": true, + "alias": "categories", + "owner": "StructuredAlias", + "domain_of": [ + "StructuredAlias" + ], + "is_usage_slot": true, + "usage_slot_name": "categories", + "range": "uriorcurie", + "@type": "SlotDefinition" + }, + { + "name": "path_expression_followed_by", + "definition_uri": "https://w3id.org/linkml/followed_by", + "description": "in a sequential list, this indicates the next member", + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "followed_by", + "domain": "PathExpression", + "slot_uri": "https://w3id.org/linkml/followed_by", + "alias": "followed_by", + "owner": "PathExpression", + "domain_of": [ + "PathExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "followed_by", + "range": "PathExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "path_expression_any_of", + "definition_uri": "https://w3id.org/linkml/any_of", + "description": "holds if at least one of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/or" + ], + "rank": 101, + "is_a": "any_of", + "domain": "PathExpression", + "slot_uri": "https://w3id.org/linkml/any_of", + "multivalued": true, + "alias": "any_of", + "owner": "PathExpression", + "domain_of": [ + "PathExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "any_of", + "range": "PathExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "path_expression_exactly_one_of", + "definition_uri": "https://w3id.org/linkml/exactly_one_of", + "description": "holds if only one of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/xone" + ], + "rank": 103, + "is_a": "exactly_one_of", + "domain": "PathExpression", + "slot_uri": "https://w3id.org/linkml/exactly_one_of", + "multivalued": true, + "alias": "exactly_one_of", + "owner": "PathExpression", + "domain_of": [ + "PathExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "exactly_one_of", + "range": "PathExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "path_expression_none_of", + "definition_uri": "https://w3id.org/linkml/none_of", + "description": "holds if none of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/not" + ], + "rank": 105, + "is_a": "none_of", + "domain": "PathExpression", + "slot_uri": "https://w3id.org/linkml/none_of", + "multivalued": true, + "alias": "none_of", + "owner": "PathExpression", + "domain_of": [ + "PathExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "none_of", + "range": "PathExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "path_expression_all_of", + "definition_uri": "https://w3id.org/linkml/all_of", + "description": "holds if all of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/and" + ], + "rank": 107, + "is_a": "all_of", + "domain": "PathExpression", + "slot_uri": "https://w3id.org/linkml/all_of", + "multivalued": true, + "alias": "all_of", + "owner": "PathExpression", + "domain_of": [ + "PathExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "all_of", + "range": "PathExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "slot_expression_any_of", + "definition_uri": "https://w3id.org/linkml/any_of", + "description": "holds if at least one of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/or" + ], + "rank": 101, + "is_a": "any_of", + "domain": "SlotExpression", + "slot_uri": "https://w3id.org/linkml/any_of", + "multivalued": true, + "alias": "any_of", + "owner": "SlotExpression", + "domain_of": [ + "SlotExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "any_of", + "range": "AnonymousSlotExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "slot_expression_all_of", + "definition_uri": "https://w3id.org/linkml/all_of", + "description": "holds if all of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/and" + ], + "rank": 107, + "is_a": "all_of", + "domain": "SlotExpression", + "slot_uri": "https://w3id.org/linkml/all_of", + "multivalued": true, + "alias": "all_of", + "owner": "SlotExpression", + "domain_of": [ + "SlotExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "all_of", + "range": "AnonymousSlotExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "slot_expression_exactly_one_of", + "definition_uri": "https://w3id.org/linkml/exactly_one_of", + "description": "holds if only one of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/xone" + ], + "rank": 103, + "is_a": "exactly_one_of", + "domain": "SlotExpression", + "slot_uri": "https://w3id.org/linkml/exactly_one_of", + "multivalued": true, + "alias": "exactly_one_of", + "owner": "SlotExpression", + "domain_of": [ + "SlotExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "exactly_one_of", + "range": "AnonymousSlotExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "slot_expression_none_of", + "definition_uri": "https://w3id.org/linkml/none_of", + "description": "holds if none of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/not" + ], + "rank": 105, + "is_a": "none_of", + "domain": "SlotExpression", + "slot_uri": "https://w3id.org/linkml/none_of", + "multivalued": true, + "alias": "none_of", + "owner": "SlotExpression", + "domain_of": [ + "SlotExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "none_of", + "range": "AnonymousSlotExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "slot_definition_is_a", + "definition_uri": "https://w3id.org/linkml/is_a", + "description": "A primary parent slot from which inheritable metaslots are propagated", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 11, + "is_a": "is_a", + "abstract": true, + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/is_a", + "alias": "is_a", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "is_a", + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "slot_definition_mixins", + "definition_uri": "https://w3id.org/linkml/mixins", + "description": "A collection of secondary parent mixin slots from which inheritable metaslots are propagated", + "comments": [ + "mixins act in the same way as parents (is_a). They allow a model to have a primary strict hierachy, while keeping the benefits of multiple inheritance" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Mixin" + ], + "aliases": [ + "traits" + ], + "rank": 13, + "is_a": "mixins", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/mixins", + "multivalued": true, + "alias": "mixins", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "mixins", + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "slot_definition_apply_to", + "definition_uri": "https://w3id.org/linkml/apply_to", + "description": "Used to extend class or slot definitions. For example, if we have a core schema where a gene has two slots for identifier and symbol, and we have a specialized schema for my_organism where we wish to add a slot systematic_name, we can avoid subclassing by defining a class gene_my_organism, adding the slot to this class, and then adding an apply_to pointing to the gene class. The new slot will be 'injected into' the gene class.", + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "apply_to", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/apply_to", + "multivalued": true, + "alias": "apply_to", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "apply_to", + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "slot_definition_disjoint_with", + "definition_uri": "https://w3id.org/linkml/disjoint_with", + "description": "Two classes are disjoint if they have no instances in common, two slots are disjoint if they can never hold between the same two instances", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "disjoint_with", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/disjoint_with", + "multivalued": true, + "alias": "disjoint_with", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "disjoint_with", + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "slot_definition_union_of", + "definition_uri": "https://w3id.org/linkml/union_of", + "description": "indicates that the domain element consists exactly of the members of the element in the range.", + "notes": [ + "this only applies in the OWL generation" + ], + "in_subset": [ + "SpecificationSubset", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "union_of", + "domain": "SlotDefinition", + "slot_uri": "https://w3id.org/linkml/union_of", + "multivalued": true, + "alias": "union_of", + "owner": "SlotDefinition", + "domain_of": [ + "SlotDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "union_of", + "range": "SlotDefinition", + "@type": "SlotDefinition" + }, + { + "name": "class_expression_any_of", + "definition_uri": "https://w3id.org/linkml/any_of", + "description": "holds if at least one of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/or" + ], + "rank": 101, + "is_a": "any_of", + "domain": "ClassExpression", + "slot_uri": "https://w3id.org/linkml/any_of", + "multivalued": true, + "alias": "any_of", + "owner": "ClassExpression", + "domain_of": [ + "ClassExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "any_of", + "range": "AnonymousClassExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "class_expression_all_of", + "definition_uri": "https://w3id.org/linkml/all_of", + "description": "holds if all of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/and" + ], + "rank": 107, + "is_a": "all_of", + "domain": "ClassExpression", + "slot_uri": "https://w3id.org/linkml/all_of", + "multivalued": true, + "alias": "all_of", + "owner": "ClassExpression", + "domain_of": [ + "ClassExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "all_of", + "range": "AnonymousClassExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "class_expression_exactly_one_of", + "definition_uri": "https://w3id.org/linkml/exactly_one_of", + "description": "holds if only one of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/xone" + ], + "rank": 103, + "is_a": "exactly_one_of", + "domain": "ClassExpression", + "slot_uri": "https://w3id.org/linkml/exactly_one_of", + "multivalued": true, + "alias": "exactly_one_of", + "owner": "ClassExpression", + "domain_of": [ + "ClassExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "exactly_one_of", + "range": "AnonymousClassExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "class_expression_none_of", + "definition_uri": "https://w3id.org/linkml/none_of", + "description": "holds if none of the expressions hold", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "exact_mappings": [ + "https://w3id.org/shacl/not" + ], + "rank": 105, + "is_a": "none_of", + "domain": "ClassExpression", + "slot_uri": "https://w3id.org/linkml/none_of", + "multivalued": true, + "alias": "none_of", + "owner": "ClassExpression", + "domain_of": [ + "ClassExpression" + ], + "is_usage_slot": true, + "usage_slot_name": "none_of", + "range": "AnonymousClassExpression", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "class_definition_is_a", + "definition_uri": "https://w3id.org/linkml/is_a", + "description": "A primary parent class from which inheritable metaslots are propagated", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 11, + "is_a": "is_a", + "abstract": true, + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/is_a", + "alias": "is_a", + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "is_a", + "range": "ClassDefinition", + "@type": "SlotDefinition" + }, + { + "name": "class_definition_mixins", + "definition_uri": "https://w3id.org/linkml/mixins", + "description": "A collection of secondary parent mixin classes from which inheritable metaslots are propagated", + "comments": [ + "mixins act in the same way as parents (is_a). They allow a model to have a primary strict hierachy, while keeping the benefits of multiple inheritance" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Mixin" + ], + "aliases": [ + "traits" + ], + "rank": 13, + "is_a": "mixins", + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/mixins", + "multivalued": true, + "alias": "mixins", + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "mixins", + "range": "ClassDefinition", + "@type": "SlotDefinition" + }, + { + "name": "class_definition_apply_to", + "definition_uri": "https://w3id.org/linkml/apply_to", + "description": "Used to extend class or slot definitions. For example, if we have a core schema where a gene has two slots for identifier and symbol, and we have a specialized schema for my_organism where we wish to add a slot systematic_name, we can avoid subclassing by defining a class gene_my_organism, adding the slot to this class, and then adding an apply_to pointing to the gene class. The new slot will be 'injected into' the gene class.", + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "apply_to", + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/apply_to", + "multivalued": true, + "alias": "apply_to", + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "apply_to", + "range": "ClassDefinition", + "@type": "SlotDefinition" + }, + { + "name": "class_definition_rules", + "definition_uri": "https://w3id.org/linkml/rules", + "description": "the collection of rules that apply to all members of this class", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "https://w3id.org/shacl/rule" + ], + "is_a": "rules", + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/shacl/rule", + "multivalued": true, + "alias": "rules", + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "rules", + "range": "ClassRule", + "inlined": true, + "@type": "SlotDefinition" + }, + { + "name": "class_definition_disjoint_with", + "definition_uri": "https://w3id.org/linkml/disjoint_with", + "description": "Two classes are disjoint if they have no instances in common, two slots are disjoint if they can never hold between the same two instances", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "disjoint_with", + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/disjoint_with", + "multivalued": true, + "alias": "disjoint_with", + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "disjoint_with", + "range": "ClassDefinition", + "@type": "SlotDefinition" + }, + { + "name": "class_definition_union_of", + "definition_uri": "https://w3id.org/linkml/union_of", + "description": "indicates that the domain element consists exactly of the members of the element in the range.", + "notes": [ + "this only applies in the OWL generation" + ], + "in_subset": [ + "SpecificationSubset", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "union_of", + "domain": "ClassDefinition", + "slot_uri": "https://w3id.org/linkml/union_of", + "multivalued": true, + "alias": "union_of", + "owner": "ClassDefinition", + "domain_of": [ + "ClassDefinition" + ], + "is_usage_slot": true, + "usage_slot_name": "union_of", + "range": "ClassDefinition", + "@type": "SlotDefinition" + }, + { + "name": "permissible_value_is_a", + "definition_uri": "https://w3id.org/linkml/is_a", + "description": "A primary parent class or slot from which inheritable metaslots are propagated from. While multiple inheritance is not allowed, mixins can be provided effectively providing the same thing. The semantics are the same when translated to formalisms that allow MI (e.g. RDFS/OWL). When translating to a SI framework (e.g. java classes, python classes) then is a is used. When translating a framework without polymorphism (e.g. json-schema, solr document schema) then is a and mixins are recursively unfolded", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 11, + "is_a": "is_a", + "abstract": true, + "domain": "PermissibleValue", + "slot_uri": "https://w3id.org/linkml/is_a", + "alias": "is_a", + "owner": "PermissibleValue", + "domain_of": [ + "PermissibleValue" + ], + "is_usage_slot": true, + "usage_slot_name": "is_a", + "range": "PermissibleValue", + "@type": "SlotDefinition" + }, + { + "name": "permissible_value_mixins", + "definition_uri": "https://w3id.org/linkml/mixins", + "description": "A collection of secondary parent classes or slots from which inheritable metaslots are propagated from.", + "comments": [ + "mixins act in the same way as parents (is_a). They allow a model to have a primary strict hierachy, while keeping the benefits of multiple inheritance" + ], + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Mixin" + ], + "aliases": [ + "traits" + ], + "rank": 13, + "is_a": "mixins", + "domain": "PermissibleValue", + "slot_uri": "https://w3id.org/linkml/mixins", + "multivalued": true, + "alias": "mixins", + "owner": "PermissibleValue", + "domain_of": [ + "PermissibleValue" + ], + "is_usage_slot": true, + "usage_slot_name": "mixins", + "range": "PermissibleValue", + "@type": "SlotDefinition" + }, + { + "name": "UnitOfMeasure_exact_mappings", + "definition_uri": "https://w3id.org/linkml/exact_mappings", + "description": "Used to link a unit to equivalent concepts in ontologies such as UO, SNOMED, OEM, OBOE, NCIT", + "comments": [ + "Do not use this to encode mappings to systems for which a dedicated field exists" + ], + "from_schema": "https://w3id.org/linkml/mappings", + "imported_from": "linkml:units", + "mappings": [ + "http://www.w3.org/2004/02/skos/core#exactMatch" + ], + "is_a": "exact_mappings", + "domain": "UnitOfMeasure", + "slot_uri": "http://www.w3.org/2004/02/skos/core#exactMatch", + "multivalued": true, + "alias": "exact mappings", + "owner": "UnitOfMeasure", + "domain_of": [ + "UnitOfMeasure" + ], + "is_usage_slot": true, + "usage_slot_name": "exact mappings", + "range": "uriorcurie", + "@type": "SlotDefinition" + } + ], + "classes": [ + { + "name": "CommonMetadata", + "definition_uri": "https://w3id.org/linkml/CommonMetadata", + "description": "Generic metadata shared across definitions", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "mixin": true, + "slots": [ + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/CommonMetadata", + "@type": "ClassDefinition" + }, + { + "name": "Element", + "definition_uri": "https://w3id.org/linkml/Element", + "description": "a named element in the model", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Data_element" + ], + "aliases": [ + "data element", + "object" + ], + "abstract": true, + "mixins": [ + "Extensible", + "Annotatable", + "CommonMetadata" + ], + "slots": [ + "name", + "id_prefixes", + "definition_uri", + "local_names", + "conforms_to", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/Element", + "@type": "ClassDefinition" + }, + { + "name": "SchemaDefinition", + "definition_uri": "https://w3id.org/linkml/SchemaDefinition", + "description": "a collection of subset, type, slot and class definitions", + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset", + "RelationalModelProfile", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Data_dictionary" + ], + "aliases": [ + "data dictionary" + ], + "close_mappings": [ + "qb:ComponentSet" + ], + "rank": 1, + "is_a": "Element", + "slots": [ + "id_prefixes", + "definition_uri", + "local_names", + "conforms_to", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank", + "id", + "version", + "imports", + "license", + "prefixes", + "emit_prefixes", + "default_curi_maps", + "default_prefix", + "default_range", + "subsets", + "types", + "enums", + "slot_definitions", + "classes", + "metamodel_version", + "source_file", + "source_file_date", + "source_file_size", + "generation_date", + "slot_names_unique", + "settings", + "categories", + "keywords", + "schema_definition_name" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/SchemaDefinition", + "tree_root": true, + "@type": "ClassDefinition" + }, + { + "name": "TypeExpression", + "definition_uri": "https://w3id.org/linkml/TypeExpression", + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "Expression", + "mixin": true, + "slots": [ + "pattern", + "structured_pattern", + "unit", + "implicit_prefix", + "equals_string", + "equals_string_in", + "equals_number", + "minimum_value", + "maximum_value", + "type_expression_none_of", + "type_expression_exactly_one_of", + "type_expression_any_of", + "type_expression_all_of" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/TypeExpression", + "@type": "ClassDefinition" + }, + { + "name": "AnonymousTypeExpression", + "definition_uri": "https://w3id.org/linkml/AnonymousTypeExpression", + "from_schema": "https://w3id.org/linkml/meta", + "mixins": [ + "TypeExpression" + ], + "slots": [ + "pattern", + "structured_pattern", + "unit", + "implicit_prefix", + "equals_string", + "equals_string_in", + "equals_number", + "minimum_value", + "maximum_value", + "type_expression_none_of", + "type_expression_exactly_one_of", + "type_expression_any_of", + "type_expression_all_of" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/AnonymousTypeExpression", + "@type": "ClassDefinition" + }, + { + "name": "TypeDefinition", + "definition_uri": "https://w3id.org/linkml/TypeDefinition", + "description": "an element that whose instances are atomic scalar values that can be mapped to primitive types", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 4, + "is_a": "Element", + "mixins": [ + "TypeExpression" + ], + "slots": [ + "name", + "id_prefixes", + "definition_uri", + "local_names", + "conforms_to", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank", + "typeof", + "base", + "type_uri", + "repr", + "type_definition_union_of", + "pattern", + "structured_pattern", + "unit", + "implicit_prefix", + "equals_string", + "equals_string_in", + "equals_number", + "minimum_value", + "maximum_value", + "type_expression_none_of", + "type_expression_exactly_one_of", + "type_expression_any_of", + "type_expression_all_of" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/TypeDefinition", + "@type": "ClassDefinition" + }, + { + "name": "SubsetDefinition", + "definition_uri": "https://w3id.org/linkml/SubsetDefinition", + "description": "an element that can be used to group other metamodel elements", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 6, + "is_a": "Element", + "slots": [ + "name", + "id_prefixes", + "definition_uri", + "local_names", + "conforms_to", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/SubsetDefinition", + "@type": "ClassDefinition" + }, + { + "name": "Definition", + "definition_uri": "https://w3id.org/linkml/Definition", + "description": "abstract base class for core metaclasses", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "see_also": [ + "https://en.wikipedia.org/wiki/Data_element_definition" + ], + "is_a": "Element", + "abstract": true, + "slots": [ + "name", + "id_prefixes", + "definition_uri", + "local_names", + "conforms_to", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank", + "is_a", + "abstract", + "mixin", + "mixins", + "apply_to", + "values_from", + "created_by", + "created_on", + "last_updated_on", + "modified_by", + "status", + "string_serialization" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/Definition", + "@type": "ClassDefinition" + }, + { + "name": "EnumExpression", + "definition_uri": "https://w3id.org/linkml/EnumExpression", + "description": "An expression that constrains the range of a slot", + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "Expression", + "slots": [ + "code_set", + "code_set_tag", + "code_set_version", + "pv_formula", + "permissible_values", + "include", + "minus", + "inherits", + "reachable_from", + "matches", + "concepts" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/EnumExpression", + "@type": "ClassDefinition" + }, + { + "name": "AnonymousEnumExpression", + "definition_uri": "https://w3id.org/linkml/AnonymousEnumExpression", + "description": "An enum_expression that is not named", + "from_schema": "https://w3id.org/linkml/meta", + "mixins": [ + "EnumExpression" + ], + "slots": [ + "code_set", + "code_set_tag", + "code_set_version", + "pv_formula", + "permissible_values", + "include", + "minus", + "inherits", + "reachable_from", + "matches", + "concepts" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/AnonymousEnumExpression", + "@type": "ClassDefinition" + }, + { + "name": "EnumDefinition", + "definition_uri": "https://w3id.org/linkml/EnumDefinition", + "description": "an element whose instances must be drawn from a specified set of permissible values", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "RelationalModelProfile", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "enum", + "value set", + "term set", + "Terminology Value Set" + ], + "exact_mappings": [ + "qb:HierarchicalCodeList", + "NCIT:C113497" + ], + "close_mappings": [ + "skos:ConceptScheme" + ], + "rank": 5, + "is_a": "Definition", + "mixins": [ + "EnumExpression" + ], + "slots": [ + "name", + "id_prefixes", + "definition_uri", + "local_names", + "conforms_to", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank", + "is_a", + "abstract", + "mixin", + "mixins", + "apply_to", + "values_from", + "created_by", + "created_on", + "last_updated_on", + "modified_by", + "status", + "string_serialization", + "enum_uri", + "code_set", + "code_set_tag", + "code_set_version", + "pv_formula", + "permissible_values", + "include", + "minus", + "inherits", + "reachable_from", + "matches", + "concepts" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/EnumDefinition", + "@type": "ClassDefinition" + }, + { + "name": "MatchQuery", + "definition_uri": "https://w3id.org/linkml/MatchQuery", + "description": "A query that is used on an enum expression to dynamically obtain a set of permissivle values via a query that matches on properties of the external concepts", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "slots": [ + "identifier_pattern", + "source_ontology" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/MatchQuery", + "@type": "ClassDefinition" + }, + { + "name": "ReachabilityQuery", + "definition_uri": "https://w3id.org/linkml/ReachabilityQuery", + "description": "A query that is used on an enum expression to dynamically obtain a set of permissible values via walking from a set of source nodes to a set of descendants or ancestors over a set of relationship types", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "slots": [ + "source_ontology", + "source_nodes", + "relationship_types", + "is_direct", + "include_self", + "traverse_up" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/ReachabilityQuery", + "@type": "ClassDefinition" + }, + { + "name": "StructuredAlias", + "definition_uri": "https://w3id.org/linkml/StructuredAlias", + "description": "object that contains meta data about a synonym or alias including where it came from (source) and its scope (narrow, broad, etc.)", + "from_schema": "https://w3id.org/linkml/meta", + "mappings": [ + "skosxl:Label" + ], + "mixins": [ + "Expression", + "Extensible", + "Annotatable", + "CommonMetadata" + ], + "slots": [ + "literal_form", + "alias_predicate", + "structured_alias_categories", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank" + ], + "slot_usage": {}, + "class_uri": "http://www.w3.org/2008/05/skos-xl#Label", + "@type": "ClassDefinition" + }, + { + "name": "Expression", + "definition_uri": "https://w3id.org/linkml/Expression", + "description": "general mixin for any class that can represent some form of expression", + "from_schema": "https://w3id.org/linkml/meta", + "abstract": true, + "mixin": true, + "status": "testing", + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/Expression", + "@type": "ClassDefinition" + }, + { + "name": "AnonymousExpression", + "definition_uri": "https://w3id.org/linkml/AnonymousExpression", + "from_schema": "https://w3id.org/linkml/meta", + "abstract": true, + "mixins": [ + "Expression", + "Extensible", + "Annotatable", + "CommonMetadata" + ], + "status": "testing", + "slots": [ + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/AnonymousExpression", + "@type": "ClassDefinition" + }, + { + "name": "PathExpression", + "definition_uri": "https://w3id.org/linkml/PathExpression", + "description": "An expression that describes an abstract path from an object to another through a sequence of slot lookups", + "from_schema": "https://w3id.org/linkml/meta", + "mixins": [ + "Expression", + "Extensible", + "Annotatable", + "CommonMetadata" + ], + "status": "testing", + "slots": [ + "path_expression_followed_by", + "path_expression_none_of", + "path_expression_any_of", + "path_expression_all_of", + "path_expression_exactly_one_of", + "reversed", + "traverse", + "range_expression", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/PathExpression", + "@type": "ClassDefinition" + }, + { + "name": "SlotExpression", + "definition_uri": "https://w3id.org/linkml/SlotExpression", + "description": "an expression that constrains the range of values a slot can take", + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "Expression", + "mixin": true, + "status": "testing", + "slots": [ + "range", + "range_expression", + "enum_range", + "required", + "recommended", + "inlined", + "inlined_as_list", + "minimum_value", + "maximum_value", + "pattern", + "structured_pattern", + "unit", + "implicit_prefix", + "value_presence", + "equals_string", + "equals_string_in", + "equals_number", + "equals_expression", + "minimum_cardinality", + "maximum_cardinality", + "has_member", + "all_members", + "slot_expression_none_of", + "slot_expression_exactly_one_of", + "slot_expression_any_of", + "slot_expression_all_of" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/SlotExpression", + "@type": "ClassDefinition" + }, + { + "name": "AnonymousSlotExpression", + "definition_uri": "https://w3id.org/linkml/AnonymousSlotExpression", + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "AnonymousExpression", + "mixins": [ + "SlotExpression" + ], + "status": "testing", + "slots": [ + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank", + "range", + "range_expression", + "enum_range", + "required", + "recommended", + "inlined", + "inlined_as_list", + "minimum_value", + "maximum_value", + "pattern", + "structured_pattern", + "unit", + "implicit_prefix", + "value_presence", + "equals_string", + "equals_string_in", + "equals_number", + "equals_expression", + "minimum_cardinality", + "maximum_cardinality", + "has_member", + "all_members", + "slot_expression_none_of", + "slot_expression_exactly_one_of", + "slot_expression_any_of", + "slot_expression_all_of" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/AnonymousSlotExpression", + "@type": "ClassDefinition" + }, + { + "name": "SlotDefinition", + "definition_uri": "https://w3id.org/linkml/SlotDefinition", + "description": "an element that describes how instances are related to other instances", + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "slot", + "field", + "property", + "attribute", + "column", + "variable" + ], + "close_mappings": [ + "rdf:Property", + "qb:ComponentProperty" + ], + "rank": 3, + "is_a": "Definition", + "mixins": [ + "SlotExpression" + ], + "slots": [ + "name", + "id_prefixes", + "definition_uri", + "local_names", + "conforms_to", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank", + "abstract", + "mixin", + "values_from", + "created_by", + "created_on", + "last_updated_on", + "modified_by", + "status", + "string_serialization", + "singular_name", + "domain", + "slot_uri", + "multivalued", + "inherited", + "readonly", + "ifabsent", + "list_elements_unique", + "list_elements_ordered", + "shared", + "key", + "identifier", + "designates_type", + "alias", + "owner", + "domain_of", + "subproperty_of", + "symmetric", + "reflexive", + "locally_reflexive", + "irreflexive", + "asymmetric", + "transitive", + "inverse", + "is_class_field", + "transitive_form_of", + "reflexive_transitive_form_of", + "role", + "is_usage_slot", + "usage_slot_name", + "relational_role", + "slot_group", + "is_grouping_slot", + "path_rule", + "slot_definition_disjoint_with", + "children_are_mutually_disjoint", + "slot_definition_union_of", + "slot_definition_is_a", + "slot_definition_mixins", + "slot_definition_apply_to", + "range", + "range_expression", + "enum_range", + "required", + "recommended", + "inlined", + "inlined_as_list", + "minimum_value", + "maximum_value", + "pattern", + "structured_pattern", + "unit", + "implicit_prefix", + "value_presence", + "equals_string", + "equals_string_in", + "equals_number", + "equals_expression", + "minimum_cardinality", + "maximum_cardinality", + "has_member", + "all_members", + "slot_expression_none_of", + "slot_expression_exactly_one_of", + "slot_expression_any_of", + "slot_expression_all_of" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/SlotDefinition", + "@type": "ClassDefinition" + }, + { + "name": "ClassExpression", + "definition_uri": "https://w3id.org/linkml/ClassExpression", + "description": "A boolean expression that can be used to dynamically determine membership of a class", + "from_schema": "https://w3id.org/linkml/meta", + "mixin": true, + "status": "testing", + "slots": [ + "class_expression_any_of", + "class_expression_exactly_one_of", + "class_expression_none_of", + "class_expression_all_of", + "slot_conditions" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/ClassExpression", + "@type": "ClassDefinition" + }, + { + "name": "AnonymousClassExpression", + "definition_uri": "https://w3id.org/linkml/AnonymousClassExpression", + "from_schema": "https://w3id.org/linkml/meta", + "is_a": "AnonymousExpression", + "mixins": [ + "ClassExpression" + ], + "status": "testing", + "slots": [ + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank", + "is_a", + "class_expression_any_of", + "class_expression_exactly_one_of", + "class_expression_none_of", + "class_expression_all_of", + "slot_conditions" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/AnonymousClassExpression", + "@type": "ClassDefinition" + }, + { + "name": "ClassDefinition", + "definition_uri": "https://w3id.org/linkml/ClassDefinition", + "description": "an element whose instances are complex objects that may have slot-value assignments", + "in_subset": [ + "SpecificationSubset", + "MinimalSubset", + "BasicSubset", + "RelationalModelProfile", + "ObjectOrientedProfile", + "OwlProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "table", + "record", + "template", + "message", + "observation" + ], + "close_mappings": [ + "owl:Class" + ], + "rank": 2, + "is_a": "Definition", + "mixins": [ + "ClassExpression" + ], + "slots": [ + "name", + "id_prefixes", + "definition_uri", + "local_names", + "conforms_to", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank", + "abstract", + "mixin", + "values_from", + "created_by", + "created_on", + "last_updated_on", + "modified_by", + "status", + "string_serialization", + "slots", + "slot_usage", + "attributes", + "class_uri", + "subclass_of", + "class_definition_union_of", + "defining_slots", + "tree_root", + "unique_keys", + "class_definition_rules", + "classification_rules", + "slot_names_unique", + "represents_relationship", + "class_definition_disjoint_with", + "children_are_mutually_disjoint", + "class_definition_is_a", + "class_definition_mixins", + "class_definition_apply_to", + "class_expression_any_of", + "class_expression_exactly_one_of", + "class_expression_none_of", + "class_expression_all_of", + "slot_conditions" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/ClassDefinition", + "@type": "ClassDefinition" + }, + { + "name": "ClassLevelRule", + "definition_uri": "https://w3id.org/linkml/ClassLevelRule", + "description": "A rule that is applied to classes", + "from_schema": "https://w3id.org/linkml/meta", + "abstract": true, + "status": "testing", + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/ClassLevelRule", + "@type": "ClassDefinition" + }, + { + "name": "ClassRule", + "definition_uri": "https://w3id.org/linkml/ClassRule", + "description": "A rule that applies to instances of a class", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "if rule" + ], + "close_mappings": [ + "sh:TripleRule", + "swrl:Imp" + ], + "is_a": "ClassLevelRule", + "mixins": [ + "Extensible", + "Annotatable", + "CommonMetadata" + ], + "status": "testing", + "slots": [ + "preconditions", + "postconditions", + "elseconditions", + "bidirectional", + "open_world", + "rank", + "deactivated", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/ClassRule", + "@type": "ClassDefinition" + }, + { + "name": "PatternExpression", + "definition_uri": "https://w3id.org/linkml/PatternExpression", + "description": "a regular expression pattern used to evaluate conformance of a string", + "from_schema": "https://w3id.org/linkml/meta", + "mixins": [ + "Extensible", + "Annotatable", + "CommonMetadata" + ], + "slots": [ + "syntax", + "interpolated", + "partial_match", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/PatternExpression", + "@type": "ClassDefinition" + }, + { + "name": "ImportExpression", + "definition_uri": "https://w3id.org/linkml/ImportExpression", + "description": "an expression describing an import", + "from_schema": "https://w3id.org/linkml/meta", + "mixins": [ + "Extensible", + "Annotatable", + "CommonMetadata" + ], + "status": "testing", + "slots": [ + "import_from", + "import_as", + "import_map", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/ImportExpression", + "@type": "ClassDefinition" + }, + { + "name": "Setting", + "definition_uri": "https://w3id.org/linkml/Setting", + "description": "assignment of a key to a value", + "in_subset": [ + "SpecificationSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "slots": [ + "setting_key", + "setting_value" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/Setting", + "@type": "ClassDefinition" + }, + { + "name": "Prefix", + "definition_uri": "https://w3id.org/linkml/Prefix", + "description": "prefix URI tuple", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 12, + "slots": [ + "prefix_prefix", + "prefix_reference" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/Prefix", + "@type": "ClassDefinition" + }, + { + "name": "LocalName", + "definition_uri": "https://w3id.org/linkml/LocalName", + "description": "an attributed label", + "from_schema": "https://w3id.org/linkml/meta", + "slots": [ + "local_name_source", + "local_name_value" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/LocalName", + "@type": "ClassDefinition" + }, + { + "name": "Example", + "definition_uri": "https://w3id.org/linkml/Example", + "description": "usage example and description", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "slots": [ + "value", + "value_description" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/Example", + "@type": "ClassDefinition" + }, + { + "name": "AltDescription", + "definition_uri": "https://w3id.org/linkml/AltDescription", + "description": "an attributed description", + "in_subset": [ + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "slots": [ + "alt_description_source", + "alt_description_text" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/AltDescription", + "@type": "ClassDefinition" + }, + { + "name": "PermissibleValue", + "definition_uri": "https://w3id.org/linkml/PermissibleValue", + "description": "a permissible value, accompanied by intended text and an optional mapping to a concept URI", + "in_subset": [ + "SpecificationSubset", + "BasicSubset" + ], + "from_schema": "https://w3id.org/linkml/meta", + "aliases": [ + "PV" + ], + "close_mappings": [ + "skos:Concept" + ], + "rank": 16, + "mixins": [ + "Extensible", + "Annotatable", + "CommonMetadata" + ], + "slots": [ + "text", + "description", + "meaning", + "unit", + "permissible_value_is_a", + "permissible_value_mixins", + "extensions", + "annotations", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/PermissibleValue", + "@type": "ClassDefinition" + }, + { + "name": "UniqueKey", + "definition_uri": "https://w3id.org/linkml/UniqueKey", + "description": "a collection of slots whose values uniquely identify an instance of a class", + "in_subset": [ + "SpecificationSubset", + "BasicSubset", + "RelationalModelProfile" + ], + "from_schema": "https://w3id.org/linkml/meta", + "rank": 20, + "mixins": [ + "Extensible", + "Annotatable", + "CommonMetadata" + ], + "slots": [ + "unique_key_name", + "unique_key_slots", + "extensions", + "annotations", + "description", + "alt_descriptions", + "title", + "deprecated", + "todos", + "notes", + "comments", + "examples", + "in_subset", + "from_schema", + "imported_from", + "source", + "in_language", + "see_also", + "deprecated_element_has_exact_replacement", + "deprecated_element_has_possible_replacement", + "aliases", + "structured_aliases", + "mappings", + "exact_mappings", + "close_mappings", + "related_mappings", + "narrow_mappings", + "broad_mappings", + "rank" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/UniqueKey", + "@type": "ClassDefinition" + }, + { + "name": "Extension", + "definition_uri": "https://w3id.org/linkml/Extension", + "description": "a tag/value pair used to add non-model information to an entry", + "from_schema": "https://w3id.org/linkml/extensions", + "imported_from": "linkml:extensions", + "slots": [ + "extension_tag", + "extension_value", + "extensions" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/Extension", + "@type": "ClassDefinition" + }, + { + "name": "Extensible", + "definition_uri": "https://w3id.org/linkml/Extensible", + "description": "mixin for classes that support extension", + "from_schema": "https://w3id.org/linkml/extensions", + "imported_from": "linkml:extensions", + "mixin": true, + "slots": [ + "extensions" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/Extensible", + "@type": "ClassDefinition" + }, + { + "name": "Annotatable", + "definition_uri": "https://w3id.org/linkml/Annotatable", + "description": "mixin for classes that support annotations", + "from_schema": "https://w3id.org/linkml/annotations", + "imported_from": "linkml:annotations", + "mixin": true, + "slots": [ + "annotations" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/Annotatable", + "@type": "ClassDefinition" + }, + { + "name": "Annotation", + "definition_uri": "https://w3id.org/linkml/Annotation", + "description": "a tag/value pair with the semantics of OWL Annotation", + "from_schema": "https://w3id.org/linkml/annotations", + "imported_from": "linkml:annotations", + "is_a": "Extension", + "mixins": [ + "Annotatable" + ], + "slots": [ + "extension_tag", + "extension_value", + "extensions", + "annotations" + ], + "slot_usage": {}, + "class_uri": "https://w3id.org/linkml/Annotation", + "@type": "ClassDefinition" + }, + { + "name": "UnitOfMeasure", + "definition_uri": "https://w3id.org/linkml/UnitOfMeasure", + "description": "A unit of measure, or unit, is a particular quantity value that has been chosen as a scale for measuring other quantities the same kind (more generally of equivalent dimension).", + "from_schema": "https://w3id.org/linkml/units", + "imported_from": "linkml:units", + "mappings": [ + "qudt:Unit" + ], + "slots": [ + "symbol", + "UnitOfMeasure_exact_mappings", + "ucum_code", + "derivation", + "has_quantity_kind", + "iec61360code" + ], + "slot_usage": {}, + "class_uri": "http://qudt.org/schema/qudt/Unit", + "any_of": [ + { + "slot_conditions": [ + { + "name": "ucum_code", + "required": true, + "@type": "SlotDefinition" + } + ], + "@type": "AnonymousClassExpression" + }, + { + "slot_conditions": [ + { + "name": "iec61360code", + "required": true, + "@type": "SlotDefinition" + } + ], + "@type": "AnonymousClassExpression" + }, + { + "slot_conditions": [ + { + "name": "symbol", + "required": true, + "@type": "SlotDefinition" + } + ], + "@type": "AnonymousClassExpression" + }, + { + "slot_conditions": [ + { + "name": "exact_mappings", + "required": true, + "@type": "SlotDefinition" + } + ], + "@type": "AnonymousClassExpression" + } + ], + "@type": "ClassDefinition" + } + ], + "metamodel_version": "1.7.0", + "source_file": "meta.yaml", + "source_file_date": "2022-12-09T14:24:35", + "source_file_size": 81549, + "generation_date": "2022-12-09T14:56:40", + "@type": "SchemaDefinition", + "@context": [ + "target/jsonld/meta.context.jsonld", + "https://w3id.org/linkml/types.context.jsonld", + "https://w3id.org/linkml/mappings.context.jsonld", + "https://w3id.org/linkml/extensions.context.jsonld", + "https://w3id.org/linkml/annotations.context.jsonld", + "https://w3id.org/linkml/units.context.jsonld", + { + "@base": "https://w3id.org/linkml/" + } + ] +} diff --git a/linkml_runtime/linkml_model/jsonld/meta.model.context.jsonld b/linkml_runtime/linkml_model/jsonld/meta.model.context.jsonld index c0efdf8f..c4678ccd 100644 --- a/linkml_runtime/linkml_model/jsonld/meta.model.context.jsonld +++ b/linkml_runtime/linkml_model/jsonld/meta.model.context.jsonld @@ -1,5 +1,5 @@ { - "_comments": "Auto generated from meta.yaml by jsonldcontextgen.py version: 0.1.1\n Generation date: 2022-07-13T17:56:58\n Schema: meta\n metamodel version: 1.7.0\n model version: 2.0.0\n \n id: https://w3id.org/linkml/meta\n description: The metamodel for schemas defined using the Linked Data Modeling Language framework.\n\nFor more information on LinkML, see [linkml.io](https://linkml.io)\n\nCore metaclasses:\n\n* [SchemaDefinition](https://w3id.org/linkml/SchemaDefinition)\n* [ClassDefinition](https://w3id.org/linkml/ClassDefinition)\n* [SlotDefinition](https://w3id.org/linkml/SlotDefinition)\n* [TypeDefinition](https://w3id.org/linkml/TypeDefinition)\n\nEvery LinkML model instantiates SchemaDefinition, all classes in\nthe model instantiate ClassDefinition, and so on\n\nNote that the LinkML metamodel instantiates itself.\n\nFor a non-normative introduction to LinkML schemas, see the tutorial\nand schema guide on [linkml.io/linkml].\n\nFor canonical reference documentation on any metamodel construct,\nrefer to the official URI for each construct, e.g.\n[https://w3id.org/linkml/is_a](https://w3id.org/linkml/is_a)\n license: https://creativecommons.org/publicdomain/zero/1.0/\n ", + "_comments": "Auto generated from meta.yaml by jsonldcontextgen.py version: 0.1.1\n Generation date: 2022-07-14T00:56:26\n Schema: meta\n metamodel version: 1.7.0\n model version: 2.0.0\n \n id: https://w3id.org/linkml/meta\n description: The metamodel for schemas defined using the Linked Data Modeling Language framework.\n\nFor more information on LinkML, see [linkml.io](https://linkml.io)\n\nCore metaclasses:\n\n* [SchemaDefinition](https://w3id.org/linkml/SchemaDefinition)\n* [ClassDefinition](https://w3id.org/linkml/ClassDefinition)\n* [SlotDefinition](https://w3id.org/linkml/SlotDefinition)\n* [TypeDefinition](https://w3id.org/linkml/TypeDefinition)\n\nEvery LinkML model instantiates SchemaDefinition, all classes in\nthe model instantiate ClassDefinition, and so on\n\nNote that the LinkML metamodel instantiates itself.\n\nFor a non-normative introduction to LinkML schemas, see the tutorial\nand schema guide on [linkml.io/linkml].\n\nFor canonical reference documentation on any metamodel construct,\nrefer to the official URI for each construct, e.g.\n[https://w3id.org/linkml/is_a](https://w3id.org/linkml/is_a)\n license: https://creativecommons.org/publicdomain/zero/1.0/\n ", "@context": { "IAO": { "@id": "http://purl.obolibrary.org/obo/IAO_", diff --git a/linkml_runtime/linkml_model/jsonld/types.model.context.jsonld b/linkml_runtime/linkml_model/jsonld/types.model.context.jsonld index aa541dd3..7ffa5cbb 100644 --- a/linkml_runtime/linkml_model/jsonld/types.model.context.jsonld +++ b/linkml_runtime/linkml_model/jsonld/types.model.context.jsonld @@ -1,5 +1,5 @@ { - "_comments": "Auto generated from types.yaml by jsonldcontextgen.py version: 0.1.1\n Generation date: 2022-07-13T17:56:55\n Schema: types\n metamodel version: 1.7.0\n model version: 2.0.0\n \n id: https://w3id.org/linkml/types\n description: Shared type definitions for the core LinkML mode and metamodel\n license: https://creativecommons.org/publicdomain/zero/1.0/\n ", + "_comments": "Auto generated from types.yaml by jsonldcontextgen.py version: 0.1.1\n Generation date: 2022-07-14T00:56:20\n Schema: types\n metamodel version: 1.7.0\n model version: 2.0.0\n \n id: https://w3id.org/linkml/types\n description: Shared type definitions for the core LinkML mode and metamodel\n license: https://creativecommons.org/publicdomain/zero/1.0/\n ", "@context": { "linkml": "https://w3id.org/linkml/", "shex": "http://www.w3.org/ns/shex#", diff --git a/linkml_runtime/linkml_model/jsonschema/datasets.schema.json b/linkml_runtime/linkml_model/jsonschema/datasets.schema.json new file mode 100644 index 00000000..67515917 --- /dev/null +++ b/linkml_runtime/linkml_model/jsonschema/datasets.schema.json @@ -0,0 +1,293 @@ +{ + "$defs": { + "DataPackage": { + "additionalProperties": false, + "description": "A collection of data resources", + "properties": { + "compression": { + "type": "string" + }, + "conforms_to": { + "type": "string" + }, + "conforms_to_class": { + "description": "class in schema which the data object instantiates", + "type": "string" + }, + "conforms_to_schema": { + "type": "string" + }, + "created_by": { + "description": "agent that created the element", + "type": "string" + }, + "created_on": { + "description": "time at which the element was created", + "format": "date-time", + "type": "string" + }, + "description": { + "description": "human readable description of the information", + "type": "string" + }, + "download_url": { + "type": "string" + }, + "id": { + "description": "the unique name of th dataset", + "type": "string" + }, + "issued": { + "format": "date-time", + "type": "string" + }, + "keywords": { + "items": { + "type": "string" + }, + "type": "array" + }, + "language": { + "description": "language in which the information is expressed", + "type": "string" + }, + "license": { + "description": "license for the data", + "type": "string" + }, + "page": { + "type": "string" + }, + "publisher": { + "type": "string" + }, + "resources": { + "items": { + "type": "string" + }, + "type": "array" + }, + "test_roles": { + "items": { + "$ref": "#/$defs/TestRole" + }, + "type": "array" + }, + "title": { + "description": "the official title of the element", + "type": "string" + }, + "version": { + "description": "particular version of schema", + "type": "string" + }, + "was_derived_from": { + "description": "A derivation is a transformation of an entity into another, an update of an entity resulting in a new one, or the construction of a new entity based on a pre-existing entity.@en", + "type": "string" + } + }, + "required": [ + "id" + ], + "title": "DataPackage", + "type": "object" + }, + "DataResource": { + "additionalProperties": false, + "description": "An individual file or table", + "properties": { + "bytes": { + "type": "integer" + }, + "compression": { + "type": "string" + }, + "conforms_to": { + "type": "string" + }, + "conforms_to_class": { + "description": "class in schema which the data object instantiates", + "type": "string" + }, + "conforms_to_schema": { + "type": "string" + }, + "created_by": { + "description": "agent that created the element", + "type": "string" + }, + "created_on": { + "description": "time at which the element was created", + "format": "date-time", + "type": "string" + }, + "description": { + "description": "human readable description of the information", + "type": "string" + }, + "dialect": { + "type": "string" + }, + "download_url": { + "type": "string" + }, + "encoding": { + "type": "string" + }, + "format": { + "$ref": "#/$defs/FormatEnum" + }, + "hash": { + "type": "string" + }, + "id": { + "description": "the unique name of th dataset", + "type": "string" + }, + "issued": { + "format": "date-time", + "type": "string" + }, + "keywords": { + "items": { + "type": "string" + }, + "type": "array" + }, + "language": { + "description": "language in which the information is expressed", + "type": "string" + }, + "license": { + "description": "license for the data", + "type": "string" + }, + "md5": { + "type": "string" + }, + "media_type": { + "type": "string" + }, + "page": { + "type": "string" + }, + "path": { + "type": "string" + }, + "publisher": { + "type": "string" + }, + "sha256": { + "type": "string" + }, + "test_roles": { + "items": { + "$ref": "#/$defs/TestRole" + }, + "type": "array" + }, + "title": { + "description": "the official title of the element", + "type": "string" + }, + "version": { + "description": "particular version of schema", + "type": "string" + }, + "was_derived_from": { + "description": "A derivation is a transformation of an entity into another, an update of an entity resulting in a new one, or the construction of a new entity based on a pre-existing entity.@en", + "type": "string" + } + }, + "required": [ + "id" + ], + "title": "DataResource", + "type": "object" + }, + "FormatDialect": { + "additionalProperties": false, + "description": "Additional format information for a file", + "properties": { + "comment_prefix": { + "type": "string" + }, + "delimiter": { + "type": "string" + }, + "double_quote": { + "type": "string" + }, + "header": { + "type": "string" + }, + "quote_char": { + "type": "string" + } + }, + "required": [], + "title": "FormatDialect", + "type": "object" + }, + "FormatEnum": { + "description": "", + "enum": [ + "JSON-LD", + "N3", + "N-Triples", + "N-Quads", + "LD Patch", + "Microdata", + "OWL XML Serialization", + "OWL Functional Syntax", + "OWL Manchester Syntax", + "POWDER", + "POWDER-S", + "PROV-N", + "PROV-XML", + "RDFa", + "RDF/JSON", + "RDF/XML", + "RIF XML Syntax", + "SPARQL Results in XML", + "SPARQL Results in JSON", + "SPARQL Results in CSV", + "SPARQL Results in TSV", + "Turtle", + "TriG", + "YAML", + "JSON" + ], + "title": "FormatEnum", + "type": "string" + }, + "MediaTypeEnum": { + "description": "", + "enum": [ + "csv", + "rdf-xml" + ], + "title": "MediaTypeEnum", + "type": "string" + }, + "TestRole": { + "description": "", + "enum": [ + "Example", + "CounterExample" + ], + "title": "TestRole", + "type": "string" + } + }, + "$id": "https://w3id.org/linkml/datasets", + "$schema": "http://json-schema.org/draft-07/schema#", + "additionalProperties": true, + "metamodel_version": "1.7.0", + "properties": {}, + "required": [], + "title": "datasets", + "type": "object", + "version": null +} + diff --git a/linkml_runtime/linkml_model/meta.py b/linkml_runtime/linkml_model/meta.py index 6cc349f3..84e4b19b 100644 --- a/linkml_runtime/linkml_model/meta.py +++ b/linkml_runtime/linkml_model/meta.py @@ -1,8 +1,7 @@ # Auto generated from meta.yaml by pythongen.py version: 0.9.0 -# Generation date: 2022-12-09T13:58:38 +# Generation date: 2022-12-09T14:57:09 # Schema: meta # -# # id: https://w3id.org/linkml/meta # description: The metamodel for schemas defined using the Linked Data Modeling Language framework. For more # information on LinkML: * [linkml.io](https://linkml.io) main website * @@ -25,7 +24,6 @@ from jsonasobj2 import JsonObj, as_dict from typing import Optional, List, Union, Dict, ClassVar, Any from dataclasses import dataclass -from linkml_runtime.linkml_model.meta import EnumDefinition, PermissibleValue, PvFormulaOptions from linkml_runtime.utils.slot import Slot from linkml_runtime.utils.metamodelcore import empty_list, empty_dict, bnode @@ -35,10 +33,10 @@ from linkml_runtime.utils.enumerations import EnumDefinitionImpl from rdflib import Namespace, URIRef from linkml_runtime.utils.curienamespace import CurieNamespace -from linkml_runtime.linkml_model.annotations import Annotation, AnnotationTag -from linkml_runtime.linkml_model.extensions import Extension, ExtensionTag -from linkml_runtime.linkml_model.types import Boolean, Datetime, Integer, Ncname, String, Uri, Uriorcurie -from linkml_runtime.linkml_model.units import UnitOfMeasure +from .annotations import Annotation, AnnotationTag +from .extensions import Extension, ExtensionTag +from .types import Boolean, Datetime, Integer, Ncname, String, Uri, Uriorcurie +from .units import UnitOfMeasure from linkml_runtime.utils.metamodelcore import Bool, NCName, URI, URIorCURIE, XSDDateTime metamodel_version = "1.7.0" @@ -48,7 +46,6 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs # Namespaces -IAO = CurieNamespace('IAO', 'http://purl.obolibrary.org/obo/IAO_') NCIT = CurieNamespace('NCIT', 'http://ncicb.nci.nih.gov/xml/owl/EVS/Thesaurus.owl#') OIO = CurieNamespace('OIO', 'http://www.geneontology.org/formats/oboInOwl#') BIBO = CurieNamespace('bibo', 'http://purl.org/ontology/bibo/') @@ -4013,4 +4010,4 @@ class slots: model_uri=LINKML.permissible_value_is_a, domain=PermissibleValue, range=Optional[Union[str, PermissibleValueText]]) slots.permissible_value_mixins = Slot(uri=LINKML.mixins, name="permissible_value_mixins", curie=LINKML.curie('mixins'), - model_uri=LINKML.permissible_value_mixins, domain=PermissibleValue, range=Optional[Union[Union[str, PermissibleValueText], List[Union[str, PermissibleValueText]]]]) + model_uri=LINKML.permissible_value_mixins, domain=PermissibleValue, range=Optional[Union[Union[str, PermissibleValueText], List[Union[str, PermissibleValueText]]]]) \ No newline at end of file diff --git a/linkml_runtime/linkml_model/model/schema/datasets.yaml b/linkml_runtime/linkml_model/model/schema/datasets.yaml new file mode 100644 index 00000000..81e459c7 --- /dev/null +++ b/linkml_runtime/linkml_model/model/schema/datasets.yaml @@ -0,0 +1,355 @@ +id: https://w3id.org/linkml/datasets +title: LinkML Datasets Datamodel +name: datasets +description: A datamodel for datasets +license: https://creativecommons.org/publicdomain/zero/1.0/ +see_also: + - https://specs.frictionlessdata.io/data-resource + - https://www.w3.org/TR/void/ + - https://www.w3.org/TR/hcls-dataset/ + +prefixes: + linkml: https://w3id.org/linkml/ + datasets: https://w3id.org/linkml/report + skos: http://www.w3.org/2004/02/skos/core# + pav: http://purl.org/pav/ + schema: http://schema.org/ + sh: https://w3id.org/shacl/ + void: http://rdfs.org/ns/void# + frictionless: https://specs.frictionlessdata.io/ + formats: http://www.w3.org/ns/formats/ + csvw: http://www.w3.org/ns/csvw# + dcat: http://www.w3.org/ns/dcat# + mediatypes: https://www.iana.org/assignments/media-types/ + +default_prefix: datasets +default_range: string + +default_curi_maps: + - semweb_context + +emit_prefixes: + - linkml + - rdf + - rdfs + - xsd + - owl + +imports: + - linkml:types + + +#================================== +# Classes # +#================================== +classes: + Information: + abstract: true + description: Grouping for datasets and data files + close_mappings: + - schema:CreativeWork + slots: + - id + - download_url + - license + - title + - description + - conforms_to + - conforms_to_schema + - conforms_to_class + - version + - language + - publisher + - keywords + - issued +# - modified + - created_by + - created_on + - compression + - was_derived_from + - page + - test_roles + + DataPackage: + aliases: + - dataset + - file collection + - data resource collection + description: A collection of data resources + is_a: Information + class_uri: void:Dataset + exact_mappings: + - dcat:Dataset + close_mappings: + - dcat:Catalog + see_also: + - https://specs.frictionlessdata.io/data-package + slots: + - resources + + DataResource: + is_a: Information + description: An individual file or table + class_uri: dcat:Distribution + exact_mappings: + - schema:DataDownload + see_also: + - https://specs.frictionlessdata.io/data-resource + slots: + - path + - title + - description + - format + - media_type + - encoding + - bytes + - hash + - md5 + - sha256 + - dialect + + FormatDialect: + description: Additional format information for a file + attributes: + comment_prefix: + delimiter: + double_quote: + header: + quote_char: + +#================================== +# Slots # +#================================== +slots: + id: + identifier: true + description: the unique name of th dataset + slot_uri: dcterms:identifier + exact_mappings: + - schema:name + + title: + description: the official title of the element + slot_uri: dcterms:title + + description: + description: human readable description of the information + slot_uri: dcterms:description + + language: + description: language in which the information is expressed + + publisher: + slot_uri: dcterms:publisher + range: uriorcurie + + issued: + slot_uri: dcterms:issued + range: datetime + + page: + slot_uri: dcat:landingPage + + dialect: + slot_uri: csvw:dialect + + bytes: + range: integer + slot_uri: dcat:byteSize + + path: + close_mappings: + - frictionless:path + + download_url: + range: uri + slot_uri: dcat:downloadURL + exact_mappings: + - schema:url + close_mappings: + - frictionless:path + + format: + range: FormatEnum + slot_uri: dcterms:format + + compression: + + encoding: + hash: + notes: + - we recommend using a more specific slot such as sha256 or md5 + sha256: + is_a: hash + md5: + is_a: hash + + media_type: + #range: MediaTypeEnum + range: string + examples: + - value: text/csv + - value: application/json + slot_uri: dcat:mediaType + exact_mappings: + - frictionless:mediatype + - schema:encodingFormat + + conforms_to: + slot_uri: dcterms:conformsTo + range: uriorcurie + + conforms_to_schema: + is_a: conforms_to + exact_mappings: + - frictionless:schema + + conforms_to_class: + is_a: conforms_to + description: class in schema which the data object instantiates + + profile: + range: uriorcurie + exact_mappings: + - frictionless:profiles + + keywords: + singular_name: keyword + multivalued: true + range: string + slot_uri: dcat:keyword + exact_mappings: + - schema:keywords + + themes: + singular_name: theme + multivalued: true + range: uriorcurie + slot_uri: dcat:theme + + resources: + multivalued: true + range: DataResource + slot_uri: dcat:distribution + exact_mappings: + - schema:distribution + + test_roles: + multivalued: true + range: TestRole + + created_by: + range: uriorcurie + description: agent that created the element + slot_uri: pav:createdBy + + created_on: + range: datetime + description: time at which the element was created + slot_uri: pav:createdOn + + last_updated_on: + range: datetime + description: time at which the element was last updated + slot_uri: pav:lastUpdatedOn + + modified_by: + range: uriorcurie + description: agent that modified the element + slot_uri: oslc:modifiedBy + + status: + range: uriorcurie + description: status of the element + slot_uri: bibo:status + examples: + - value: "bibo:draft" + + license: + description: license for the data + slot_uri: dcterms:license + exact_mappings: + - frictionless:licenses + + version: + description: particular version of schema + slot_uri: pav:version + exact_mappings: + - schema:version + - dcterms:hasVersion + + was_derived_from: + slot_uri: prov:wasDerivedFrom + description: A derivation is a transformation of an entity into another, an update + of an entity resulting in a new one, or the construction of a new entity based + on a pre-existing entity.@en + +#================================== +# Enumerations # +#================================== +enums: + + TestRole: + permissible_values: + Example: + CounterExample: + + MediaTypeEnum: + exact_mappings: + - dcterms:MediaType + permissible_values: + csv: + meaning: mediatypes:text/csv + rdf-xml: + meaning: mediatypes:application/rdf+xml + + FormatEnum: + permissible_values: + JSON-LD: + meaning: formats:JSON-LD + N3: + meaning: formats:N3 + N-Triples: + meaning: formats:N-Triples + N-Quads: + meaning: formats:N-Quads + LD Patch: + meaning: formats:LD_Patch + Microdata: + meaning: formats:microdata + OWL XML Serialization: + meaning: formats:OWL_XML + OWL Functional Syntax: + meaning: formats:OWL_Functional + OWL Manchester Syntax: + meaning: formats:OWL_Manchester + POWDER: + meaning: formats:POWDER + POWDER-S: + meaning: formats:POWDER-S + PROV-N: + meaning: formats:PROV-N + PROV-XML: + meaning: formats:PROV-XML + RDFa: + meaning: formats:RDFa + RDF/JSON: + meaning: formats:RDF_JSON + RDF/XML: + meaning: formats:RDF_XML + RIF XML Syntax: + meaning: formats:RIF_XML + SPARQL Results in XML: + meaning: formats:SPARQL_Results_XML + SPARQL Results in JSON: + meaning: formats:SPARQL_Results_JSON + SPARQL Results in CSV: + meaning: formats:SPARQL_Results_CSV + SPARQL Results in TSV: + meaning: formats:SPARQL_Results_TSV + Turtle: + meaning: formats:Turtle + TriG: + meaning: formats:TriG + YAML: + JSON: diff --git a/linkml_runtime/linkml_model/owl/meta.owl.ttl b/linkml_runtime/linkml_model/owl/meta.owl.ttl index d7e2b217..0600a81a 100644 --- a/linkml_runtime/linkml_model/owl/meta.owl.ttl +++ b/linkml_runtime/linkml_model/owl/meta.owl.ttl @@ -55,10 +55,10 @@ linkml:meta a owl:Ontology ; dcterms:license "https://creativecommons.org/publicdomain/zero/1.0/" ; dcterms:title "LinkML Schema Metamodel" ; pav:version "2.0.0" ; - linkml:generation_date "2022-12-09T13:58:30" ; + linkml:generation_date "2022-12-09T14:57:01" ; linkml:metamodel_version "1.7.0" ; linkml:source_file "meta.yaml" ; - linkml:source_file_date "2022-12-09T13:54:23" ; + linkml:source_file_date "2022-12-09T14:24:35" ; linkml:source_file_size 81549 . linkml:owned_by a owl:ObjectProperty, @@ -998,96 +998,96 @@ linkml:AnonymousExpression a owl:Class, linkml:ClassDefinition ; rdfs:label "anonymous_expression" ; rdfs:subClassOf [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_possible_replacement ], + [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty skos:definition ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:exactMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:imported_from ], + owl:onClass linkml:Uri ; + owl:onProperty skos:inScheme ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty rdfs:seeAlso ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:note ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty dcterms:source ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:StructuredAlias ; - owl:onProperty skosxl:altLabel ], + owl:onClass linkml:String ; + owl:onProperty linkml:deprecated ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; - owl:onProperty skos:note ], + owl:onProperty skos:editorialNote ], [ a owl:Restriction ; - owl:allValuesFrom linkml:SubsetDefinition ; - owl:onProperty OIO:inSubset ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_exact_replacement ], [ a owl:Restriction ; owl:allValuesFrom linkml:AltDescription ; owl:onProperty linkml:alt_descriptions ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:closeMatch ], + owl:allValuesFrom linkml:StructuredAlias ; + owl:onProperty skosxl:altLabel ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Example ; - owl:onProperty linkml:examples ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Integer ; + owl:onProperty sh:order ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:todos ], + owl:allValuesFrom linkml:Annotation ; + owl:onProperty linkml:annotations ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:broadMatch ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:altLabel ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:relatedMatch ], + owl:onProperty rdfs:seeAlso ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:deprecated ], + owl:onProperty linkml:imported_from ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_exact_replacement ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:mappingRelation ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty dcterms:title ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_possible_replacement ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:relatedMatch ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty schema:inLanguage ], + owl:allValuesFrom linkml:Example ; + owl:onProperty linkml:examples ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:editorialNote ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:exactMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Annotation ; - owl:onProperty linkml:annotations ], + owl:allValuesFrom linkml:Extension ; + owl:onProperty linkml:extensions ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:todos ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:narrowMatch ], + owl:onProperty skos:broadMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uri ; - owl:onProperty skos:inScheme ], + owl:onClass linkml:Uriorcurie ; + owl:onProperty dcterms:source ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:altLabel ], + owl:allValuesFrom linkml:SubsetDefinition ; + owl:onProperty OIO:inSubset ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:mappingRelation ], + owl:onProperty skos:narrowMatch ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty sh:order ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:closeMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Extension ; - owl:onProperty linkml:extensions ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty schema:inLanguage ], linkml:Annotatable, linkml:CommonMetadata, linkml:Expression, @@ -1102,16 +1102,26 @@ linkml:ClassRule a owl:Class, linkml:ClassDefinition ; rdfs:label "class_rule" ; rdfs:subClassOf [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Integer ; + owl:onProperty sh:order ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty skos:altLabel ], + [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:deprecated ], + owl:onProperty linkml:imported_from ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:closeMatch ], + owl:onProperty skos:broadMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty sh:deactivated ], + owl:onClass linkml:String ; + owl:onProperty linkml:deprecated ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Annotation ; + owl:onProperty linkml:annotations ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:AnonymousClassExpression ; @@ -1120,89 +1130,75 @@ linkml:ClassRule a owl:Class, owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty schema:inLanguage ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:mappingRelation ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; - owl:onProperty dcterms:source ], + owl:onProperty linkml:deprecated_element_has_possible_replacement ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; owl:onProperty skos:note ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:todos ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:AnonymousClassExpression ; + owl:onProperty linkml:elseconditions ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; owl:onProperty linkml:deprecated_element_has_exact_replacement ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Extension ; - owl:onProperty linkml:extensions ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:imported_from ], + owl:onClass linkml:Boolean ; + owl:onProperty sh:deactivated ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:mappingRelation ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:editorialNote ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty rdfs:seeAlso ], + owl:allValuesFrom linkml:SubsetDefinition ; + owl:onProperty OIO:inSubset ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:open_world ], + owl:onClass linkml:String ; + owl:onProperty skos:definition ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:AnonymousClassExpression ; - owl:onProperty linkml:elseconditions ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:open_world ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_possible_replacement ], + owl:onProperty dcterms:source ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:narrowMatch ], + owl:onProperty skos:relatedMatch ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:StructuredAlias ; + owl:onProperty skosxl:altLabel ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:AnonymousClassExpression ; owl:onProperty linkml:postconditions ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty sh:order ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; owl:onProperty linkml:bidirectional ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:relatedMatch ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:StructuredAlias ; - owl:onProperty skosxl:altLabel ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Annotation ; - owl:onProperty linkml:annotations ], + owl:onProperty rdfs:seeAlso ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:broadMatch ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:altLabel ], + owl:onProperty skos:narrowMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:todos ], + owl:allValuesFrom linkml:Extension ; + owl:onProperty linkml:extensions ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty skos:exactMatch ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty dcterms:title ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uri ; - owl:onProperty skos:inScheme ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:editorialNote ], [ a owl:Restriction ; owl:allValuesFrom linkml:AltDescription ; owl:onProperty linkml:alt_descriptions ], @@ -1210,12 +1206,16 @@ linkml:ClassRule a owl:Class, owl:allValuesFrom linkml:Example ; owl:onProperty linkml:examples ], [ a owl:Restriction ; - owl:allValuesFrom linkml:SubsetDefinition ; - owl:onProperty OIO:inSubset ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uri ; + owl:onProperty skos:inScheme ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:closeMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty skos:definition ], + owl:onProperty dcterms:title ], linkml:Annotatable, linkml:ClassLevelRule, linkml:CommonMetadata, @@ -1265,29 +1265,26 @@ linkml:TypeExpression a owl:Class, linkml:ClassDefinition ; rdfs:label "type_expression" ; rdfs:subClassOf [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:equals_string_in ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:implicit_prefix ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:maximum_value ], + owl:onClass linkml:UnitOfMeasure ; + owl:onProperty qudt:unit ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; - owl:onProperty linkml:equals_number ], + owl:onProperty linkml:maximum_value ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousTypeExpression ; owl:onProperty linkml:all_of ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousTypeExpression ; - owl:onProperty linkml:none_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousTypeExpression ; owl:onProperty linkml:exactly_one_of ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:minimum_value ], + owl:allValuesFrom linkml:AnonymousTypeExpression ; + owl:onProperty linkml:none_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:PatternExpression ; @@ -1295,22 +1292,25 @@ linkml:TypeExpression a owl:Class, [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:implicit_prefix ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:equals_string ], + owl:onProperty linkml:pattern ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:UnitOfMeasure ; - owl:onProperty qudt:unit ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:minimum_value ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:pattern ], + owl:onProperty linkml:equals_string ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousTypeExpression ; owl:onProperty linkml:any_of ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:equals_string_in ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Integer ; + owl:onProperty linkml:equals_number ], linkml:Expression, linkml:mixin . @@ -1664,16 +1664,16 @@ linkml:ClassExpression a owl:Class, rdfs:label "class_expression" ; rdfs:subClassOf [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:all_of ], + owl:onProperty linkml:none_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:any_of ], + owl:onProperty linkml:exactly_one_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:exactly_one_of ], + owl:onProperty linkml:all_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:none_of ], + owl:onProperty linkml:any_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:SlotDefinition ; owl:onProperty linkml:slot_conditions ], @@ -1684,35 +1684,13 @@ linkml:ImportExpression a owl:Class, linkml:ClassDefinition ; rdfs:label "import_expression" ; rdfs:subClassOf [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:relatedMatch ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty skos:definition ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:exactMatch ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:closeMatch ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:SubsetDefinition ; - owl:onProperty OIO:inSubset ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Setting ; - owl:onProperty linkml:import_map ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_possible_replacement ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:mappingRelation ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uri ; - owl:onProperty skos:inScheme ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Ncname ; - owl:onProperty linkml:import_as ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:deprecated ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; owl:onProperty linkml:todos ], @@ -1720,43 +1698,41 @@ linkml:ImportExpression a owl:Class, owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty skos:narrowMatch ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty sh:order ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:editorialNote ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; - owl:onProperty skos:note ], + owl:onProperty skos:altLabel ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty rdfs:seeAlso ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:mappingRelation ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty skos:broadMatch ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:deprecated ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:closeMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_exact_replacement ], + owl:onClass linkml:Ncname ; + owl:onProperty linkml:import_as ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Extension ; - owl:onProperty linkml:extensions ], + owl:allValuesFrom linkml:Setting ; + owl:onProperty linkml:import_map ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:imported_from ], + owl:onClass linkml:Uri ; + owl:onProperty skos:inScheme ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:StructuredAlias ; + owl:onProperty skosxl:altLabel ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty schema:inLanguage ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty rdfs:seeAlso ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Annotation ; - owl:onProperty linkml:annotations ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Example ; - owl:onProperty linkml:examples ], + owl:onProperty linkml:imported_from ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; @@ -1765,26 +1741,50 @@ linkml:ImportExpression a owl:Class, owl:onClass linkml:Uriorcurie ; owl:onProperty linkml:import_from ; owl:qualifiedCardinality 1 ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Integer ; + owl:onProperty sh:order ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; owl:onProperty dcterms:source ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_exact_replacement ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty skos:note ], [ a owl:Restriction ; owl:allValuesFrom linkml:AltDescription ; owl:onProperty linkml:alt_descriptions ], [ a owl:Restriction ; - owl:allValuesFrom linkml:StructuredAlias ; - owl:onProperty skosxl:altLabel ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:relatedMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:altLabel ], + owl:allValuesFrom linkml:Extension ; + owl:onProperty linkml:extensions ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_possible_replacement ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:exactMatch ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Annotation ; + owl:onProperty linkml:annotations ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty skos:definition ], + owl:onProperty schema:inLanguage ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:editorialNote ], + owl:allValuesFrom linkml:Example ; + owl:onProperty linkml:examples ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:SubsetDefinition ; + owl:onProperty OIO:inSubset ], linkml:Annotatable, linkml:CommonMetadata, linkml:Extensible ; @@ -1794,12 +1794,12 @@ linkml:LocalName a owl:Class, linkml:ClassDefinition ; rdfs:label "local_name" ; rdfs:subClassOf [ a owl:Restriction ; - owl:onClass linkml:String ; - owl:onProperty skos:altLabel ; - owl:qualifiedCardinality 1 ], - [ a owl:Restriction ; owl:onClass linkml:Ncname ; owl:onProperty linkml:local_name_source ; + owl:qualifiedCardinality 1 ], + [ a owl:Restriction ; + owl:onClass linkml:String ; + owl:onProperty skos:altLabel ; owl:qualifiedCardinality 1 ] ; skos:definition "an attributed label" . @@ -1808,103 +1808,103 @@ linkml:SlotExpression a owl:Class, rdfs:label "slot_expression" ; rdfs:subClassOf [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:pattern ], + owl:onClass linkml:EnumExpression ; + owl:onProperty linkml:enum_range ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:AnonymousClassExpression ; - owl:onProperty linkml:range_expression ], + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:all_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:maximum_cardinality ], + owl:onClass linkml:String ; + owl:onProperty linkml:implicit_prefix ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:recommended ], + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:none_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PresenceEnum ; - owl:onProperty linkml:value_presence ], + owl:onClass linkml:AnonymousSlotExpression ; + owl:onProperty linkml:has_member ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:equals_expression ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:minimum_cardinality ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:UnitOfMeasure ; owl:onProperty qudt:unit ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PatternExpression ; - owl:onProperty linkml:structured_pattern ], + owl:onClass linkml:PresenceEnum ; + owl:onProperty linkml:value_presence ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; - owl:onProperty linkml:equals_number ], + owl:onProperty linkml:maximum_cardinality ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:exactly_one_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; owl:onProperty linkml:maximum_value ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:all_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty linkml:equals_string ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:minimum_cardinality ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:required ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:inlined ], + owl:onClass linkml:String ; + owl:onProperty linkml:pattern ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:equals_string_in ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:exactly_one_of ], + owl:onProperty linkml:any_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Element ; - owl:onProperty linkml:range ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:inlined_as_list ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:equals_string_in ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:PatternExpression ; + owl:onProperty linkml:structured_pattern ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:implicit_prefix ], + owl:onProperty linkml:equals_expression ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:AnonymousSlotExpression ; - owl:onProperty linkml:all_members ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:minimum_value ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:EnumExpression ; - owl:onProperty linkml:enum_range ], + owl:onClass linkml:Element ; + owl:onProperty linkml:range ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:any_of ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Boolean ; + owl:onProperty linkml:recommended ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:AnonymousSlotExpression ; - owl:onProperty linkml:has_member ], + owl:onClass linkml:AnonymousClassExpression ; + owl:onProperty linkml:range_expression ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; - owl:onProperty linkml:minimum_value ], + owl:onProperty linkml:equals_number ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:inlined_as_list ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:none_of ], + owl:onClass linkml:AnonymousSlotExpression ; + owl:onProperty linkml:all_members ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:required ], + owl:onProperty linkml:inlined ], linkml:Expression, linkml:mixin ; skos:definition "an expression that constrains the range of values a slot can take" . @@ -1913,106 +1913,106 @@ linkml:UniqueKey a owl:Class, linkml:ClassDefinition ; rdfs:label "unique_key" ; rdfs:subClassOf [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:mappingRelation ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:imported_from ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_exact_replacement ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:altLabel ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:exactMatch ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:editorialNote ], + owl:onProperty dcterms:source ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty schema:inLanguage ], + owl:onClass linkml:Uri ; + owl:onProperty skos:inScheme ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:imported_from ], + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_possible_replacement ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:relatedMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; owl:onProperty sh:order ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:deprecated ], - [ a owl:Restriction ; - owl:onClass linkml:String ; - owl:onProperty linkml:unique_key_name ; - owl:qualifiedCardinality 1 ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:todos ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AltDescription ; - owl:onProperty linkml:alt_descriptions ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty skos:broadMatch ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty dcterms:title ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:closeMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uri ; - owl:onProperty skos:inScheme ], + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_exact_replacement ], [ a owl:Restriction ; - owl:allValuesFrom linkml:StructuredAlias ; - owl:onProperty skosxl:altLabel ], + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:todos ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_possible_replacement ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:note ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Annotation ; - owl:onProperty linkml:annotations ], + owl:allValuesFrom linkml:Example ; + owl:onProperty linkml:examples ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty skos:definition ], + owl:allValuesFrom linkml:Annotation ; + owl:onProperty linkml:annotations ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty dcterms:source ], + owl:allValuesFrom linkml:AltDescription ; + owl:onProperty linkml:alt_descriptions ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:relatedMatch ], + owl:onProperty rdfs:seeAlso ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:narrowMatch ], + owl:onProperty skos:exactMatch ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:deprecated ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:SubsetDefinition ; + owl:onProperty OIO:inSubset ], [ a owl:Class ; owl:intersectionOf ( [ a owl:Restriction ; owl:allValuesFrom linkml:SlotDefinition ; owl:onProperty linkml:unique_key_slots ] [ a owl:Restriction ; owl:onProperty linkml:unique_key_slots ; owl:someValuesFrom linkml:SlotDefinition ] ) ], + [ a owl:Restriction ; + owl:onClass linkml:String ; + owl:onProperty linkml:unique_key_name ; + owl:qualifiedCardinality 1 ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; - owl:onProperty skos:note ], + owl:onProperty skos:editorialNote ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:closeMatch ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:altLabel ], [ a owl:Restriction ; - owl:allValuesFrom linkml:SubsetDefinition ; - owl:onProperty OIO:inSubset ], + owl:allValuesFrom linkml:StructuredAlias ; + owl:onProperty skosxl:altLabel ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Example ; - owl:onProperty linkml:examples ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:mappingRelation ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty skos:definition ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty rdfs:seeAlso ], + owl:onProperty skos:narrowMatch ], [ a owl:Restriction ; owl:allValuesFrom linkml:Extension ; owl:onProperty linkml:extensions ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty dcterms:title ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty schema:inLanguage ], linkml:Annotatable, linkml:CommonMetadata, linkml:Extensible ; @@ -2076,12 +2076,12 @@ linkml:MatchQuery a owl:Class, rdfs:label "match_query" ; rdfs:subClassOf [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:source_ontology ], + owl:onClass linkml:String ; + owl:onProperty linkml:identifier_pattern ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:identifier_pattern ] ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:source_ontology ] ; skos:definition "A query that is used on an enum expression to dynamically obtain a set of permissivle values via a query that matches on properties of the external concepts" . linkml:equals_number a owl:ObjectProperty, @@ -2153,124 +2153,124 @@ linkml:PathExpression a owl:Class, linkml:ClassDefinition ; rdfs:label "path_expression" ; rdfs:subClassOf [ a owl:Restriction ; - owl:allValuesFrom linkml:Extension ; - owl:onProperty linkml:extensions ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:note ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:todos ], - [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:AnonymousClassExpression ; owl:onProperty linkml:range_expression ], [ a owl:Restriction ; - owl:allValuesFrom linkml:PathExpression ; - owl:onProperty linkml:none_of ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:closeMatch ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:deprecated ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:relatedMatch ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:SubsetDefinition ; - owl:onProperty OIO:inSubset ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:reversed ], + owl:allValuesFrom linkml:Example ; + owl:onProperty linkml:examples ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty skos:definition ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:PathExpression ; - owl:onProperty linkml:all_of ], + owl:onClass linkml:SlotDefinition ; + owl:onProperty linkml:traverse ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; owl:onProperty linkml:deprecated_element_has_exact_replacement ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PathExpression ; - owl:onProperty linkml:followed_by ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty schema:inLanguage ], + owl:onProperty linkml:deprecated ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:SlotDefinition ; - owl:onProperty linkml:traverse ], + owl:onClass linkml:String ; + owl:onProperty skos:definition ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_possible_replacement ], + owl:onProperty dcterms:source ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:PathExpression ; + owl:onProperty linkml:exactly_one_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; owl:onProperty skos:editorialNote ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty skos:note ], [ a owl:Restriction ; owl:allValuesFrom linkml:PathExpression ; - owl:onProperty linkml:exactly_one_of ], + owl:onProperty linkml:all_of ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty dcterms:source ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:narrowMatch ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Extension ; + owl:onProperty linkml:extensions ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; owl:onProperty sh:order ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AltDescription ; - owl:onProperty linkml:alt_descriptions ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uri ; + owl:onProperty skos:inScheme ], [ a owl:Restriction ; - owl:allValuesFrom linkml:StructuredAlias ; - owl:onProperty skosxl:altLabel ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:closeMatch ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty schema:inLanguage ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:broadMatch ], + owl:onProperty skos:relatedMatch ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:PathExpression ; + owl:onProperty linkml:any_of ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:PathExpression ; + owl:onProperty linkml:none_of ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:todos ], [ a owl:Restriction ; owl:allValuesFrom linkml:Annotation ; owl:onProperty linkml:annotations ], [ a owl:Restriction ; - owl:allValuesFrom linkml:PathExpression ; - owl:onProperty linkml:any_of ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:mappingRelation ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:narrowMatch ], + owl:onProperty skos:broadMatch ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty dcterms:title ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:altLabel ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uri ; - owl:onProperty skos:inScheme ], + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_possible_replacement ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty rdfs:seeAlso ], + owl:allValuesFrom linkml:SubsetDefinition ; + owl:onProperty OIO:inSubset ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty skos:exactMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:altLabel ], + owl:allValuesFrom linkml:AltDescription ; + owl:onProperty linkml:alt_descriptions ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Example ; - owl:onProperty linkml:examples ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:PathExpression ; + owl:onProperty linkml:followed_by ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty linkml:imported_from ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:mappingRelation ], + owl:onProperty rdfs:seeAlso ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:StructuredAlias ; + owl:onProperty skosxl:altLabel ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Boolean ; + owl:onProperty linkml:reversed ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty dcterms:title ], linkml:Annotatable, linkml:CommonMetadata, linkml:Expression, @@ -2299,12 +2299,12 @@ linkml:Setting a owl:Class, linkml:ClassDefinition ; rdfs:label "setting" ; rdfs:subClassOf [ a owl:Restriction ; - owl:onClass linkml:Ncname ; - owl:onProperty linkml:setting_key ; - owl:qualifiedCardinality 1 ], - [ a owl:Restriction ; owl:onClass linkml:String ; owl:onProperty linkml:setting_value ; + owl:qualifiedCardinality 1 ], + [ a owl:Restriction ; + owl:onClass linkml:Ncname ; + owl:onProperty linkml:setting_key ; owl:qualifiedCardinality 1 ] ; skos:definition "assignment of a key to a value" . @@ -2319,19 +2319,19 @@ linkml:AnonymousEnumExpression a owl:Class, linkml:ClassDefinition ; rdfs:label "anonymous_enum_expression" ; rdfs:subClassOf [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousEnumExpression ; + owl:onProperty linkml:minus ], + [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty linkml:concepts ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:code_set_version ], + owl:onProperty linkml:code_set_tag ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:code_set ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousEnumExpression ; - owl:onProperty linkml:include ], + owl:onClass linkml:PvFormulaOptions ; + owl:onProperty linkml:pv_formula ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:ReachabilityQuery ; @@ -2340,23 +2340,23 @@ linkml:AnonymousEnumExpression a owl:Class, owl:maxQualifiedCardinality 1 ; owl:onClass linkml:MatchQuery ; owl:onProperty linkml:matches ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:EnumDefinition ; + owl:onProperty linkml:inherits ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PvFormulaOptions ; - owl:onProperty linkml:pv_formula ], + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:code_set ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:code_set_tag ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:EnumDefinition ; - owl:onProperty linkml:inherits ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousEnumExpression ; - owl:onProperty linkml:minus ], + owl:onProperty linkml:code_set_version ], [ a owl:Restriction ; owl:allValuesFrom linkml:PermissibleValue ; owl:onProperty linkml:permissible_values ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousEnumExpression ; + owl:onProperty linkml:include ], linkml:EnumExpression ; skos:definition "An enum_expression that is not named" . @@ -2364,115 +2364,115 @@ linkml:PermissibleValue a owl:Class, linkml:ClassDefinition ; rdfs:label "permissible_value" ; rdfs:subClassOf [ a owl:Restriction ; - owl:allValuesFrom linkml:Extension ; - owl:onProperty linkml:extensions ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:todos ], - [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:relatedMatch ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty dcterms:title ], + owl:onProperty skos:mappingRelation ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:narrowMatch ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty schema:inLanguage ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PermissibleValue ; - owl:onProperty linkml:is_a ], + owl:onProperty skos:relatedMatch ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:imported_from ], + owl:allValuesFrom linkml:PermissibleValue ; + owl:onProperty linkml:mixins ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty sh:order ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Annotation ; - owl:onProperty linkml:annotations ], + owl:onClass linkml:Uriorcurie ; + owl:onProperty dcterms:source ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:mappingRelation ], + owl:onProperty skos:broadMatch ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty skos:altLabel ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Extension ; + owl:onProperty linkml:extensions ], [ a owl:Restriction ; owl:allValuesFrom linkml:StructuredAlias ; owl:onProperty skosxl:altLabel ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty rdfs:seeAlso ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:broadMatch ], + owl:onProperty skos:exactMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:closeMatch ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:meaning ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; - owl:onProperty skos:editorialNote ], + owl:onProperty linkml:todos ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:meaning ], + owl:onClass linkml:String ; + owl:onProperty dcterms:title ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:closeMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uri ; owl:onProperty skos:inScheme ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty schema:inLanguage ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:imported_from ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_exact_replacement ], [ a owl:Restriction ; owl:allValuesFrom linkml:SubsetDefinition ; owl:onProperty OIO:inSubset ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:note ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:deprecated ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:UnitOfMeasure ; owl:onProperty qudt:unit ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_possible_replacement ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AltDescription ; - owl:onProperty linkml:alt_descriptions ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Example ; - owl:onProperty linkml:examples ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:note ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:exactMatch ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:editorialNote ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_exact_replacement ], + owl:allValuesFrom linkml:Annotation ; + owl:onProperty linkml:annotations ], [ a owl:Restriction ; owl:onClass linkml:String ; owl:onProperty linkml:text ; owl:qualifiedCardinality 1 ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:deprecated ], + owl:onClass linkml:PermissibleValue ; + owl:onProperty linkml:is_a ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty skos:definition ], + owl:onClass linkml:Integer ; + owl:onProperty sh:order ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:altLabel ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:narrowMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:PermissibleValue ; - owl:onProperty linkml:mixins ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty rdfs:seeAlso ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; - owl:onProperty dcterms:source ], + owl:onProperty linkml:deprecated_element_has_possible_replacement ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty skos:definition ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AltDescription ; + owl:onProperty linkml:alt_descriptions ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Example ; + owl:onProperty linkml:examples ], linkml:Annotatable, linkml:CommonMetadata, linkml:Extensible ; @@ -2502,69 +2502,63 @@ linkml:CommonMetadata a owl:Class, linkml:ClassDefinition ; rdfs:label "common_metadata" ; rdfs:subClassOf [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:note ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Example ; - owl:onProperty linkml:examples ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty dcterms:source ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty skos:mappingRelation ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:editorialNote ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_possible_replacement ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; - owl:onProperty linkml:todos ], + owl:onProperty skos:altLabel ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:relatedMatch ], + owl:onProperty rdfs:seeAlso ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:closeMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; owl:onProperty sh:order ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:SubsetDefinition ; - owl:onProperty OIO:inSubset ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty rdfs:seeAlso ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uri ; - owl:onProperty skos:inScheme ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:StructuredAlias ; - owl:onProperty skosxl:altLabel ], + owl:onClass linkml:String ; + owl:onProperty linkml:deprecated ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_exact_replacement ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:editorialNote ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty skos:definition ], + owl:onProperty schema:inLanguage ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:altLabel ], + owl:allValuesFrom linkml:SubsetDefinition ; + owl:onProperty OIO:inSubset ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty dcterms:source ], + owl:onClass linkml:Uri ; + owl:onProperty skos:inScheme ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty schema:inLanguage ], + owl:onProperty skos:definition ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:narrowMatch ], + owl:onProperty skos:exactMatch ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:closeMatch ], + owl:onProperty skos:relatedMatch ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_possible_replacement ], + owl:allValuesFrom linkml:AltDescription ; + owl:onProperty linkml:alt_descriptions ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:broadMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; @@ -2572,20 +2566,26 @@ linkml:CommonMetadata a owl:Class, [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:deprecated ], + owl:onProperty dcterms:title ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:exactMatch ], + owl:allValuesFrom linkml:Example ; + owl:onProperty linkml:examples ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty dcterms:title ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:note ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AltDescription ; - owl:onProperty linkml:alt_descriptions ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_exact_replacement ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:broadMatch ], + owl:onProperty skos:narrowMatch ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:StructuredAlias ; + owl:onProperty skosxl:altLabel ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:todos ], linkml:mixin ; skos:definition "Generic metadata shared across definitions" . @@ -2594,53 +2594,41 @@ linkml:PatternExpression a owl:Class, rdfs:label "pattern_expression" ; rdfs:subClassOf [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uri ; - owl:onProperty skos:inScheme ], + owl:onClass linkml:String ; + owl:onProperty dcterms:title ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:exactMatch ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:note ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_exact_replacement ], + owl:onProperty dcterms:source ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:todos ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:imported_from ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:broadMatch ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Extension ; - owl:onProperty linkml:extensions ], + owl:onProperty skos:narrowMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:note ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:broadMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty schema:inLanguage ], + owl:onClass linkml:Integer ; + owl:onProperty sh:order ], [ a owl:Restriction ; owl:allValuesFrom linkml:Example ; owl:onProperty linkml:examples ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; - owl:onProperty skos:altLabel ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Annotation ; - owl:onProperty linkml:annotations ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:mappingRelation ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty dcterms:source ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:StructuredAlias ; - owl:onProperty skosxl:altLabel ], + owl:onProperty linkml:todos ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; - owl:onProperty skos:editorialNote ], + owl:onProperty skos:altLabel ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Extension ; + owl:onProperty linkml:extensions ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; @@ -2650,51 +2638,63 @@ linkml:PatternExpression a owl:Class, owl:onClass linkml:Uriorcurie ; owl:onProperty linkml:deprecated_element_has_possible_replacement ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:relatedMatch ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty skos:definition ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty rdfs:seeAlso ], + owl:onProperty skos:relatedMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty linkml:syntax ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:closeMatch ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:deprecated ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:SubsetDefinition ; + owl:onProperty OIO:inSubset ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_exact_replacement ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:imported_from ], + owl:onProperty schema:inLanguage ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty skos:editorialNote ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uri ; + owl:onProperty skos:inScheme ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:StructuredAlias ; + owl:onProperty skosxl:altLabel ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty sh:order ], + owl:allValuesFrom linkml:Annotation ; + owl:onProperty linkml:annotations ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:narrowMatch ], + owl:onProperty rdfs:seeAlso ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:exactMatch ], [ a owl:Restriction ; owl:allValuesFrom linkml:AltDescription ; owl:onProperty linkml:alt_descriptions ], [ a owl:Restriction ; - owl:allValuesFrom linkml:SubsetDefinition ; - owl:onProperty OIO:inSubset ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:closeMatch ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty skos:definition ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:mappingRelation ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; owl:onProperty linkml:interpolated ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty dcterms:title ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:deprecated ], linkml:Annotatable, linkml:CommonMetadata, linkml:Extensible ; @@ -2704,14 +2704,6 @@ linkml:ReachabilityQuery a owl:Class, linkml:ClassDefinition ; rdfs:label "reachability_query" ; rdfs:subClassOf [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:is_direct ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:include_self ], - [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; owl:onProperty linkml:traverse_up ], @@ -2721,10 +2713,18 @@ linkml:ReachabilityQuery a owl:Class, owl:onProperty linkml:source_ontology ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty linkml:source_nodes ], + owl:onProperty linkml:relationship_types ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Boolean ; + owl:onProperty linkml:is_direct ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty linkml:relationship_types ] ; + owl:onProperty linkml:source_nodes ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Boolean ; + owl:onProperty linkml:include_self ] ; skos:definition "A query that is used on an enum expression to dynamically obtain a set of permissible values via walking from a set of source nodes to a set of descendants or ancestors over a set of relationship types" . linkml:UnitOfMeasure a owl:Class, @@ -2733,26 +2733,26 @@ linkml:UnitOfMeasure a owl:Class, rdfs:subClassOf [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:derivation ], + owl:onProperty qudt:symbol ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty qudt:ucumCode ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:exactMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty qudt:iec61360Code ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty qudt:symbol ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; owl:onProperty qudt:hasQuantityKind ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:exactMatch ] ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:derivation ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty qudt:ucumCode ] ; skos:definition "A unit of measure, or unit, is a particular quantity value that has been chosen as a scale for measuring other quantities the same kind (more generally of equivalent dimension)." ; skos:exactMatch qudt:Unit . @@ -2963,17 +2963,6 @@ linkml:EnumDefinition a owl:Class, linkml:ClassDefinition ; rdfs:label "enum_definition" ; rdfs:subClassOf [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousEnumExpression ; - owl:onProperty linkml:include ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:enum_uri ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:code_set ], - [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:PvFormulaOptions ; owl:onProperty linkml:pv_formula ], @@ -2982,19 +2971,29 @@ linkml:EnumDefinition a owl:Class, owl:onClass linkml:ReachabilityQuery ; owl:onProperty linkml:reachable_from ], [ a owl:Restriction ; - owl:allValuesFrom linkml:PermissibleValue ; - owl:onProperty linkml:permissible_values ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:code_set ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty linkml:code_set_tag ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty linkml:concepts ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousEnumExpression ; + owl:onProperty linkml:minus ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:PermissibleValue ; + owl:onProperty linkml:permissible_values ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty linkml:code_set_version ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty linkml:concepts ], + owl:allValuesFrom linkml:AnonymousEnumExpression ; + owl:onProperty linkml:include ], [ a owl:Restriction ; owl:allValuesFrom linkml:EnumDefinition ; owl:onProperty linkml:inherits ], @@ -3003,8 +3002,9 @@ linkml:EnumDefinition a owl:Class, owl:onClass linkml:MatchQuery ; owl:onProperty linkml:matches ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousEnumExpression ; - owl:onProperty linkml:minus ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:enum_uri ], linkml:Definition, linkml:EnumExpression ; skos:altLabel "Terminology Value Set", @@ -3029,67 +3029,67 @@ linkml:TypeDefinition a owl:Class, linkml:ClassDefinition ; rdfs:label "type_definition" ; rdfs:subClassOf [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousTypeExpression ; - owl:onProperty linkml:all_of ], - [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:UnitOfMeasure ; - owl:onProperty qudt:unit ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:minimum_value ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:TypeDefinition ; - owl:onProperty linkml:typeof ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousTypeExpression ; - owl:onProperty linkml:any_of ], + owl:onClass linkml:PatternExpression ; + owl:onProperty linkml:structured_pattern ], [ a owl:Restriction ; - owl:allValuesFrom linkml:TypeDefinition ; - owl:onProperty linkml:union_of ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:implicit_prefix ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PatternExpression ; - owl:onProperty linkml:structured_pattern ], + owl:onClass linkml:String ; + owl:onProperty linkml:base ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:maximum_value ], + owl:onClass linkml:String ; + owl:onProperty linkml:pattern ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:TypeDefinition ; + owl:onProperty linkml:union_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousTypeExpression ; owl:onProperty linkml:exactly_one_of ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:minimum_value ], + owl:allValuesFrom linkml:AnonymousTypeExpression ; + owl:onProperty linkml:none_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:uri ], + owl:onClass linkml:TypeDefinition ; + owl:onProperty linkml:typeof ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; owl:onProperty linkml:equals_number ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:equals_string_in ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousTypeExpression ; - owl:onProperty linkml:none_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:base ], + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:uri ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty linkml:equals_string ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousTypeExpression ; + owl:onProperty linkml:any_of ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousTypeExpression ; + owl:onProperty linkml:all_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:implicit_prefix ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:maximum_value ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:pattern ], + owl:onClass linkml:UnitOfMeasure ; + owl:onProperty qudt:unit ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:equals_string_in ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; @@ -3127,11 +3127,11 @@ linkml:AltDescription a owl:Class, rdfs:label "alt_description" ; rdfs:subClassOf [ a owl:Restriction ; owl:onClass linkml:String ; - owl:onProperty linkml:source ; + owl:onProperty linkml:description ; owl:qualifiedCardinality 1 ], [ a owl:Restriction ; owl:onClass linkml:String ; - owl:onProperty linkml:description ; + owl:onProperty linkml:source ; owl:qualifiedCardinality 1 ] ; skos:definition "an attributed description" . @@ -3158,52 +3158,52 @@ linkml:AnonymousTypeExpression a owl:Class, linkml:ClassDefinition ; rdfs:label "anonymous_type_expression" ; rdfs:subClassOf [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousTypeExpression ; - owl:onProperty linkml:exactly_one_of ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:equals_string_in ], - [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:UnitOfMeasure ; - owl:onProperty qudt:unit ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:equals_number ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PatternExpression ; - owl:onProperty linkml:structured_pattern ], + owl:onClass linkml:String ; + owl:onProperty linkml:equals_string ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty linkml:implicit_prefix ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:equals_string_in ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty linkml:pattern ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:minimum_value ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousTypeExpression ; owl:onProperty linkml:all_of ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:PatternExpression ; + owl:onProperty linkml:structured_pattern ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; - owl:onProperty linkml:equals_number ], + owl:onProperty linkml:maximum_value ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousTypeExpression ; + owl:onProperty linkml:exactly_one_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousTypeExpression ; owl:onProperty linkml:any_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; - owl:onProperty linkml:maximum_value ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:equals_string ], + owl:onProperty linkml:minimum_value ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousTypeExpression ; owl:onProperty linkml:none_of ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:UnitOfMeasure ; + owl:onProperty qudt:unit ], linkml:TypeExpression . linkml:extensions a owl:ObjectProperty, @@ -3247,107 +3247,107 @@ linkml:StructuredAlias a owl:Class, linkml:ClassDefinition ; rdfs:label "structured_alias" ; rdfs:subClassOf [ a owl:Restriction ; - owl:allValuesFrom linkml:SubsetDefinition ; - owl:onProperty OIO:inSubset ], + owl:allValuesFrom linkml:Example ; + owl:onProperty linkml:examples ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:relatedMatch ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty dcterms:source ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:AliasPredicateEnum ; + owl:onProperty rdf:predicate ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Integer ; + owl:onProperty sh:order ], + [ a owl:Restriction ; + owl:onClass linkml:String ; + owl:onProperty skosxl:literalForm ; + owl:qualifiedCardinality 1 ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty dcterms:title ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:closeMatch ], + owl:onProperty skos:relatedMatch ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:narrowMatch ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_exact_replacement ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty skos:note ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty linkml:imported_from ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty sh:order ], + owl:onClass linkml:String ; + owl:onProperty skos:definition ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Extension ; + owl:onProperty linkml:extensions ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:StructuredAlias ; + owl:onProperty skosxl:altLabel ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AltDescription ; + owl:onProperty linkml:alt_descriptions ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty skos:altLabel ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:mappingRelation ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; owl:onProperty schema:inLanguage ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:altLabel ], [ a owl:Restriction ; owl:allValuesFrom linkml:Annotation ; owl:onProperty linkml:annotations ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty dcterms:source ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_exact_replacement ], + owl:onClass linkml:String ; + owl:onProperty linkml:deprecated ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:mappingRelation ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:editorialNote ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Example ; - owl:onProperty linkml:examples ], + owl:onProperty dcterms:subject ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:exactMatch ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_possible_replacement ], + owl:onProperty rdfs:seeAlso ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:narrowMatch ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:StructuredAlias ; - owl:onProperty skosxl:altLabel ], + owl:onProperty skos:exactMatch ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; owl:onProperty linkml:todos ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:note ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:AliasPredicateEnum ; - owl:onProperty rdf:predicate ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty skos:broadMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty dcterms:subject ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:editorialNote ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uri ; owl:onProperty skos:inScheme ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AltDescription ; - owl:onProperty linkml:alt_descriptions ], - [ a owl:Restriction ; - owl:onClass linkml:String ; - owl:onProperty skosxl:literalForm ; - owl:qualifiedCardinality 1 ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_possible_replacement ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty rdfs:seeAlso ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Extension ; - owl:onProperty linkml:extensions ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty skos:definition ], + owl:onProperty skos:closeMatch ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:deprecated ], + owl:allValuesFrom linkml:SubsetDefinition ; + owl:onProperty OIO:inSubset ], linkml:Annotatable, linkml:CommonMetadata, linkml:Expression, @@ -3376,16 +3376,16 @@ linkml:Extension a owl:Class, linkml:ClassDefinition ; rdfs:label "extension" ; rdfs:subClassOf [ a owl:Restriction ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:tag ; - owl:qualifiedCardinality 1 ], - [ a owl:Restriction ; owl:onClass linkml:String ; owl:onProperty linkml:value ; owl:qualifiedCardinality 1 ], [ a owl:Restriction ; owl:allValuesFrom linkml:Extension ; - owl:onProperty linkml:extensions ] ; + owl:onProperty linkml:extensions ], + [ a owl:Restriction ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:tag ; + owl:qualifiedCardinality 1 ] ; skos:definition "a tag/value pair used to add non-model information to an entry" . skos:mappingRelation a owl:ObjectProperty, @@ -3403,44 +3403,44 @@ linkml:EnumExpression a owl:Class, linkml:ClassDefinition ; rdfs:label "enum_expression" ; rdfs:subClassOf [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:MatchQuery ; + owl:onProperty linkml:matches ], + [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; owl:onProperty linkml:code_set ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:ReachabilityQuery ; - owl:onProperty linkml:reachable_from ], + owl:allValuesFrom linkml:EnumDefinition ; + owl:onProperty linkml:inherits ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:code_set_version ], + owl:allValuesFrom linkml:PermissibleValue ; + owl:onProperty linkml:permissible_values ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty linkml:concepts ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:code_set_tag ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousEnumExpression ; - owl:onProperty linkml:minus ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:EnumDefinition ; - owl:onProperty linkml:inherits ], + owl:onProperty linkml:code_set_version ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:PvFormulaOptions ; owl:onProperty linkml:pv_formula ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty linkml:concepts ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousEnumExpression ; owl:onProperty linkml:include ], [ a owl:Restriction ; - owl:allValuesFrom linkml:PermissibleValue ; - owl:onProperty linkml:permissible_values ], + owl:allValuesFrom linkml:AnonymousEnumExpression ; + owl:onProperty linkml:minus ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:MatchQuery ; - owl:onProperty linkml:matches ], + owl:onClass linkml:ReachabilityQuery ; + owl:onProperty linkml:reachable_from ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:code_set_tag ], linkml:Expression ; skos:definition "An expression that constrains the range of a slot" . @@ -3449,103 +3449,103 @@ linkml:AnonymousSlotExpression a owl:Class, rdfs:label "anonymous_slot_expression" ; rdfs:subClassOf [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:AnonymousSlotExpression ; - owl:onProperty linkml:all_members ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:maximum_cardinality ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:UnitOfMeasure ; - owl:onProperty qudt:unit ], + owl:onClass linkml:PresenceEnum ; + owl:onProperty linkml:value_presence ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:equals_number ], + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:all_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:minimum_cardinality ], + owl:onClass linkml:String ; + owl:onProperty linkml:equals_expression ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:AnonymousSlotExpression ; - owl:onProperty linkml:has_member ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:required ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:pattern ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:inlined ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; - owl:onProperty linkml:maximum_cardinality ], + owl:onProperty linkml:maximum_value ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; owl:onProperty linkml:recommended ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:minimum_value ], + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:none_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PatternExpression ; - owl:onProperty linkml:structured_pattern ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:equals_number ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PresenceEnum ; - owl:onProperty linkml:value_presence ], + owl:onClass linkml:Element ; + owl:onProperty linkml:range ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:implicit_prefix ], + owl:onClass linkml:AnonymousClassExpression ; + owl:onProperty linkml:range_expression ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:all_of ], + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:equals_string_in ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:inlined ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:any_of ], + owl:onProperty linkml:inlined_as_list ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:exactly_one_of ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:UnitOfMeasure ; + owl:onProperty qudt:unit ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:required ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:minimum_value ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:none_of ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:PatternExpression ; + owl:onProperty linkml:structured_pattern ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:equals_string ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:minimum_cardinality ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:EnumExpression ; owl:onProperty linkml:enum_range ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:any_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:maximum_value ], + owl:onClass linkml:AnonymousSlotExpression ; + owl:onProperty linkml:all_members ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:AnonymousClassExpression ; - owl:onProperty linkml:range_expression ], + owl:onClass linkml:String ; + owl:onProperty linkml:implicit_prefix ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Element ; - owl:onProperty linkml:range ], + owl:onClass linkml:String ; + owl:onProperty linkml:equals_string ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:equals_expression ], + owl:onProperty linkml:pattern ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:inlined_as_list ], + owl:onClass linkml:AnonymousSlotExpression ; + owl:onProperty linkml:has_member ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:equals_string_in ], + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:exactly_one_of ], linkml:AnonymousExpression, linkml:SlotExpression . @@ -3555,15 +3555,14 @@ linkml:SchemaDefinition a owl:Class, rdfs:seeAlso "https://en.wikipedia.org/wiki/Data_dictionary" ; rdfs:subClassOf [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Datetime ; - owl:onProperty linkml:generation_date ], + owl:onClass linkml:String ; + owl:onProperty linkml:metamodel_version ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty schema:keywords ], + owl:allValuesFrom linkml:SlotDefinition ; + owl:onProperty linkml:slots ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:TypeDefinition ; - owl:onProperty linkml:default_range ], + owl:allValuesFrom linkml:EnumDefinition ; + owl:onProperty linkml:enums ], [ a owl:Restriction ; owl:onClass linkml:Ncname ; owl:onProperty rdfs:label ; @@ -3571,72 +3570,73 @@ linkml:SchemaDefinition a owl:Class, [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:metamodel_version ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:ClassDefinition ; - owl:onProperty linkml:classes ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:SubsetDefinition ; - owl:onProperty linkml:subsets ], + owl:onProperty linkml:source_file ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:source_file_size ], + owl:onClass linkml:Uri ; + owl:onProperty linkml:id ; + owl:qualifiedCardinality 1 ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:slot_names_unique ], + owl:onClass linkml:String ; + owl:onProperty pav:version ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Datetime ; - owl:onProperty linkml:source_file_date ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:TypeDefinition ; - owl:onProperty linkml:types ], + owl:onClass linkml:String ; + owl:onProperty dcterms:license ], [ a owl:Restriction ; - owl:allValuesFrom linkml:SlotDefinition ; - owl:onProperty linkml:slots ], + owl:allValuesFrom linkml:String ; + owl:onProperty schema:keywords ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:source_file ], + owl:allValuesFrom linkml:Prefix ; + owl:onProperty sh:declare ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty pav:version ], + owl:onClass linkml:Datetime ; + owl:onProperty linkml:generation_date ], [ a owl:Restriction ; - owl:allValuesFrom linkml:EnumDefinition ; - owl:onProperty linkml:enums ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Datetime ; + owl:onProperty linkml:source_file_date ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty dcterms:subject ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Setting ; + owl:onProperty linkml:settings ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:SubsetDefinition ; + owl:onProperty linkml:subsets ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; owl:onProperty linkml:default_curi_maps ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Setting ; - owl:onProperty linkml:settings ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:default_prefix ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:TypeDefinition ; + owl:onProperty linkml:types ], [ a owl:Restriction ; owl:allValuesFrom linkml:Ncname ; owl:onProperty linkml:emit_prefixes ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:ClassDefinition ; + owl:onProperty linkml:classes ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty dcterms:license ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:slot_names_unique ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:default_prefix ], + owl:onClass linkml:TypeDefinition ; + owl:onProperty linkml:default_range ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Integer ; + owl:onProperty linkml:source_file_size ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty linkml:imports ], - [ a owl:Restriction ; - owl:onClass linkml:Uri ; - owl:onProperty linkml:id ; - owl:qualifiedCardinality 1 ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Prefix ; - owl:onProperty sh:declare ], linkml:Element ; skos:altLabel "data dictionary" ; skos:closeMatch qb:ComponentSet ; @@ -3654,16 +3654,16 @@ linkml:AnonymousClassExpression a owl:Class, owl:onProperty linkml:is_a ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:exactly_one_of ], + owl:onProperty linkml:any_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:all_of ], + owl:onProperty linkml:none_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:any_of ], + owl:onProperty linkml:exactly_one_of ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:none_of ], + owl:onProperty linkml:all_of ], linkml:AnonymousExpression, linkml:ClassExpression . @@ -3675,16 +3675,6 @@ linkml:Definition a owl:Class, owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; owl:onProperty oslc:modifiedBy ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Definition ; - owl:onProperty linkml:apply_to ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Datetime ; - owl:onProperty pav:lastUpdatedOn ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty linkml:values_from ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; @@ -3692,30 +3682,40 @@ linkml:Definition a owl:Class, [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Datetime ; - owl:onProperty pav:createdOn ], + owl:onProperty pav:lastUpdatedOn ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Definition ; + owl:onProperty linkml:mixins ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; owl:onProperty linkml:abstract ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:string_serialization ], + owl:allValuesFrom linkml:Definition ; + owl:onProperty linkml:apply_to ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; owl:onProperty bibo:status ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Definition ; - owl:onProperty linkml:mixins ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Datetime ; + owl:onProperty pav:createdOn ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Definition ; owl:onProperty linkml:is_a ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty linkml:string_serialization ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; owl:onProperty linkml:mixin ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty linkml:values_from ], linkml:Element ; skos:definition "abstract base class for core metaclasses" . @@ -3724,114 +3724,114 @@ linkml:Element a owl:Class, rdfs:label "element" ; rdfs:seeAlso "https://en.wikipedia.org/wiki/Data_element" ; rdfs:subClassOf [ a owl:Restriction ; + owl:allValuesFrom linkml:Extension ; + owl:onProperty linkml:extensions ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Integer ; + owl:onProperty sh:order ], + [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty dcterms:conformsTo ], + owl:onProperty schema:inLanguage ], [ a owl:Restriction ; owl:allValuesFrom linkml:String ; - owl:onProperty skos:note ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:exactMatch ], + owl:onProperty skos:editorialNote ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:closeMatch ], + owl:allValuesFrom linkml:Annotation ; + owl:onProperty linkml:annotations ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:imported_from ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:note ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty dcterms:source ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:broadMatch ], [ a owl:Restriction ; owl:allValuesFrom linkml:StructuredAlias ; owl:onProperty skosxl:altLabel ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AltDescription ; - owl:onProperty linkml:alt_descriptions ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:mappingRelation ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:editorialNote ], + owl:allValuesFrom linkml:Example ; + owl:onProperty linkml:examples ], [ a owl:Restriction ; owl:allValuesFrom linkml:LocalName ; owl:onProperty linkml:local_names ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:todos ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; owl:onProperty linkml:definition_uri ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:broadMatch ], + owl:onProperty skos:exactMatch ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:narrowMatch ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:deprecated ], + owl:onProperty dcterms:title ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty skos:definition ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:Ncname ; - owl:onProperty linkml:id_prefixes ], + owl:onProperty linkml:deprecated ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty rdfs:seeAlso ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uri ; - owl:onProperty skos:inScheme ], + owl:onProperty skos:mappingRelation ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty schema:inLanguage ], + owl:onProperty linkml:imported_from ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Uriorcurie ; - owl:onProperty skos:narrowMatch ], + owl:allValuesFrom linkml:SubsetDefinition ; + owl:onProperty OIO:inSubset ], [ a owl:Restriction ; owl:allValuesFrom linkml:Uriorcurie ; owl:onProperty skos:relatedMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Example ; - owl:onProperty linkml:examples ], + owl:onClass linkml:String ; + owl:onProperty rdfs:label ; + owl:qualifiedCardinality 1 ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:deprecated_element_has_exact_replacement ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty rdfs:seeAlso ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Annotation ; - owl:onProperty linkml:annotations ], + owl:allValuesFrom linkml:Uriorcurie ; + owl:onProperty skos:closeMatch ], [ a owl:Restriction ; - owl:allValuesFrom linkml:SubsetDefinition ; - owl:onProperty OIO:inSubset ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty dcterms:conformsTo ], [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:todos ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uri ; + owl:onProperty skos:inScheme ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; owl:onProperty linkml:deprecated_element_has_possible_replacement ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty skos:altLabel ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty dcterms:title ], + owl:onProperty skos:definition ], [ a owl:Restriction ; - owl:onClass linkml:String ; - owl:onProperty rdfs:label ; - owl:qualifiedCardinality 1 ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty dcterms:source ], [ a owl:Restriction ; - owl:allValuesFrom linkml:Extension ; - owl:onProperty linkml:extensions ], + owl:allValuesFrom linkml:String ; + owl:onProperty skos:altLabel ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty sh:order ], + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:deprecated_element_has_exact_replacement ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:Ncname ; + owl:onProperty linkml:id_prefixes ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AltDescription ; + owl:onProperty linkml:alt_descriptions ], linkml:Annotatable, linkml:CommonMetadata, linkml:Extensible ; @@ -3843,81 +3843,81 @@ linkml:ClassDefinition a owl:Class, linkml:ClassDefinition ; rdfs:label "class_definition" ; rdfs:subClassOf [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:children_are_mutually_disjoint ], - [ a owl:Restriction ; owl:allValuesFrom linkml:SlotDefinition ; owl:onProperty linkml:slot_conditions ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:none_of ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:all_of ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:ClassDefinition ; - owl:onProperty linkml:disjoint_with ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:ClassDefinition ; + owl:onProperty linkml:is_a ], [ a owl:Restriction ; owl:allValuesFrom linkml:SlotDefinition ; owl:onProperty linkml:slot_usage ], [ a owl:Restriction ; - owl:allValuesFrom linkml:ClassDefinition ; - owl:onProperty linkml:union_of ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty linkml:class_uri ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:ClassDefinition ; - owl:onProperty linkml:mixins ], + owl:allValuesFrom linkml:UniqueKey ; + owl:onProperty linkml:unique_keys ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:any_of ], + owl:allValuesFrom linkml:SlotDefinition ; + owl:onProperty linkml:defining_slots ], [ a owl:Restriction ; owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:exactly_one_of ], + owl:onProperty linkml:classification_rules ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:tree_root ], + owl:onProperty linkml:children_are_mutually_disjoint ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousClassExpression ; - owl:onProperty linkml:classification_rules ], + owl:allValuesFrom linkml:SlotDefinition ; + owl:onProperty linkml:attributes ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:ClassDefinition ; - owl:onProperty linkml:is_a ], + owl:onClass linkml:Uriorcurie ; + owl:onProperty rdfs:subClassOf ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousClassExpression ; + owl:onProperty linkml:all_of ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:ClassDefinition ; + owl:onProperty linkml:apply_to ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; owl:onProperty linkml:slot_names_unique ], [ a owl:Restriction ; - owl:allValuesFrom linkml:ClassRule ; - owl:onProperty sh:rule ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:SlotDefinition ; - owl:onProperty linkml:defining_slots ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:UniqueKey ; - owl:onProperty linkml:unique_keys ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Uriorcurie ; + owl:onProperty linkml:class_uri ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; owl:onProperty linkml:represents_relationship ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Uriorcurie ; - owl:onProperty rdfs:subClassOf ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:tree_root ], [ a owl:Restriction ; owl:allValuesFrom linkml:SlotDefinition ; - owl:onProperty linkml:attributes ], + owl:onProperty linkml:slots ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:ClassRule ; + owl:onProperty sh:rule ], [ a owl:Restriction ; owl:allValuesFrom linkml:ClassDefinition ; - owl:onProperty linkml:apply_to ], + owl:onProperty linkml:union_of ], [ a owl:Restriction ; - owl:allValuesFrom linkml:SlotDefinition ; - owl:onProperty linkml:slots ], + owl:allValuesFrom linkml:AnonymousClassExpression ; + owl:onProperty linkml:none_of ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousClassExpression ; + owl:onProperty linkml:exactly_one_of ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:ClassDefinition ; + owl:onProperty linkml:mixins ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousClassExpression ; + owl:onProperty linkml:any_of ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:ClassDefinition ; + owl:onProperty linkml:disjoint_with ], linkml:ClassExpression, linkml:Definition ; skos:altLabel "message", @@ -3933,176 +3933,166 @@ linkml:SlotDefinition a owl:Class, rdfs:label "slot_definition" ; rdfs:subClassOf [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:is_usage_slot ], + owl:onClass linkml:String ; + owl:onProperty skos:altLabel ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Integer ; - owl:onProperty linkml:minimum_value ], + owl:onProperty linkml:maximum_cardinality ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:required ], + owl:onProperty linkml:symmetric ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:recommended ], + owl:onProperty linkml:multivalued ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:ClassDefinition ; + owl:onProperty linkml:domain_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:children_are_mutually_disjoint ], + owl:onClass linkml:String ; + owl:onProperty linkml:usage_slot_name ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:ifabsent ], + owl:onProperty linkml:role ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:inherited ], + owl:onProperty linkml:list_elements_ordered ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:none_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:identifier ], + owl:onProperty linkml:key ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:RelationalRoleEnum ; - owl:onProperty linkml:relational_role ], + owl:onClass linkml:PresenceEnum ; + owl:onProperty linkml:value_presence ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:usage_slot_name ], + owl:onProperty linkml:equals_string ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:symmetric ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:maximum_value ], [ a owl:Restriction ; - owl:allValuesFrom linkml:SlotDefinition ; - owl:onProperty linkml:union_of ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:PatternExpression ; + owl:onProperty linkml:structured_pattern ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:SlotDefinition ; owl:onProperty rdfs:subPropertyOf ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:EnumExpression ; - owl:onProperty linkml:enum_range ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:maximum_cardinality ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:equals_number ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:is_grouping_slot ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Element ; owl:onProperty linkml:range ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:SlotDefinition ; - owl:onProperty linkml:transitive_form_of ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:irreflexive ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:pattern ], + owl:onClass linkml:PathExpression ; + owl:onProperty linkml:path_rule ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:SlotDefinition ; + owl:onProperty linkml:disjoint_with ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:key ], + owl:onProperty linkml:inlined_as_list ], [ a owl:Restriction ; - owl:allValuesFrom linkml:ClassDefinition ; - owl:onProperty linkml:domain_of ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:AnonymousClassExpression ; + owl:onProperty linkml:range_expression ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:AnonymousSlotExpression ; - owl:onProperty linkml:has_member ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:identifier ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:exactly_one_of ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Boolean ; + owl:onProperty linkml:recommended ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:maximum_value ], + owl:onClass linkml:SlotDefinition ; + owl:onProperty owl:inverseOf ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:multivalued ], + owl:onProperty linkml:reflexive ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Definition ; - owl:onProperty linkml:owner ], + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:exactly_one_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:SlotDefinition ; - owl:onProperty linkml:reflexive_transitive_form_of ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:inlined ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PresenceEnum ; - owl:onProperty linkml:value_presence ], + owl:onClass linkml:UnitOfMeasure ; + owl:onProperty qudt:unit ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty skos:prefLabel ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:String ; - owl:onProperty linkml:equals_string_in ], + owl:onProperty linkml:readonly ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:AnonymousClassExpression ; - owl:onProperty linkml:range_expression ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:SlotDefinition ; - owl:onProperty linkml:mixins ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:is_usage_slot ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:SlotDefinition ; - owl:onProperty linkml:is_a ], + owl:onClass linkml:EnumExpression ; + owl:onProperty linkml:enum_range ], [ a owl:Restriction ; owl:allValuesFrom linkml:SlotDefinition ; owl:onProperty linkml:apply_to ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:UnitOfMeasure ; - owl:onProperty qudt:unit ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:equals_string ], + owl:onClass linkml:SlotDefinition ; + owl:onProperty linkml:is_a ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:equals_expression ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Integer ; - owl:onProperty linkml:minimum_cardinality ], + owl:onProperty linkml:implicit_prefix ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:inlined ], + owl:onProperty linkml:required ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:irreflexive ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:any_of ], + owl:onProperty linkml:children_are_mutually_disjoint ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:none_of ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:RelationalRoleEnum ; + owl:onProperty linkml:relational_role ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:reflexive ], + owl:onClass linkml:ClassDefinition ; + owl:onProperty linkml:domain ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:SlotDefinition ; owl:onProperty sh:group ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:any_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:asymmetric ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:minimum_cardinality ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Uriorcurie ; @@ -4110,81 +4100,91 @@ linkml:SlotDefinition a owl:Class, [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:list_elements_unique ], + owl:onProperty linkml:transitive ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:list_elements_ordered ], + owl:onProperty linkml:inherited ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:String ; + owl:onProperty linkml:equals_string_in ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:AnonymousSlotExpression ; owl:onProperty linkml:all_members ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:locally_reflexive ], - [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty linkml:role ], - [ a owl:Restriction ; - owl:allValuesFrom linkml:SlotDefinition ; - owl:onProperty linkml:disjoint_with ], + owl:onClass linkml:SlotDefinition ; + owl:onProperty linkml:transitive_form_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PathExpression ; - owl:onProperty linkml:path_rule ], + owl:onClass linkml:AnonymousSlotExpression ; + owl:onProperty linkml:has_member ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:readonly ], + owl:onProperty linkml:equals_expression ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:inlined_as_list ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:minimum_value ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:is_grouping_slot ], + owl:onProperty linkml:list_elements_unique ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:String ; - owl:onProperty linkml:implicit_prefix ], + owl:onProperty linkml:ifabsent ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:Boolean ; - owl:onProperty linkml:shared ], + owl:onClass linkml:String ; + owl:onProperty linkml:pattern ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:ClassDefinition ; - owl:onProperty linkml:domain ], + owl:onClass linkml:Boolean ; + owl:onProperty linkml:locally_reflexive ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; - owl:onProperty linkml:transitive ], + owl:onProperty linkml:asymmetric ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:PatternExpression ; - owl:onProperty linkml:structured_pattern ], + owl:onClass linkml:SlotDefinition ; + owl:onProperty linkml:reflexive_transitive_form_of ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:SlotDefinition ; - owl:onProperty owl:inverseOf ], + owl:onClass linkml:Integer ; + owl:onProperty linkml:equals_number ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; owl:onProperty linkml:is_class_field ], [ a owl:Restriction ; - owl:maxQualifiedCardinality 1 ; - owl:onClass linkml:String ; - owl:onProperty skos:altLabel ], + owl:allValuesFrom linkml:AnonymousSlotExpression ; + owl:onProperty linkml:all_of ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:SlotDefinition ; + owl:onProperty linkml:mixins ], [ a owl:Restriction ; owl:maxQualifiedCardinality 1 ; owl:onClass linkml:Boolean ; owl:onProperty linkml:designates_type ], [ a owl:Restriction ; - owl:allValuesFrom linkml:AnonymousSlotExpression ; - owl:onProperty linkml:all_of ], + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Boolean ; + owl:onProperty linkml:shared ], + [ a owl:Restriction ; + owl:allValuesFrom linkml:SlotDefinition ; + owl:onProperty linkml:union_of ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:Definition ; + owl:onProperty linkml:owner ], + [ a owl:Restriction ; + owl:maxQualifiedCardinality 1 ; + owl:onClass linkml:String ; + owl:onProperty skos:prefLabel ], linkml:Definition, linkml:SlotExpression ; skos:altLabel "attribute", diff --git a/linkml_runtime/linkml_model/prefixmap/meta.yaml b/linkml_runtime/linkml_model/prefixmap/meta.yaml new file mode 100644 index 00000000..97f352ac --- /dev/null +++ b/linkml_runtime/linkml_model/prefixmap/meta.yaml @@ -0,0 +1,29 @@ +{ + "IAO": "http://purl.obolibrary.org/obo/IAO_", + "NCIT": "http://ncicb.nci.nih.gov/xml/owl/EVS/Thesaurus.owl#", + "OIO": "http://www.geneontology.org/formats/oboInOwl#", + "bibo": "http://purl.org/ontology/bibo/", + "dcterms": "http://purl.org/dc/terms/", + "linkml": "https://w3id.org/linkml/", + "oslc": "http://open-services.net/ns/core#", + "owl": "http://www.w3.org/2002/07/owl#", + "pav": "http://purl.org/pav/", + "prov": "http://www.w3.org/ns/prov#", + "qb": "http://purl.org/linked-data/cube#", + "qudt": "http://qudt.org/schema/qudt/", + "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#", + "rdfs": "http://www.w3.org/2000/01/rdf-schema#", + "schema": "http://schema.org/", + "sh": "https://w3id.org/shacl/", + "skos": "http://www.w3.org/2004/02/skos/core#", + "skosxl": "http://www.w3.org/2008/05/skos-xl#", + "swrl": "http://www.w3.org/2003/11/swrl#", + "vann": "https://vocab.org/vann/", + "xsd": "http://www.w3.org/2001/XMLSchema#", + "StructuredAlias": { + "@id": "skosxl:Label" + }, + "UnitOfMeasure": { + "@id": "qudt:Unit" + } +} diff --git a/linkml_runtime/linkml_model/protobuf/meta.proto b/linkml_runtime/linkml_model/protobuf/meta.proto new file mode 100644 index 00000000..ddc26ece --- /dev/null +++ b/linkml_runtime/linkml_model/protobuf/meta.proto @@ -0,0 +1,844 @@ +// an attributed description +message AltDescription + { + string source = 0 + string description = 0 + } +// a tag/value pair with the semantics of OWL Annotation +message Annotation + { + uriorcurie tag = 0 + string value = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + } +message AnonymousClassExpression + { + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + definition isA = 11 + repeated anonymousClassExpression anyOf = 101 + repeated anonymousClassExpression exactlyOneOf = 103 + repeated anonymousClassExpression noneOf = 105 + repeated anonymousClassExpression allOf = 107 + repeated slotDefinition slotConditions = 0 + } +// An enum_expression that is not named +message AnonymousEnumExpression + { + uriorcurie codeSet = 0 + string codeSetTag = 0 + string codeSetVersion = 0 + pvFormulaOptions pvFormula = 0 + repeated permissibleValue permissibleValues = 0 + repeated anonymousEnumExpression include = 0 + repeated anonymousEnumExpression minus = 0 + repeated enumDefinition inherits = 0 + reachabilityQuery reachableFrom = 0 + matchQuery matches = 0 + repeated uriorcurie concepts = 0 + } +message AnonymousSlotExpression + { + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + element range = 0 + anonymousClassExpression rangeExpression = 0 + enumExpression enumRange = 0 + boolean required = 8 + boolean recommended = 9 + boolean inlined = 25 + boolean inlinedAsList = 27 + integer minimumValue = 0 + integer maximumValue = 0 + string pattern = 35 + patternExpression structuredPattern = 0 + unitOfMeasure unit = 0 + string implicitPrefix = 0 + presenceEnum valuePresence = 0 + string equalsString = 0 + repeated string equalsStringIn = 0 + integer equalsNumber = 0 + string equalsExpression = 0 + integer minimumCardinality = 0 + integer maximumCardinality = 0 + anonymousSlotExpression hasMember = 0 + anonymousSlotExpression allMembers = 0 + repeated anonymousSlotExpression noneOf = 105 + repeated anonymousSlotExpression exactlyOneOf = 103 + repeated anonymousSlotExpression anyOf = 101 + repeated anonymousSlotExpression allOf = 107 + } +message AnonymousTypeExpression + { + string pattern = 35 + patternExpression structuredPattern = 0 + unitOfMeasure unit = 0 + string implicitPrefix = 0 + string equalsString = 0 + repeated string equalsStringIn = 0 + integer equalsNumber = 0 + integer minimumValue = 0 + integer maximumValue = 0 + repeated anonymousTypeExpression noneOf = 105 + repeated anonymousTypeExpression exactlyOneOf = 103 + repeated anonymousTypeExpression anyOf = 101 + repeated anonymousTypeExpression allOf = 107 + } +// an element whose instances are complex objects that may have slot-value assignments +message ClassDefinition + { + string name = 1 + repeated ncname idPrefixes = 0 + uriorcurie definitionUri = 0 + repeated localName localNames = 0 + string conformsTo = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + boolean abstract = 0 + boolean mixin = 0 + repeated uriorcurie valuesFrom = 0 + uriorcurie createdBy = 0 + datetime createdOn = 0 + datetime lastUpdatedOn = 0 + uriorcurie modifiedBy = 0 + uriorcurie status = 0 + string stringSerialization = 0 + repeated slotDefinition slots = 19 + repeated slotDefinition slotUsage = 23 + repeated slotDefinition attributes = 29 + uriorcurie classUri = 2 + uriorcurie subclassOf = 0 + repeated classDefinition unionOf = 0 + repeated slotDefinition definingSlots = 0 + boolean treeRoot = 31 + repeated uniqueKey uniqueKeys = 0 + repeated classRule rules = 0 + repeated anonymousClassExpression classificationRules = 0 + boolean slotNamesUnique = 0 + boolean representsRelationship = 0 + repeated classDefinition disjointWith = 0 + boolean childrenAreMutuallyDisjoint = 0 + classDefinition isA = 11 + repeated classDefinition mixins = 13 + repeated classDefinition applyTo = 0 + repeated anonymousClassExpression anyOf = 101 + repeated anonymousClassExpression exactlyOneOf = 103 + repeated anonymousClassExpression noneOf = 105 + repeated anonymousClassExpression allOf = 107 + repeated slotDefinition slotConditions = 0 + } +// A rule that applies to instances of a class +message ClassRule + { + anonymousClassExpression preconditions = 111 + anonymousClassExpression postconditions = 113 + anonymousClassExpression elseconditions = 115 + boolean bidirectional = 0 + boolean openWorld = 0 + integer rank = 51 + boolean deactivated = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + } +// an element whose instances must be drawn from a specified set of permissible values +message EnumDefinition + { + string name = 1 + repeated ncname idPrefixes = 0 + uriorcurie definitionUri = 0 + repeated localName localNames = 0 + string conformsTo = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + definition isA = 11 + boolean abstract = 0 + boolean mixin = 0 + repeated definition mixins = 13 + repeated definition applyTo = 0 + repeated uriorcurie valuesFrom = 0 + uriorcurie createdBy = 0 + datetime createdOn = 0 + datetime lastUpdatedOn = 0 + uriorcurie modifiedBy = 0 + uriorcurie status = 0 + string stringSerialization = 0 + uriorcurie enumUri = 0 + uriorcurie codeSet = 0 + string codeSetTag = 0 + string codeSetVersion = 0 + pvFormulaOptions pvFormula = 0 + repeated permissibleValue permissibleValues = 0 + repeated anonymousEnumExpression include = 0 + repeated anonymousEnumExpression minus = 0 + repeated enumDefinition inherits = 0 + reachabilityQuery reachableFrom = 0 + matchQuery matches = 0 + repeated uriorcurie concepts = 0 + } +// An expression that constrains the range of a slot +message EnumExpression + { + uriorcurie codeSet = 0 + string codeSetTag = 0 + string codeSetVersion = 0 + pvFormulaOptions pvFormula = 0 + repeated permissibleValue permissibleValues = 0 + repeated anonymousEnumExpression include = 0 + repeated anonymousEnumExpression minus = 0 + repeated enumDefinition inherits = 0 + reachabilityQuery reachableFrom = 0 + matchQuery matches = 0 + repeated uriorcurie concepts = 0 + } +// usage example and description +message Example + { + string value = 0 + string description = 0 + } +// a tag/value pair used to add non-model information to an entry +message Extension + { + uriorcurie tag = 0 + string value = 0 + repeated extension extensions = 0 + } +// an expression describing an import +message ImportExpression + { + uriorcurie importFrom = 0 + ncname importAs = 0 + repeated setting importMap = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + } +// an attributed label +message LocalName + { + ncname localNameSource = 0 + string localNameValue = 0 + } +// A query that is used on an enum expression to dynamically obtain a set of permissivle values via a query that matches on properties of the external concepts +message MatchQuery + { + string identifierPattern = 0 + uriorcurie sourceOntology = 0 + } +// An expression that describes an abstract path from an object to another through a sequence of slot lookups +message PathExpression + { + pathExpression followedBy = 0 + repeated pathExpression noneOf = 105 + repeated pathExpression anyOf = 101 + repeated pathExpression allOf = 107 + repeated pathExpression exactlyOneOf = 103 + boolean reversed = 0 + slotDefinition traverse = 0 + anonymousClassExpression rangeExpression = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + } +// a regular expression pattern used to evaluate conformance of a string +message PatternExpression + { + string syntax = 0 + boolean interpolated = 0 + boolean partialMatch = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + } +// a permissible value, accompanied by intended text and an optional mapping to a concept URI +message PermissibleValue + { + string text = 21 + string description = 5 + uriorcurie meaning = 23 + unitOfMeasure unit = 0 + permissibleValue isA = 11 + repeated permissibleValue mixins = 13 + repeated extension extensions = 0 + repeated annotation annotations = 0 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + } +// prefix URI tuple +message Prefix + { + ncname prefixPrefix = 1 + uri prefixReference = 2 + } +// A query that is used on an enum expression to dynamically obtain a set of permissible values via walking from a set of source nodes to a set of descendants or ancestors over a set of relationship types +message ReachabilityQuery + { + uriorcurie sourceOntology = 0 + repeated uriorcurie sourceNodes = 0 + repeated uriorcurie relationshipTypes = 0 + boolean isDirect = 0 + boolean includeSelf = 0 + boolean traverseUp = 0 + } +// a collection of subset, type, slot and class definitions +message SchemaDefinition + { + repeated ncname idPrefixes = 0 + uriorcurie definitionUri = 0 + repeated localName localNames = 0 + string conformsTo = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + uri id = 0 + string version = 0 + repeated uriorcurie imports = 21 + string license = 31 + repeated prefix prefixes = 10 + repeated ncname emitPrefixes = 0 + repeated string defaultCuriMaps = 0 + string defaultPrefix = 11 + typeDefinition defaultRange = 13 + repeated subsetDefinition subsets = 8 + repeated typeDefinition types = 6 + repeated enumDefinition enums = 5 + repeated slotDefinition slots = 4 + repeated classDefinition classes = 3 + string metamodelVersion = 0 + string sourceFile = 0 + datetime sourceFileDate = 0 + integer sourceFileSize = 0 + datetime generationDate = 0 + boolean slotNamesUnique = 0 + repeated setting settings = 20 + repeated uriorcurie categories = 0 + repeated string keywords = 0 + ncname name = 1 + } +// assignment of a key to a value +message Setting + { + ncname settingKey = 0 + string settingValue = 0 + } +// an element that describes how instances are related to other instances +message SlotDefinition + { + string name = 1 + repeated ncname idPrefixes = 0 + uriorcurie definitionUri = 0 + repeated localName localNames = 0 + string conformsTo = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + boolean abstract = 0 + boolean mixin = 0 + repeated uriorcurie valuesFrom = 0 + uriorcurie createdBy = 0 + datetime createdOn = 0 + datetime lastUpdatedOn = 0 + uriorcurie modifiedBy = 0 + uriorcurie status = 0 + string stringSerialization = 0 + string singularName = 0 + classDefinition domain = 0 + uriorcurie slotUri = 2 + boolean multivalued = 7 + boolean inherited = 0 + string readonly = 0 + string ifabsent = 0 + boolean listElementsUnique = 0 + boolean listElementsOrdered = 0 + boolean shared = 0 + boolean key = 0 + boolean identifier = 5 + boolean designatesType = 0 + string alias = 6 + definition owner = 0 + repeated classDefinition domainOf = 0 + slotDefinition subpropertyOf = 0 + boolean symmetric = 0 + boolean reflexive = 0 + boolean locallyReflexive = 0 + boolean irreflexive = 0 + boolean asymmetric = 0 + boolean transitive = 0 + slotDefinition inverse = 0 + boolean isClassField = 0 + slotDefinition transitiveFormOf = 0 + slotDefinition reflexiveTransitiveFormOf = 0 + string role = 0 + boolean isUsageSlot = 0 + string usageSlotName = 0 + relationalRoleEnum relationalRole = 0 + slotDefinition slotGroup = 0 + boolean isGroupingSlot = 0 + pathExpression pathRule = 0 + repeated slotDefinition disjointWith = 0 + boolean childrenAreMutuallyDisjoint = 0 + repeated slotDefinition unionOf = 0 + slotDefinition isA = 11 + repeated slotDefinition mixins = 13 + repeated slotDefinition applyTo = 0 + element range = 0 + anonymousClassExpression rangeExpression = 0 + enumExpression enumRange = 0 + boolean required = 8 + boolean recommended = 9 + boolean inlined = 25 + boolean inlinedAsList = 27 + integer minimumValue = 0 + integer maximumValue = 0 + string pattern = 35 + patternExpression structuredPattern = 0 + unitOfMeasure unit = 0 + string implicitPrefix = 0 + presenceEnum valuePresence = 0 + string equalsString = 0 + repeated string equalsStringIn = 0 + integer equalsNumber = 0 + string equalsExpression = 0 + integer minimumCardinality = 0 + integer maximumCardinality = 0 + anonymousSlotExpression hasMember = 0 + anonymousSlotExpression allMembers = 0 + repeated anonymousSlotExpression noneOf = 105 + repeated anonymousSlotExpression exactlyOneOf = 103 + repeated anonymousSlotExpression anyOf = 101 + repeated anonymousSlotExpression allOf = 107 + } +// object that contains meta data about a synonym or alias including where it came from (source) and its scope (narrow, broad, etc.) +message StructuredAlias + { + string literalForm = 0 + aliasPredicateEnum predicate = 0 + repeated uriorcurie categories = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + } +// an element that can be used to group other metamodel elements +message SubsetDefinition + { + string name = 1 + repeated ncname idPrefixes = 0 + uriorcurie definitionUri = 0 + repeated localName localNames = 0 + string conformsTo = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + } +// an element that whose instances are atomic scalar values that can be mapped to primitive types +message TypeDefinition + { + string name = 1 + repeated ncname idPrefixes = 0 + uriorcurie definitionUri = 0 + repeated localName localNames = 0 + string conformsTo = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + typeDefinition typeof = 7 + string base = 8 + uriorcurie uri = 2 + string repr = 10 + repeated typeDefinition unionOf = 0 + string pattern = 35 + patternExpression structuredPattern = 0 + unitOfMeasure unit = 0 + string implicitPrefix = 0 + string equalsString = 0 + repeated string equalsStringIn = 0 + integer equalsNumber = 0 + integer minimumValue = 0 + integer maximumValue = 0 + repeated anonymousTypeExpression noneOf = 105 + repeated anonymousTypeExpression exactlyOneOf = 103 + repeated anonymousTypeExpression anyOf = 101 + repeated anonymousTypeExpression allOf = 107 + } +// a collection of slots whose values uniquely identify an instance of a class +message UniqueKey + { + string uniqueKeyName = 0 + repeated slotDefinition uniqueKeySlots = 0 + repeated extension extensions = 0 + repeated annotation annotations = 0 + string description = 5 + repeated altDescription altDescriptions = 0 + string title = 3 + string deprecated = 0 + repeated string todos = 0 + repeated string notes = 0 + repeated string comments = 0 + repeated example examples = 0 + repeated subsetDefinition inSubset = 0 + uri fromSchema = 0 + string importedFrom = 0 + uriorcurie source = 0 + string inLanguage = 0 + repeated uriorcurie seeAlso = 0 + uriorcurie deprecatedElementHasExactReplacement = 0 + uriorcurie deprecatedElementHasPossibleReplacement = 0 + repeated string aliases = 0 + repeated structuredAlias structuredAliases = 0 + repeated uriorcurie mappings = 0 + repeated uriorcurie exactMappings = 0 + repeated uriorcurie closeMappings = 0 + repeated uriorcurie relatedMappings = 0 + repeated uriorcurie narrowMappings = 0 + repeated uriorcurie broadMappings = 0 + integer rank = 51 + } +// A unit of measure, or unit, is a particular quantity value that has been chosen as a scale for measuring other quantities the same kind (more generally of equivalent dimension). +message UnitOfMeasure + { + string symbol = 0 + repeated uriorcurie exactMappings = 0 + string ucumCode = 0 + string derivation = 0 + uriorcurie hasQuantityKind = 0 + string iec61360code = 0 + } diff --git a/linkml_runtime/linkml_model/rdf/datasets.model.ttl b/linkml_runtime/linkml_model/rdf/datasets.model.ttl new file mode 100644 index 00000000..a9ad3196 --- /dev/null +++ b/linkml_runtime/linkml_model/rdf/datasets.model.ttl @@ -0,0 +1,747 @@ +@prefix : . +@prefix dcterms: . +@prefix linkml: . +@prefix xsd: . + +linkml:datasets a linkml:SchemaDefinition ; + dcterms:description "A datamodel for datasets" ; + dcterms:license "https://creativecommons.org/publicdomain/zero/1.0/" ; + dcterms:title "LinkML Datasets Datamodel" ; + linkml:classes [ a linkml:ClassDefinition ; + dcterms:description "Grouping for datasets and data files" ; + linkml:abstract true ; + linkml:class_uri "https://w3id.org/linkml/reportInformation" ; + linkml:close_mappings "schema:CreativeWork" ; + linkml:definition_uri "https://w3id.org/linkml/reportInformation" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "Information" ; + linkml:slot_usage [ ] ; + linkml:slots "compression", + "conforms_to", + "conforms_to_class", + "conforms_to_schema", + "created_by", + "created_on", + "description", + "download_url", + "id", + "issued", + "keywords", + "language", + "license", + "page", + "publisher", + "test_roles", + "title", + "version", + "was_derived_from" ], + [ a linkml:ClassDefinition ; + dcterms:description "A collection of data resources" ; + linkml:aliases "data resource collection", + "dataset", + "file collection" ; + linkml:class_uri "http://rdfs.org/ns/void#Dataset" ; + linkml:close_mappings "dcat:Catalog" ; + linkml:definition_uri "https://w3id.org/linkml/reportDataPackage" ; + linkml:exact_mappings "dcat:Dataset" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "Information" ; + linkml:mappings "void:Dataset" ; + linkml:name "DataPackage" ; + linkml:see_also "https://specs.frictionlessdata.io/data-package" ; + linkml:slot_usage [ ] ; + linkml:slots "compression", + "conforms_to", + "conforms_to_class", + "conforms_to_schema", + "created_by", + "created_on", + "description", + "download_url", + "id", + "issued", + "keywords", + "language", + "license", + "page", + "publisher", + "resources", + "test_roles", + "title", + "version", + "was_derived_from" ], + [ a linkml:ClassDefinition ; + dcterms:description "Additional format information for a file" ; + linkml:attributes [ a linkml:SlotDefinition ; + linkml:name "header" ], + [ a linkml:SlotDefinition ; + linkml:name "delimiter" ], + [ a linkml:SlotDefinition ; + linkml:name "quote_char" ], + [ a linkml:SlotDefinition ; + linkml:name "comment_prefix" ], + [ a linkml:SlotDefinition ; + linkml:name "double_quote" ] ; + linkml:class_uri "https://w3id.org/linkml/reportFormatDialect" ; + linkml:definition_uri "https://w3id.org/linkml/reportFormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "FormatDialect" ; + linkml:slot_usage [ ] ; + linkml:slots "formatDialect__comment_prefix", + "formatDialect__delimiter", + "formatDialect__double_quote", + "formatDialect__header", + "formatDialect__quote_char" ], + [ a linkml:ClassDefinition ; + dcterms:description "An individual file or table" ; + linkml:class_uri "http://www.w3.org/ns/dcat#Distribution" ; + linkml:definition_uri "https://w3id.org/linkml/reportDataResource" ; + linkml:exact_mappings "schema:DataDownload" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "Information" ; + linkml:mappings "dcat:Distribution" ; + linkml:name "DataResource" ; + linkml:see_also "https://specs.frictionlessdata.io/data-resource" ; + linkml:slot_usage [ ] ; + linkml:slots "bytes", + "compression", + "conforms_to", + "conforms_to_class", + "conforms_to_schema", + "created_by", + "created_on", + "description", + "dialect", + "download_url", + "encoding", + "format", + "hash", + "id", + "issued", + "keywords", + "language", + "license", + "md5", + "media_type", + "page", + "path", + "publisher", + "sha256", + "test_roles", + "title", + "version", + "was_derived_from" ] ; + linkml:default_curi_maps "semweb_context" ; + linkml:default_prefix "datasets" ; + linkml:default_range "string" ; + linkml:emit_prefixes "linkml", + "owl", + "rdf", + "rdfs", + "xsd" ; + linkml:enums [ linkml:definition_uri "https://w3id.org/linkml/reportFormatEnum" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "FormatEnum" ; + linkml:permissible_values [ linkml:meaning "formats:JSON-LD" ; + linkml:text "JSON-LD" ], + [ linkml:meaning "formats:N-Triples" ; + linkml:text "N-Triples" ], + [ linkml:meaning "formats:Turtle" ; + linkml:text "Turtle" ], + [ linkml:meaning "formats:RDF_JSON" ; + linkml:text "RDF/JSON" ], + [ linkml:meaning "formats:RDFa" ; + linkml:text "RDFa" ], + [ linkml:meaning "formats:SPARQL_Results_CSV" ; + linkml:text "SPARQL%20Results%20in%20CSV" ], + [ linkml:meaning "formats:RIF_XML" ; + linkml:text "RIF%20XML%20Syntax" ], + [ linkml:meaning "formats:SPARQL_Results_TSV" ; + linkml:text "SPARQL%20Results%20in%20TSV" ], + [ linkml:meaning "formats:microdata" ; + linkml:text "Microdata" ], + [ linkml:meaning "formats:POWDER-S" ; + linkml:text "POWDER-S" ], + [ linkml:meaning "formats:OWL_Manchester" ; + linkml:text "OWL%20Manchester%20Syntax" ], + [ linkml:meaning "formats:PROV-N" ; + linkml:text "PROV-N" ], + [ linkml:meaning "formats:POWDER" ; + linkml:text "POWDER" ], + [ linkml:meaning "formats:SPARQL_Results_JSON" ; + linkml:text "SPARQL%20Results%20in%20JSON" ], + [ linkml:meaning "formats:N-Quads" ; + linkml:text "N-Quads" ], + [ linkml:meaning "formats:TriG" ; + linkml:text "TriG" ], + [ linkml:meaning "formats:OWL_Functional" ; + linkml:text "OWL%20Functional%20Syntax" ], + [ linkml:meaning "formats:N3" ; + linkml:text "N3" ], + [ linkml:meaning "formats:LD_Patch" ; + linkml:text "LD%20Patch" ], + [ linkml:text "YAML" ], + [ linkml:meaning "formats:OWL_XML" ; + linkml:text "OWL%20XML%20Serialization" ], + [ linkml:text "JSON" ], + [ linkml:meaning "formats:RDF_XML" ; + linkml:text "RDF/XML" ], + [ linkml:meaning "formats:PROV-XML" ; + linkml:text "PROV-XML" ], + [ linkml:meaning "formats:SPARQL_Results_XML" ; + linkml:text "SPARQL%20Results%20in%20XML" ] ], + [ linkml:definition_uri "https://w3id.org/linkml/reportTestRole" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "TestRole" ; + linkml:permissible_values [ linkml:text "CounterExample" ], + [ linkml:text "Example" ] ], + [ linkml:definition_uri "https://w3id.org/linkml/reportMediaTypeEnum" ; + linkml:exact_mappings "dcterms:MediaType" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "MediaTypeEnum" ; + linkml:permissible_values [ linkml:meaning "mediatypes:application/rdf+xml" ; + linkml:text "rdf-xml" ], + [ linkml:meaning "mediatypes:text/csv" ; + linkml:text "csv" ] ] ; + linkml:generation_date "2022-07-14T00:57:10" ; + linkml:imports "linkml:types" ; + linkml:metamodel_version "1.7.0" ; + linkml:name "datasets" ; + linkml:prefixes [ linkml:prefix_prefix "schema" ; + linkml:prefix_reference "http://schema.org/" ], + [ linkml:prefix_prefix "datasets" ; + linkml:prefix_reference "https://w3id.org/linkml/report" ], + [ linkml:prefix_prefix "void" ; + linkml:prefix_reference "http://rdfs.org/ns/void#" ], + [ linkml:prefix_prefix "csvw" ; + linkml:prefix_reference "http://www.w3.org/ns/csvw#" ], + [ linkml:prefix_prefix "frictionless" ; + linkml:prefix_reference "https://specs.frictionlessdata.io/" ], + [ linkml:prefix_prefix "skos" ; + linkml:prefix_reference "http://www.w3.org/2004/02/skos/core#" ], + [ linkml:prefix_prefix "sh" ; + linkml:prefix_reference "https://w3id.org/shacl/" ], + [ linkml:prefix_prefix "linkml" ; + linkml:prefix_reference "https://w3id.org/linkml/" ], + [ linkml:prefix_prefix "formats" ; + linkml:prefix_reference "http://www.w3.org/ns/formats/" ], + [ linkml:prefix_prefix "dcat" ; + linkml:prefix_reference "http://www.w3.org/ns/dcat#" ], + [ linkml:prefix_prefix "mediatypes" ; + linkml:prefix_reference "https://www.iana.org/assignments/media-types/" ], + [ linkml:prefix_prefix "pav" ; + linkml:prefix_reference "http://purl.org/pav/" ] ; + linkml:see_also "https://specs.frictionlessdata.io/data-resource", + "https://www.w3.org/TR/hcls-dataset/", + "https://www.w3.org/TR/void/" ; + linkml:slots [ a linkml:SlotDefinition ; + dcterms:description "language in which the information is expressed" ; + linkml:definition_uri "https://w3id.org/linkml/reportlanguage" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "language" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportlanguage" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportdialect" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/csvw#dialect" ; + linkml:name "dialect" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "http://www.w3.org/ns/csvw#dialect" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportbytes" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#byteSize" ; + linkml:name "bytes" ; + linkml:owner "DataResource" ; + linkml:range "integer" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#byteSize" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportresources" ; + linkml:domain_of "DataPackage" ; + linkml:exact_mappings "http://schema.org/distribution" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#distribution" ; + linkml:multivalued true ; + linkml:name "resources" ; + linkml:owner "DataPackage" ; + linkml:range "DataResource" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#distribution" ], + [ a linkml:SlotDefinition ; + dcterms:description "particular version of schema" ; + linkml:definition_uri "https://w3id.org/linkml/reportversion" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "http://purl.org/dc/terms/hasVersion", + "http://schema.org/version" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/pav/version" ; + linkml:name "version" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "http://purl.org/pav/version" ], + [ a linkml:SlotDefinition ; + linkml:alias "quote_char" ; + linkml:domain_of "FormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "formatDialect__quote_char" ; + linkml:owner "FormatDialect" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportquote_char" ], + [ a linkml:SlotDefinition ; + linkml:alias "comment_prefix" ; + linkml:domain_of "FormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "formatDialect__comment_prefix" ; + linkml:owner "FormatDialect" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportcomment_prefix" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportpublisher" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/publisher" ; + linkml:name "publisher" ; + linkml:owner "Information" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "http://purl.org/dc/terms/publisher" ], + [ a linkml:SlotDefinition ; + dcterms:description "human readable description of the information" ; + linkml:definition_uri "https://w3id.org/linkml/reportdescription" ; + linkml:domain_of "DataResource", + "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/description" ; + linkml:name "description" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "http://purl.org/dc/terms/description" ], + [ a linkml:SlotDefinition ; + dcterms:description "agent that created the element" ; + linkml:definition_uri "https://w3id.org/linkml/reportcreated_by" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/pav/createdBy" ; + linkml:name "created_by" ; + linkml:owner "Information" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "http://purl.org/pav/createdBy" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportformat" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/format" ; + linkml:name "format" ; + linkml:owner "DataResource" ; + linkml:range "FormatEnum" ; + linkml:slot_uri "http://purl.org/dc/terms/format" ], + [ a linkml:SlotDefinition ; + linkml:alias "header" ; + linkml:domain_of "FormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "formatDialect__header" ; + linkml:owner "FormatDialect" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportheader" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportprofile" ; + linkml:exact_mappings "https://specs.frictionlessdata.io/profiles" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "profile" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "https://w3id.org/linkml/reportprofile" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportcompression" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "compression" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportcompression" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportsha256" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "hash" ; + linkml:name "sha256" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportsha256" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reporttest_roles" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:multivalued true ; + linkml:name "test_roles" ; + linkml:owner "Information" ; + linkml:range "TestRole" ; + linkml:slot_uri "https://w3id.org/linkml/reporttest_roles" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportthemes" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#theme" ; + linkml:multivalued true ; + linkml:name "themes" ; + linkml:range "uriorcurie" ; + linkml:singular_name "theme" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#theme" ], + [ a linkml:SlotDefinition ; + dcterms:description "agent that modified the element" ; + linkml:definition_uri "https://w3id.org/linkml/reportmodified_by" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://example.org/UNKNOWN/oslc/modifiedBy" ; + linkml:name "modified_by" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "http://example.org/UNKNOWN/oslc/modifiedBy" ], + [ a linkml:SlotDefinition ; + linkml:alias "double_quote" ; + linkml:domain_of "FormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "formatDialect__double_quote" ; + linkml:owner "FormatDialect" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportdouble_quote" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportmedia_type" ; + linkml:domain_of "DataResource" ; + linkml:exact_mappings "http://schema.org/encodingFormat", + "https://specs.frictionlessdata.io/mediatype" ; + linkml:examples [ a linkml:Example ; + linkml:value "application/json" ], + [ a linkml:Example ; + linkml:value "text/csv" ] ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#mediaType" ; + linkml:name "media_type" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#mediaType" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportencoding" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "encoding" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportencoding" ], + [ a linkml:SlotDefinition ; + dcterms:description "A derivation is a transformation of an entity into another, an update of an entity resulting in a new one, or the construction of a new entity based on a pre-existing entity.@en" ; + linkml:definition_uri "https://w3id.org/linkml/reportwas_derived_from" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/prov#wasDerivedFrom" ; + linkml:name "was_derived_from" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "http://www.w3.org/ns/prov#wasDerivedFrom" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reporthash" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "hash" ; + linkml:notes "we recommend using a more specific slot such as sha256 or md5" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reporthash" ], + [ a linkml:SlotDefinition ; + dcterms:description "time at which the element was created" ; + linkml:definition_uri "https://w3id.org/linkml/reportcreated_on" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/pav/createdOn" ; + linkml:name "created_on" ; + linkml:owner "Information" ; + linkml:range "datetime" ; + linkml:slot_uri "http://purl.org/pav/createdOn" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportkeywords" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "http://schema.org/keywords" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#keyword" ; + linkml:multivalued true ; + linkml:name "keywords" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:singular_name "keyword" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#keyword" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportpage" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#landingPage" ; + linkml:name "page" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#landingPage" ], + [ a linkml:SlotDefinition ; + dcterms:description "the official title of the element" ; + linkml:definition_uri "https://w3id.org/linkml/reporttitle" ; + linkml:domain_of "DataResource", + "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/title" ; + linkml:name "title" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "http://purl.org/dc/terms/title" ], + [ a linkml:SlotDefinition ; + linkml:close_mappings "https://specs.frictionlessdata.io/path" ; + linkml:definition_uri "https://w3id.org/linkml/reportpath" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "path" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportpath" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportissued" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/issued" ; + linkml:name "issued" ; + linkml:owner "Information" ; + linkml:range "datetime" ; + linkml:slot_uri "http://purl.org/dc/terms/issued" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportconforms_to_schema" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "https://specs.frictionlessdata.io/schema" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "conforms_to" ; + linkml:name "conforms_to_schema" ; + linkml:owner "Information" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "https://w3id.org/linkml/reportconforms_to_schema" ], + [ a linkml:SlotDefinition ; + dcterms:description "time at which the element was last updated" ; + linkml:definition_uri "https://w3id.org/linkml/reportlast_updated_on" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/pav/lastUpdatedOn" ; + linkml:name "last_updated_on" ; + linkml:range "datetime" ; + linkml:slot_uri "http://purl.org/pav/lastUpdatedOn" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportmd5" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "hash" ; + linkml:name "md5" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportmd5" ], + [ a linkml:SlotDefinition ; + linkml:close_mappings "https://specs.frictionlessdata.io/path" ; + linkml:definition_uri "https://w3id.org/linkml/reportdownload_url" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "http://schema.org/url" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#downloadURL" ; + linkml:name "download_url" ; + linkml:owner "Information" ; + linkml:range "uri" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#downloadURL" ], + [ a linkml:SlotDefinition ; + dcterms:description "status of the element" ; + linkml:definition_uri "https://w3id.org/linkml/reportstatus" ; + linkml:examples [ a linkml:Example ; + linkml:value "bibo:draft" ] ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://example.org/UNKNOWN/bibo/status" ; + linkml:name "status" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "http://example.org/UNKNOWN/bibo/status" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportconforms_to" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/conformsTo" ; + linkml:name "conforms_to" ; + linkml:owner "Information" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "http://purl.org/dc/terms/conformsTo" ], + [ a linkml:SlotDefinition ; + linkml:alias "delimiter" ; + linkml:domain_of "FormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "formatDialect__delimiter" ; + linkml:owner "FormatDialect" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportdelimiter" ], + [ a linkml:SlotDefinition ; + dcterms:description "class in schema which the data object instantiates" ; + linkml:definition_uri "https://w3id.org/linkml/reportconforms_to_class" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "conforms_to" ; + linkml:name "conforms_to_class" ; + linkml:owner "Information" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "https://w3id.org/linkml/reportconforms_to_class" ], + [ a linkml:SlotDefinition ; + dcterms:description "the unique name of th dataset" ; + linkml:definition_uri "https://w3id.org/linkml/reportid" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "http://schema.org/name" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:identifier true ; + linkml:mappings "http://purl.org/dc/terms/identifier" ; + linkml:name "id" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:required true ; + linkml:slot_uri "http://purl.org/dc/terms/identifier" ], + [ a linkml:SlotDefinition ; + dcterms:description "license for the data" ; + linkml:definition_uri "https://w3id.org/linkml/reportlicense" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "https://specs.frictionlessdata.io/licenses" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/license" ; + linkml:name "license" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "http://purl.org/dc/terms/license" ] ; + linkml:source_file "datasets.yaml" ; + linkml:source_file_date "2022-07-14T00:55:10" ; + linkml:source_file_size 7804 ; + linkml:types [ a linkml:TypeDefinition ; + dcterms:description "a complete URI" ; + linkml:base "URI" ; + linkml:definition_uri "https://w3id.org/linkml/Uri" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "uri" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#anyURI" ], + [ a linkml:TypeDefinition ; + dcterms:description "A real number that conforms to the xsd:float specification" ; + linkml:base "float" ; + linkml:definition_uri "https://w3id.org/linkml/Float" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "float" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#float" ], + [ a linkml:TypeDefinition ; + dcterms:description "A time object represents a (local) time of day, independent of any particular day" ; + linkml:base "XSDTime" ; + linkml:definition_uri "https://w3id.org/linkml/Time" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "time" ; + linkml:notes "URI is dateTime because OWL reasoners don't work with straight date or time" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#dateTime" ], + [ a linkml:TypeDefinition ; + dcterms:description "A real number that conforms to the xsd:double specification" ; + linkml:base "float" ; + linkml:definition_uri "https://w3id.org/linkml/Double" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "double" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#double" ], + [ a linkml:TypeDefinition ; + dcterms:description "A URI or CURIE that represents an object in the model." ; + linkml:base "ElementIdentifier" ; + linkml:comments "Used for inheritence and type checking" ; + linkml:definition_uri "https://w3id.org/linkml/Objectidentifier" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "objectidentifier" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/ns/shex#iri" ], + [ a linkml:TypeDefinition ; + dcterms:description "Prefix part of CURIE" ; + linkml:base "NCName" ; + linkml:definition_uri "https://w3id.org/linkml/Ncname" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "ncname" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#string" ], + [ a linkml:TypeDefinition ; + dcterms:description "A URI, CURIE or BNODE that represents a node in a model." ; + linkml:base "NodeIdentifier" ; + linkml:definition_uri "https://w3id.org/linkml/Nodeidentifier" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "nodeidentifier" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/ns/shex#nonLiteral" ], + [ a linkml:TypeDefinition ; + dcterms:description "A real number with arbitrary precision that conforms to the xsd:decimal specification" ; + linkml:base "Decimal" ; + linkml:definition_uri "https://w3id.org/linkml/Decimal" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "decimal" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#decimal" ], + [ a linkml:TypeDefinition ; + dcterms:description "a URI or a CURIE" ; + linkml:base "URIorCURIE" ; + linkml:definition_uri "https://w3id.org/linkml/Uriorcurie" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "uriorcurie" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#anyURI" ], + [ a linkml:TypeDefinition ; + dcterms:description "Either a date or a datetime" ; + linkml:base "str" ; + linkml:definition_uri "https://w3id.org/linkml/DateOrDatetime" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "date_or_datetime" ; + linkml:repr "str" ; + linkml:uri "https://w3id.org/linkml/DateOrDatetime" ], + [ a linkml:TypeDefinition ; + dcterms:description "An integer" ; + linkml:base "int" ; + linkml:definition_uri "https://w3id.org/linkml/Integer" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "integer" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#integer" ], + [ a linkml:TypeDefinition ; + dcterms:description "A character string" ; + linkml:base "str" ; + linkml:definition_uri "https://w3id.org/linkml/String" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "string" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#string" ], + [ a linkml:TypeDefinition ; + dcterms:description "A binary (true or false) value" ; + linkml:base "Bool" ; + linkml:definition_uri "https://w3id.org/linkml/Boolean" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "boolean" ; + linkml:repr "bool" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#boolean" ], + [ a linkml:TypeDefinition ; + dcterms:description "The combination of a date and time" ; + linkml:base "XSDDateTime" ; + linkml:definition_uri "https://w3id.org/linkml/Datetime" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "datetime" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#dateTime" ], + [ a linkml:TypeDefinition ; + dcterms:description "a date (year, month and day) in an idealized calendar" ; + linkml:base "XSDDate" ; + linkml:definition_uri "https://w3id.org/linkml/Date" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "date" ; + linkml:notes "URI is dateTime because OWL reasoners don't work with straight date or time" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#date" ] . + + + diff --git a/linkml_runtime/linkml_model/rdf/datasets.ttl b/linkml_runtime/linkml_model/rdf/datasets.ttl new file mode 100644 index 00000000..c4a93b45 --- /dev/null +++ b/linkml_runtime/linkml_model/rdf/datasets.ttl @@ -0,0 +1,747 @@ +@prefix : . +@prefix dcterms: . +@prefix linkml: . +@prefix xsd: . + +linkml:datasets a linkml:SchemaDefinition ; + dcterms:description "A datamodel for datasets" ; + dcterms:license "https://creativecommons.org/publicdomain/zero/1.0/" ; + dcterms:title "LinkML Datasets Datamodel" ; + linkml:classes [ a linkml:ClassDefinition ; + dcterms:description "A collection of data resources" ; + linkml:aliases "data resource collection", + "dataset", + "file collection" ; + linkml:class_uri "http://rdfs.org/ns/void#Dataset" ; + linkml:close_mappings "dcat:Catalog" ; + linkml:definition_uri "https://w3id.org/linkml/reportDataPackage" ; + linkml:exact_mappings "dcat:Dataset" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "Information" ; + linkml:mappings "void:Dataset" ; + linkml:name "DataPackage" ; + linkml:see_also "https://specs.frictionlessdata.io/data-package" ; + linkml:slot_usage [ ] ; + linkml:slots "compression", + "conforms_to", + "conforms_to_class", + "conforms_to_schema", + "created_by", + "created_on", + "description", + "download_url", + "id", + "issued", + "keywords", + "language", + "license", + "page", + "publisher", + "resources", + "test_roles", + "title", + "version", + "was_derived_from" ], + [ a linkml:ClassDefinition ; + dcterms:description "Additional format information for a file" ; + linkml:attributes [ a linkml:SlotDefinition ; + linkml:name "quote_char" ], + [ a linkml:SlotDefinition ; + linkml:name "delimiter" ], + [ a linkml:SlotDefinition ; + linkml:name "comment_prefix" ], + [ a linkml:SlotDefinition ; + linkml:name "header" ], + [ a linkml:SlotDefinition ; + linkml:name "double_quote" ] ; + linkml:class_uri "https://w3id.org/linkml/reportFormatDialect" ; + linkml:definition_uri "https://w3id.org/linkml/reportFormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "FormatDialect" ; + linkml:slot_usage [ ] ; + linkml:slots "formatDialect__comment_prefix", + "formatDialect__delimiter", + "formatDialect__double_quote", + "formatDialect__header", + "formatDialect__quote_char" ], + [ a linkml:ClassDefinition ; + dcterms:description "Grouping for datasets and data files" ; + linkml:abstract true ; + linkml:class_uri "https://w3id.org/linkml/reportInformation" ; + linkml:close_mappings "schema:CreativeWork" ; + linkml:definition_uri "https://w3id.org/linkml/reportInformation" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "Information" ; + linkml:slot_usage [ ] ; + linkml:slots "compression", + "conforms_to", + "conforms_to_class", + "conforms_to_schema", + "created_by", + "created_on", + "description", + "download_url", + "id", + "issued", + "keywords", + "language", + "license", + "page", + "publisher", + "test_roles", + "title", + "version", + "was_derived_from" ], + [ a linkml:ClassDefinition ; + dcterms:description "An individual file or table" ; + linkml:class_uri "http://www.w3.org/ns/dcat#Distribution" ; + linkml:definition_uri "https://w3id.org/linkml/reportDataResource" ; + linkml:exact_mappings "schema:DataDownload" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "Information" ; + linkml:mappings "dcat:Distribution" ; + linkml:name "DataResource" ; + linkml:see_also "https://specs.frictionlessdata.io/data-resource" ; + linkml:slot_usage [ ] ; + linkml:slots "bytes", + "compression", + "conforms_to", + "conforms_to_class", + "conforms_to_schema", + "created_by", + "created_on", + "description", + "dialect", + "download_url", + "encoding", + "format", + "hash", + "id", + "issued", + "keywords", + "language", + "license", + "md5", + "media_type", + "page", + "path", + "publisher", + "sha256", + "test_roles", + "title", + "version", + "was_derived_from" ] ; + linkml:default_curi_maps "semweb_context" ; + linkml:default_prefix "datasets" ; + linkml:default_range "string" ; + linkml:emit_prefixes "linkml", + "owl", + "rdf", + "rdfs", + "xsd" ; + linkml:enums [ linkml:definition_uri "https://w3id.org/linkml/reportFormatEnum" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "FormatEnum" ; + linkml:permissible_values [ linkml:meaning "formats:SPARQL_Results_TSV" ; + linkml:text "SPARQL%20Results%20in%20TSV" ], + [ linkml:meaning "formats:microdata" ; + linkml:text "Microdata" ], + [ linkml:text "YAML" ], + [ linkml:meaning "formats:TriG" ; + linkml:text "TriG" ], + [ linkml:meaning "formats:OWL_XML" ; + linkml:text "OWL%20XML%20Serialization" ], + [ linkml:meaning "formats:OWL_Manchester" ; + linkml:text "OWL%20Manchester%20Syntax" ], + [ linkml:meaning "formats:OWL_Functional" ; + linkml:text "OWL%20Functional%20Syntax" ], + [ linkml:meaning "formats:SPARQL_Results_CSV" ; + linkml:text "SPARQL%20Results%20in%20CSV" ], + [ linkml:meaning "formats:POWDER-S" ; + linkml:text "POWDER-S" ], + [ linkml:text "JSON" ], + [ linkml:meaning "formats:RDFa" ; + linkml:text "RDFa" ], + [ linkml:meaning "formats:N-Triples" ; + linkml:text "N-Triples" ], + [ linkml:meaning "formats:RDF_XML" ; + linkml:text "RDF/XML" ], + [ linkml:meaning "formats:LD_Patch" ; + linkml:text "LD%20Patch" ], + [ linkml:meaning "formats:PROV-N" ; + linkml:text "PROV-N" ], + [ linkml:meaning "formats:PROV-XML" ; + linkml:text "PROV-XML" ], + [ linkml:meaning "formats:POWDER" ; + linkml:text "POWDER" ], + [ linkml:meaning "formats:N3" ; + linkml:text "N3" ], + [ linkml:meaning "formats:Turtle" ; + linkml:text "Turtle" ], + [ linkml:meaning "formats:N-Quads" ; + linkml:text "N-Quads" ], + [ linkml:meaning "formats:SPARQL_Results_JSON" ; + linkml:text "SPARQL%20Results%20in%20JSON" ], + [ linkml:meaning "formats:RDF_JSON" ; + linkml:text "RDF/JSON" ], + [ linkml:meaning "formats:JSON-LD" ; + linkml:text "JSON-LD" ], + [ linkml:meaning "formats:RIF_XML" ; + linkml:text "RIF%20XML%20Syntax" ], + [ linkml:meaning "formats:SPARQL_Results_XML" ; + linkml:text "SPARQL%20Results%20in%20XML" ] ], + [ linkml:definition_uri "https://w3id.org/linkml/reportTestRole" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "TestRole" ; + linkml:permissible_values [ linkml:text "CounterExample" ], + [ linkml:text "Example" ] ], + [ linkml:definition_uri "https://w3id.org/linkml/reportMediaTypeEnum" ; + linkml:exact_mappings "dcterms:MediaType" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "MediaTypeEnum" ; + linkml:permissible_values [ linkml:meaning "mediatypes:application/rdf+xml" ; + linkml:text "rdf-xml" ], + [ linkml:meaning "mediatypes:text/csv" ; + linkml:text "csv" ] ] ; + linkml:generation_date "2022-07-14T00:56:56" ; + linkml:imports "linkml:types" ; + linkml:metamodel_version "1.7.0" ; + linkml:name "datasets" ; + linkml:prefixes [ linkml:prefix_prefix "formats" ; + linkml:prefix_reference "http://www.w3.org/ns/formats/" ], + [ linkml:prefix_prefix "dcat" ; + linkml:prefix_reference "http://www.w3.org/ns/dcat#" ], + [ linkml:prefix_prefix "mediatypes" ; + linkml:prefix_reference "https://www.iana.org/assignments/media-types/" ], + [ linkml:prefix_prefix "linkml" ; + linkml:prefix_reference "https://w3id.org/linkml/" ], + [ linkml:prefix_prefix "frictionless" ; + linkml:prefix_reference "https://specs.frictionlessdata.io/" ], + [ linkml:prefix_prefix "sh" ; + linkml:prefix_reference "https://w3id.org/shacl/" ], + [ linkml:prefix_prefix "csvw" ; + linkml:prefix_reference "http://www.w3.org/ns/csvw#" ], + [ linkml:prefix_prefix "pav" ; + linkml:prefix_reference "http://purl.org/pav/" ], + [ linkml:prefix_prefix "void" ; + linkml:prefix_reference "http://rdfs.org/ns/void#" ], + [ linkml:prefix_prefix "skos" ; + linkml:prefix_reference "http://www.w3.org/2004/02/skos/core#" ], + [ linkml:prefix_prefix "datasets" ; + linkml:prefix_reference "https://w3id.org/linkml/report" ], + [ linkml:prefix_prefix "schema" ; + linkml:prefix_reference "http://schema.org/" ] ; + linkml:see_also "https://specs.frictionlessdata.io/data-resource", + "https://www.w3.org/TR/hcls-dataset/", + "https://www.w3.org/TR/void/" ; + linkml:slots [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportconforms_to_schema" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "https://specs.frictionlessdata.io/schema" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "conforms_to" ; + linkml:name "conforms_to_schema" ; + linkml:owner "Information" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "https://w3id.org/linkml/reportconforms_to_schema" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportkeywords" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "http://schema.org/keywords" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#keyword" ; + linkml:multivalued true ; + linkml:name "keywords" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:singular_name "keyword" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#keyword" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportpublisher" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/publisher" ; + linkml:name "publisher" ; + linkml:owner "Information" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "http://purl.org/dc/terms/publisher" ], + [ a linkml:SlotDefinition ; + linkml:alias "double_quote" ; + linkml:domain_of "FormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "formatDialect__double_quote" ; + linkml:owner "FormatDialect" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportdouble_quote" ], + [ a linkml:SlotDefinition ; + dcterms:description "time at which the element was last updated" ; + linkml:definition_uri "https://w3id.org/linkml/reportlast_updated_on" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/pav/lastUpdatedOn" ; + linkml:name "last_updated_on" ; + linkml:range "datetime" ; + linkml:slot_uri "http://purl.org/pav/lastUpdatedOn" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportsha256" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "hash" ; + linkml:name "sha256" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportsha256" ], + [ a linkml:SlotDefinition ; + dcterms:description "status of the element" ; + linkml:definition_uri "https://w3id.org/linkml/reportstatus" ; + linkml:examples [ a linkml:Example ; + linkml:value "bibo:draft" ] ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://example.org/UNKNOWN/bibo/status" ; + linkml:name "status" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "http://example.org/UNKNOWN/bibo/status" ], + [ a linkml:SlotDefinition ; + dcterms:description "time at which the element was created" ; + linkml:definition_uri "https://w3id.org/linkml/reportcreated_on" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/pav/createdOn" ; + linkml:name "created_on" ; + linkml:owner "Information" ; + linkml:range "datetime" ; + linkml:slot_uri "http://purl.org/pav/createdOn" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportprofile" ; + linkml:exact_mappings "https://specs.frictionlessdata.io/profiles" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "profile" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "https://w3id.org/linkml/reportprofile" ], + [ a linkml:SlotDefinition ; + linkml:close_mappings "https://specs.frictionlessdata.io/path" ; + linkml:definition_uri "https://w3id.org/linkml/reportdownload_url" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "http://schema.org/url" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#downloadURL" ; + linkml:name "download_url" ; + linkml:owner "Information" ; + linkml:range "uri" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#downloadURL" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportmd5" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "hash" ; + linkml:name "md5" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportmd5" ], + [ a linkml:SlotDefinition ; + dcterms:description "license for the data" ; + linkml:definition_uri "https://w3id.org/linkml/reportlicense" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "https://specs.frictionlessdata.io/licenses" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/license" ; + linkml:name "license" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "http://purl.org/dc/terms/license" ], + [ a linkml:SlotDefinition ; + dcterms:description "the official title of the element" ; + linkml:definition_uri "https://w3id.org/linkml/reporttitle" ; + linkml:domain_of "DataResource", + "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/title" ; + linkml:name "title" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "http://purl.org/dc/terms/title" ], + [ a linkml:SlotDefinition ; + linkml:alias "header" ; + linkml:domain_of "FormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "formatDialect__header" ; + linkml:owner "FormatDialect" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportheader" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reporthash" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "hash" ; + linkml:notes "we recommend using a more specific slot such as sha256 or md5" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reporthash" ], + [ a linkml:SlotDefinition ; + dcterms:description "language in which the information is expressed" ; + linkml:definition_uri "https://w3id.org/linkml/reportlanguage" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "language" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportlanguage" ], + [ a linkml:SlotDefinition ; + dcterms:description "human readable description of the information" ; + linkml:definition_uri "https://w3id.org/linkml/reportdescription" ; + linkml:domain_of "DataResource", + "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/description" ; + linkml:name "description" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "http://purl.org/dc/terms/description" ], + [ a linkml:SlotDefinition ; + dcterms:description "the unique name of th dataset" ; + linkml:definition_uri "https://w3id.org/linkml/reportid" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "http://schema.org/name" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:identifier true ; + linkml:mappings "http://purl.org/dc/terms/identifier" ; + linkml:name "id" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:required true ; + linkml:slot_uri "http://purl.org/dc/terms/identifier" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportencoding" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "encoding" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportencoding" ], + [ a linkml:SlotDefinition ; + dcterms:description "A derivation is a transformation of an entity into another, an update of an entity resulting in a new one, or the construction of a new entity based on a pre-existing entity.@en" ; + linkml:definition_uri "https://w3id.org/linkml/reportwas_derived_from" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/prov#wasDerivedFrom" ; + linkml:name "was_derived_from" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "http://www.w3.org/ns/prov#wasDerivedFrom" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportthemes" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#theme" ; + linkml:multivalued true ; + linkml:name "themes" ; + linkml:range "uriorcurie" ; + linkml:singular_name "theme" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#theme" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportcompression" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "compression" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportcompression" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportconforms_to" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/conformsTo" ; + linkml:name "conforms_to" ; + linkml:owner "Information" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "http://purl.org/dc/terms/conformsTo" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reporttest_roles" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:multivalued true ; + linkml:name "test_roles" ; + linkml:owner "Information" ; + linkml:range "TestRole" ; + linkml:slot_uri "https://w3id.org/linkml/reporttest_roles" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportmedia_type" ; + linkml:domain_of "DataResource" ; + linkml:exact_mappings "http://schema.org/encodingFormat", + "https://specs.frictionlessdata.io/mediatype" ; + linkml:examples [ a linkml:Example ; + linkml:value "text/csv" ], + [ a linkml:Example ; + linkml:value "application/json" ] ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#mediaType" ; + linkml:name "media_type" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#mediaType" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportissued" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/issued" ; + linkml:name "issued" ; + linkml:owner "Information" ; + linkml:range "datetime" ; + linkml:slot_uri "http://purl.org/dc/terms/issued" ], + [ a linkml:SlotDefinition ; + dcterms:description "class in schema which the data object instantiates" ; + linkml:definition_uri "https://w3id.org/linkml/reportconforms_to_class" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:is_a "conforms_to" ; + linkml:name "conforms_to_class" ; + linkml:owner "Information" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "https://w3id.org/linkml/reportconforms_to_class" ], + [ a linkml:SlotDefinition ; + linkml:close_mappings "https://specs.frictionlessdata.io/path" ; + linkml:definition_uri "https://w3id.org/linkml/reportpath" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "path" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportpath" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportpage" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#landingPage" ; + linkml:name "page" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#landingPage" ], + [ a linkml:SlotDefinition ; + linkml:alias "delimiter" ; + linkml:domain_of "FormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "formatDialect__delimiter" ; + linkml:owner "FormatDialect" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportdelimiter" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportdialect" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/csvw#dialect" ; + linkml:name "dialect" ; + linkml:owner "DataResource" ; + linkml:range "string" ; + linkml:slot_uri "http://www.w3.org/ns/csvw#dialect" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportresources" ; + linkml:domain_of "DataPackage" ; + linkml:exact_mappings "http://schema.org/distribution" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#distribution" ; + linkml:multivalued true ; + linkml:name "resources" ; + linkml:owner "DataPackage" ; + linkml:range "DataResource" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#distribution" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportbytes" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://www.w3.org/ns/dcat#byteSize" ; + linkml:name "bytes" ; + linkml:owner "DataResource" ; + linkml:range "integer" ; + linkml:slot_uri "http://www.w3.org/ns/dcat#byteSize" ], + [ a linkml:SlotDefinition ; + linkml:alias "quote_char" ; + linkml:domain_of "FormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "formatDialect__quote_char" ; + linkml:owner "FormatDialect" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportquote_char" ], + [ a linkml:SlotDefinition ; + dcterms:description "agent that created the element" ; + linkml:definition_uri "https://w3id.org/linkml/reportcreated_by" ; + linkml:domain_of "Information" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/pav/createdBy" ; + linkml:name "created_by" ; + linkml:owner "Information" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "http://purl.org/pav/createdBy" ], + [ a linkml:SlotDefinition ; + linkml:definition_uri "https://w3id.org/linkml/reportformat" ; + linkml:domain_of "DataResource" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/dc/terms/format" ; + linkml:name "format" ; + linkml:owner "DataResource" ; + linkml:range "FormatEnum" ; + linkml:slot_uri "http://purl.org/dc/terms/format" ], + [ a linkml:SlotDefinition ; + linkml:alias "comment_prefix" ; + linkml:domain_of "FormatDialect" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:name "formatDialect__comment_prefix" ; + linkml:owner "FormatDialect" ; + linkml:range "string" ; + linkml:slot_uri "https://w3id.org/linkml/reportcomment_prefix" ], + [ a linkml:SlotDefinition ; + dcterms:description "agent that modified the element" ; + linkml:definition_uri "https://w3id.org/linkml/reportmodified_by" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://example.org/UNKNOWN/oslc/modifiedBy" ; + linkml:name "modified_by" ; + linkml:range "uriorcurie" ; + linkml:slot_uri "http://example.org/UNKNOWN/oslc/modifiedBy" ], + [ a linkml:SlotDefinition ; + dcterms:description "particular version of schema" ; + linkml:definition_uri "https://w3id.org/linkml/reportversion" ; + linkml:domain_of "Information" ; + linkml:exact_mappings "http://purl.org/dc/terms/hasVersion", + "http://schema.org/version" ; + linkml:from_schema "https://w3id.org/linkml/datasets" ; + linkml:mappings "http://purl.org/pav/version" ; + linkml:name "version" ; + linkml:owner "Information" ; + linkml:range "string" ; + linkml:slot_uri "http://purl.org/pav/version" ] ; + linkml:source_file "datasets.yaml" ; + linkml:source_file_date "2022-07-14T00:55:10" ; + linkml:source_file_size 7804 ; + linkml:types [ a linkml:TypeDefinition ; + dcterms:description "A URI, CURIE or BNODE that represents a node in a model." ; + linkml:base "NodeIdentifier" ; + linkml:definition_uri "https://w3id.org/linkml/Nodeidentifier" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "nodeidentifier" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/ns/shex#nonLiteral" ], + [ a linkml:TypeDefinition ; + dcterms:description "A binary (true or false) value" ; + linkml:base "Bool" ; + linkml:definition_uri "https://w3id.org/linkml/Boolean" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "boolean" ; + linkml:repr "bool" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#boolean" ], + [ a linkml:TypeDefinition ; + dcterms:description "a date (year, month and day) in an idealized calendar" ; + linkml:base "XSDDate" ; + linkml:definition_uri "https://w3id.org/linkml/Date" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "date" ; + linkml:notes "URI is dateTime because OWL reasoners don't work with straight date or time" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#date" ], + [ a linkml:TypeDefinition ; + dcterms:description "a complete URI" ; + linkml:base "URI" ; + linkml:definition_uri "https://w3id.org/linkml/Uri" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "uri" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#anyURI" ], + [ a linkml:TypeDefinition ; + dcterms:description "A real number that conforms to the xsd:double specification" ; + linkml:base "float" ; + linkml:definition_uri "https://w3id.org/linkml/Double" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "double" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#double" ], + [ a linkml:TypeDefinition ; + dcterms:description "Either a date or a datetime" ; + linkml:base "str" ; + linkml:definition_uri "https://w3id.org/linkml/DateOrDatetime" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "date_or_datetime" ; + linkml:repr "str" ; + linkml:uri "https://w3id.org/linkml/DateOrDatetime" ], + [ a linkml:TypeDefinition ; + dcterms:description "A character string" ; + linkml:base "str" ; + linkml:definition_uri "https://w3id.org/linkml/String" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "string" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#string" ], + [ a linkml:TypeDefinition ; + dcterms:description "Prefix part of CURIE" ; + linkml:base "NCName" ; + linkml:definition_uri "https://w3id.org/linkml/Ncname" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "ncname" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#string" ], + [ a linkml:TypeDefinition ; + dcterms:description "A URI or CURIE that represents an object in the model." ; + linkml:base "ElementIdentifier" ; + linkml:comments "Used for inheritence and type checking" ; + linkml:definition_uri "https://w3id.org/linkml/Objectidentifier" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "objectidentifier" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/ns/shex#iri" ], + [ a linkml:TypeDefinition ; + dcterms:description "a URI or a CURIE" ; + linkml:base "URIorCURIE" ; + linkml:definition_uri "https://w3id.org/linkml/Uriorcurie" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "uriorcurie" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#anyURI" ], + [ a linkml:TypeDefinition ; + dcterms:description "An integer" ; + linkml:base "int" ; + linkml:definition_uri "https://w3id.org/linkml/Integer" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "integer" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#integer" ], + [ a linkml:TypeDefinition ; + dcterms:description "A real number with arbitrary precision that conforms to the xsd:decimal specification" ; + linkml:base "Decimal" ; + linkml:definition_uri "https://w3id.org/linkml/Decimal" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "decimal" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#decimal" ], + [ a linkml:TypeDefinition ; + dcterms:description "The combination of a date and time" ; + linkml:base "XSDDateTime" ; + linkml:definition_uri "https://w3id.org/linkml/Datetime" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "datetime" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#dateTime" ], + [ a linkml:TypeDefinition ; + dcterms:description "A real number that conforms to the xsd:float specification" ; + linkml:base "float" ; + linkml:definition_uri "https://w3id.org/linkml/Float" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "float" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#float" ], + [ a linkml:TypeDefinition ; + dcterms:description "A time object represents a (local) time of day, independent of any particular day" ; + linkml:base "XSDTime" ; + linkml:definition_uri "https://w3id.org/linkml/Time" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:imported_from "linkml:types" ; + linkml:name "time" ; + linkml:notes "URI is dateTime because OWL reasoners don't work with straight date or time" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#dateTime" ] . + + + diff --git a/linkml_runtime/linkml_model/rdf/meta.model.ttl b/linkml_runtime/linkml_model/rdf/meta.model.ttl index 27072bc4..448199b3 100644 --- a/linkml_runtime/linkml_model/rdf/meta.model.ttl +++ b/linkml_runtime/linkml_model/rdf/meta.model.ttl @@ -3784,13 +3784,13 @@ linkml:UnitOfMeasure a linkml:ClassDefinition ; skos:inScheme linkml:units ; skos:mappingRelation qudt:Unit ; linkml:any_of [ a linkml:AnonymousClassExpression ; + linkml:slot_conditions linkml:symbol ], + [ a linkml:AnonymousClassExpression ; linkml:slot_conditions linkml:ucum_code ], [ a linkml:AnonymousClassExpression ; - linkml:slot_conditions linkml:iec61360code ], + linkml:slot_conditions linkml:exact_mappings ], [ a linkml:AnonymousClassExpression ; - linkml:slot_conditions linkml:symbol ], - [ a linkml:AnonymousClassExpression ; - linkml:slot_conditions linkml:exact_mappings ] ; + linkml:slot_conditions linkml:iec61360code ] ; linkml:class_uri qudt:Unit ; linkml:definition_uri linkml:UnitOfMeasure ; linkml:imported_from "linkml:units" ; @@ -4847,7 +4847,7 @@ refer to the official URI for each construct, e.g. linkml:presence_enum, linkml:pv_formula_options, linkml:relational_role_enum ; - linkml:generation_date "2022-07-13T17:57:50"^^xsd:dateTime ; + linkml:generation_date "2022-07-14T00:57:07"^^xsd:dateTime ; linkml:id linkml:meta ; linkml:imports linkml:annotations, linkml:extensions, @@ -4855,38 +4855,38 @@ refer to the official URI for each construct, e.g. linkml:types, linkml:units ; linkml:metamodel_version "1.7.0" ; - linkml:prefixes [ linkml:prefix_prefix "qb" ; + linkml:prefixes [ linkml:prefix_prefix "pav" ; + linkml:prefix_reference pav: ], + [ linkml:prefix_prefix "sh" ; + linkml:prefix_reference sh1: ], + [ linkml:prefix_prefix "bibo" ; + linkml:prefix_reference bibo: ], + [ linkml:prefix_prefix "qb" ; linkml:prefix_reference qb: ], - [ linkml:prefix_prefix "schema" ; - linkml:prefix_reference schema1: ], - [ linkml:prefix_prefix "swrl" ; - linkml:prefix_reference swrl: ], [ linkml:prefix_prefix "skosxl" ; linkml:prefix_reference skosxl: ], - [ linkml:prefix_prefix "oslc" ; - linkml:prefix_reference oslc: ], - [ linkml:prefix_prefix "skos" ; - linkml:prefix_reference skos: ], - [ linkml:prefix_prefix "owl" ; - linkml:prefix_reference owl: ], [ linkml:prefix_prefix "linkml" ; linkml:prefix_reference linkml: ], - [ linkml:prefix_prefix "pav" ; - linkml:prefix_reference pav: ], - [ linkml:prefix_prefix "bibo" ; - linkml:prefix_reference bibo: ], - [ linkml:prefix_prefix "sh" ; - linkml:prefix_reference sh1: ], - [ linkml:prefix_prefix "NCIT" ; - linkml:prefix_reference NCIT: ], [ linkml:prefix_prefix "vann" ; linkml:prefix_reference vann1: ], - [ linkml:prefix_prefix "qudt" ; - linkml:prefix_reference qudt: ], + [ linkml:prefix_prefix "skos" ; + linkml:prefix_reference skos: ], [ linkml:prefix_prefix "OIO" ; linkml:prefix_reference OIO: ], + [ linkml:prefix_prefix "oslc" ; + linkml:prefix_reference oslc: ], + [ linkml:prefix_prefix "swrl" ; + linkml:prefix_reference swrl: ], + [ linkml:prefix_prefix "qudt" ; + linkml:prefix_reference qudt: ], + [ linkml:prefix_prefix "schema" ; + linkml:prefix_reference schema1: ], [ linkml:prefix_prefix "prov" ; - linkml:prefix_reference prov: ] ; + linkml:prefix_reference prov: ], + [ linkml:prefix_prefix "owl" ; + linkml:prefix_reference owl: ], + [ linkml:prefix_prefix "NCIT" ; + linkml:prefix_reference NCIT: ] ; linkml:slots linkml:UnitOfMeasure_exact_mappings, linkml:abstract, linkml:alias, @@ -5133,7 +5133,7 @@ refer to the official URI for each construct, e.g. linkml:values_from, linkml:version ; linkml:source_file "meta.yaml" ; - linkml:source_file_date "2022-07-13T17:52:28"^^xsd:dateTime ; + linkml:source_file_date "2022-07-14T00:55:10"^^xsd:dateTime ; linkml:source_file_size 71464 ; linkml:subsets linkml:basic, linkml:minimal, diff --git a/linkml_runtime/linkml_model/rdf/meta.ttl b/linkml_runtime/linkml_model/rdf/meta.ttl index 245be952..4954187e 100644 --- a/linkml_runtime/linkml_model/rdf/meta.ttl +++ b/linkml_runtime/linkml_model/rdf/meta.ttl @@ -3788,9 +3788,9 @@ linkml:UnitOfMeasure a linkml:ClassDefinition ; [ a linkml:AnonymousClassExpression ; linkml:slot_conditions linkml:symbol ], [ a linkml:AnonymousClassExpression ; - linkml:slot_conditions linkml:ucum_code ], + linkml:slot_conditions linkml:exact_mappings ], [ a linkml:AnonymousClassExpression ; - linkml:slot_conditions linkml:exact_mappings ] ; + linkml:slot_conditions linkml:ucum_code ] ; linkml:class_uri qudt:Unit ; linkml:definition_uri linkml:UnitOfMeasure ; linkml:imported_from "linkml:units" ; @@ -4847,7 +4847,7 @@ refer to the official URI for each construct, e.g. linkml:presence_enum, linkml:pv_formula_options, linkml:relational_role_enum ; - linkml:generation_date "2022-07-13T17:57:34"^^xsd:dateTime ; + linkml:generation_date "2022-07-14T00:56:53"^^xsd:dateTime ; linkml:id linkml:meta ; linkml:imports linkml:annotations, linkml:extensions, @@ -4855,38 +4855,38 @@ refer to the official URI for each construct, e.g. linkml:types, linkml:units ; linkml:metamodel_version "1.7.0" ; - linkml:prefixes [ linkml:prefix_prefix "qudt" ; - linkml:prefix_reference qudt: ], + linkml:prefixes [ linkml:prefix_prefix "owl" ; + linkml:prefix_reference owl: ], + [ linkml:prefix_prefix "vann" ; + linkml:prefix_reference vann1: ], + [ linkml:prefix_prefix "sh" ; + linkml:prefix_reference sh1: ], [ linkml:prefix_prefix "qb" ; linkml:prefix_reference qb: ], - [ linkml:prefix_prefix "schema" ; - linkml:prefix_reference schema1: ], [ linkml:prefix_prefix "linkml" ; linkml:prefix_reference linkml: ], + [ linkml:prefix_prefix "skos" ; + linkml:prefix_reference skos: ], + [ linkml:prefix_prefix "skosxl" ; + linkml:prefix_reference skosxl: ], + [ linkml:prefix_prefix "OIO" ; + linkml:prefix_reference OIO: ], [ linkml:prefix_prefix "bibo" ; linkml:prefix_reference bibo: ], - [ linkml:prefix_prefix "sh" ; - linkml:prefix_reference sh1: ], - [ linkml:prefix_prefix "swrl" ; - linkml:prefix_reference swrl: ], + [ linkml:prefix_prefix "oslc" ; + linkml:prefix_reference oslc: ], + [ linkml:prefix_prefix "qudt" ; + linkml:prefix_reference qudt: ], [ linkml:prefix_prefix "NCIT" ; linkml:prefix_reference NCIT: ], + [ linkml:prefix_prefix "pav" ; + linkml:prefix_reference pav: ], [ linkml:prefix_prefix "prov" ; linkml:prefix_reference prov: ], - [ linkml:prefix_prefix "owl" ; - linkml:prefix_reference owl: ], - [ linkml:prefix_prefix "oslc" ; - linkml:prefix_reference oslc: ], - [ linkml:prefix_prefix "OIO" ; - linkml:prefix_reference OIO: ], - [ linkml:prefix_prefix "skos" ; - linkml:prefix_reference skos: ], - [ linkml:prefix_prefix "skosxl" ; - linkml:prefix_reference skosxl: ], - [ linkml:prefix_prefix "vann" ; - linkml:prefix_reference vann1: ], - [ linkml:prefix_prefix "pav" ; - linkml:prefix_reference pav: ] ; + [ linkml:prefix_prefix "schema" ; + linkml:prefix_reference schema1: ], + [ linkml:prefix_prefix "swrl" ; + linkml:prefix_reference swrl: ] ; linkml:slots linkml:UnitOfMeasure_exact_mappings, linkml:abstract, linkml:alias, @@ -5133,7 +5133,7 @@ refer to the official URI for each construct, e.g. linkml:values_from, linkml:version ; linkml:source_file "meta.yaml" ; - linkml:source_file_date "2022-07-13T17:52:28"^^xsd:dateTime ; + linkml:source_file_date "2022-07-14T00:55:10"^^xsd:dateTime ; linkml:source_file_size 71464 ; linkml:subsets linkml:basic, linkml:minimal, diff --git a/linkml_runtime/linkml_model/rdf/types.model.ttl b/linkml_runtime/linkml_model/rdf/types.model.ttl index 38738073..91bd2ab3 100644 --- a/linkml_runtime/linkml_model/rdf/types.model.ttl +++ b/linkml_runtime/linkml_model/rdf/types.model.ttl @@ -6,29 +6,45 @@ linkml:default_prefix "linkml" ; linkml:default_range "string" ; linkml:description "Shared type definitions for the core LinkML mode and metamodel" ; - linkml:generation_date "2022-07-13T17:57:45" ; + linkml:generation_date "2022-07-14T00:57:00" ; linkml:id "https://w3id.org/linkml/types" ; linkml:license "https://creativecommons.org/publicdomain/zero/1.0/" ; linkml:metamodel_version "1.7.0" ; linkml:name "types" ; linkml:prefixes [ linkml:prefix_prefix "linkml" ; linkml:prefix_reference "https://w3id.org/linkml/" ], - [ linkml:prefix_prefix "xsd" ; - linkml:prefix_reference "http://www.w3.org/2001/XMLSchema#" ], [ linkml:prefix_prefix "shex" ; - linkml:prefix_reference "http://www.w3.org/ns/shex#" ] ; + linkml:prefix_reference "http://www.w3.org/ns/shex#" ], + [ linkml:prefix_prefix "xsd" ; + linkml:prefix_reference "http://www.w3.org/2001/XMLSchema#" ] ; linkml:source_file "types.yaml" ; - linkml:source_file_date "2022-06-27T20:36:40" ; + linkml:source_file_date "2022-07-14T00:55:10" ; linkml:source_file_size 2848 ; linkml:title "Core LinkML metamodel types" ; linkml:types [ a linkml:TypeDefinition ; - linkml:base "NodeIdentifier" ; - linkml:definition_uri "https://w3id.org/linkml/Nodeidentifier" ; - linkml:description "A URI, CURIE or BNODE that represents a node in a model." ; + linkml:base "float" ; + linkml:definition_uri "https://w3id.org/linkml/Float" ; + linkml:description "A real number that conforms to the xsd:float specification" ; linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "nodeidentifier" ; + linkml:name "float" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#float" ], + [ a linkml:TypeDefinition ; + linkml:base "Bool" ; + linkml:definition_uri "https://w3id.org/linkml/Boolean" ; + linkml:description "A binary (true or false) value" ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:name "boolean" ; + linkml:repr "bool" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#boolean" ], + [ a linkml:TypeDefinition ; + linkml:base "ElementIdentifier" ; + linkml:comments "Used for inheritence and type checking" ; + linkml:definition_uri "https://w3id.org/linkml/Objectidentifier" ; + linkml:description "A URI or CURIE that represents an object in the model." ; + linkml:from_schema "https://w3id.org/linkml/types" ; + linkml:name "objectidentifier" ; linkml:repr "str" ; - linkml:uri "http://www.w3.org/ns/shex#nonLiteral" ], + linkml:uri "http://www.w3.org/ns/shex#iri" ], [ a linkml:TypeDefinition ; linkml:base "XSDTime" ; linkml:definition_uri "https://w3id.org/linkml/Time" ; @@ -39,26 +55,26 @@ linkml:repr "str" ; linkml:uri "http://www.w3.org/2001/XMLSchema#dateTime" ], [ a linkml:TypeDefinition ; - linkml:base "Bool" ; - linkml:definition_uri "https://w3id.org/linkml/Boolean" ; - linkml:description "A binary (true or false) value" ; + linkml:base "Decimal" ; + linkml:definition_uri "https://w3id.org/linkml/Decimal" ; + linkml:description "A real number with arbitrary precision that conforms to the xsd:decimal specification" ; linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "boolean" ; - linkml:repr "bool" ; - linkml:uri "http://www.w3.org/2001/XMLSchema#boolean" ], + linkml:name "decimal" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#decimal" ], [ a linkml:TypeDefinition ; linkml:base "str" ; - linkml:definition_uri "https://w3id.org/linkml/String" ; - linkml:description "A character string" ; + linkml:definition_uri "https://w3id.org/linkml/DateOrDatetime" ; + linkml:description "Either a date or a datetime" ; linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "string" ; - linkml:uri "http://www.w3.org/2001/XMLSchema#string" ], + linkml:name "date_or_datetime" ; + linkml:repr "str" ; + linkml:uri "https://w3id.org/linkml/DateOrDatetime" ], [ a linkml:TypeDefinition ; - linkml:base "URI" ; - linkml:definition_uri "https://w3id.org/linkml/Uri" ; - linkml:description "a complete URI" ; + linkml:base "URIorCURIE" ; + linkml:definition_uri "https://w3id.org/linkml/Uriorcurie" ; + linkml:description "a URI or a CURIE" ; linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "uri" ; + linkml:name "uriorcurie" ; linkml:repr "str" ; linkml:uri "http://www.w3.org/2001/XMLSchema#anyURI" ], [ a linkml:TypeDefinition ; @@ -71,20 +87,13 @@ linkml:repr "str" ; linkml:uri "http://www.w3.org/2001/XMLSchema#date" ], [ a linkml:TypeDefinition ; - linkml:base "NCName" ; - linkml:definition_uri "https://w3id.org/linkml/Ncname" ; - linkml:description "Prefix part of CURIE" ; + linkml:base "NodeIdentifier" ; + linkml:definition_uri "https://w3id.org/linkml/Nodeidentifier" ; + linkml:description "A URI, CURIE or BNODE that represents a node in a model." ; linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "ncname" ; + linkml:name "nodeidentifier" ; linkml:repr "str" ; - linkml:uri "http://www.w3.org/2001/XMLSchema#string" ], - [ a linkml:TypeDefinition ; - linkml:base "float" ; - linkml:definition_uri "https://w3id.org/linkml/Float" ; - linkml:description "A real number that conforms to the xsd:float specification" ; - linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "float" ; - linkml:uri "http://www.w3.org/2001/XMLSchema#float" ], + linkml:uri "http://www.w3.org/ns/shex#nonLiteral" ], [ a linkml:TypeDefinition ; linkml:base "XSDDateTime" ; linkml:definition_uri "https://w3id.org/linkml/Datetime" ; @@ -94,29 +103,27 @@ linkml:repr "str" ; linkml:uri "http://www.w3.org/2001/XMLSchema#dateTime" ], [ a linkml:TypeDefinition ; - linkml:base "Decimal" ; - linkml:definition_uri "https://w3id.org/linkml/Decimal" ; - linkml:description "A real number with arbitrary precision that conforms to the xsd:decimal specification" ; + linkml:base "NCName" ; + linkml:definition_uri "https://w3id.org/linkml/Ncname" ; + linkml:description "Prefix part of CURIE" ; linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "decimal" ; - linkml:uri "http://www.w3.org/2001/XMLSchema#decimal" ], + linkml:name "ncname" ; + linkml:repr "str" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#string" ], [ a linkml:TypeDefinition ; - linkml:base "ElementIdentifier" ; - linkml:comments "Used for inheritence and type checking" ; - linkml:definition_uri "https://w3id.org/linkml/Objectidentifier" ; - linkml:description "A URI or CURIE that represents an object in the model." ; + linkml:base "float" ; + linkml:definition_uri "https://w3id.org/linkml/Double" ; + linkml:description "A real number that conforms to the xsd:double specification" ; linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "objectidentifier" ; - linkml:repr "str" ; - linkml:uri "http://www.w3.org/ns/shex#iri" ], + linkml:name "double" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#double" ], [ a linkml:TypeDefinition ; linkml:base "str" ; - linkml:definition_uri "https://w3id.org/linkml/DateOrDatetime" ; - linkml:description "Either a date or a datetime" ; + linkml:definition_uri "https://w3id.org/linkml/String" ; + linkml:description "A character string" ; linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "date_or_datetime" ; - linkml:repr "str" ; - linkml:uri "https://w3id.org/linkml/DateOrDatetime" ], + linkml:name "string" ; + linkml:uri "http://www.w3.org/2001/XMLSchema#string" ], [ a linkml:TypeDefinition ; linkml:base "int" ; linkml:definition_uri "https://w3id.org/linkml/Integer" ; @@ -125,18 +132,11 @@ linkml:name "integer" ; linkml:uri "http://www.w3.org/2001/XMLSchema#integer" ], [ a linkml:TypeDefinition ; - linkml:base "float" ; - linkml:definition_uri "https://w3id.org/linkml/Double" ; - linkml:description "A real number that conforms to the xsd:double specification" ; - linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "double" ; - linkml:uri "http://www.w3.org/2001/XMLSchema#double" ], - [ a linkml:TypeDefinition ; - linkml:base "URIorCURIE" ; - linkml:definition_uri "https://w3id.org/linkml/Uriorcurie" ; - linkml:description "a URI or a CURIE" ; + linkml:base "URI" ; + linkml:definition_uri "https://w3id.org/linkml/Uri" ; + linkml:description "a complete URI" ; linkml:from_schema "https://w3id.org/linkml/types" ; - linkml:name "uriorcurie" ; + linkml:name "uri" ; linkml:repr "str" ; linkml:uri "http://www.w3.org/2001/XMLSchema#anyURI" ] ; linkml:version "2.0.0" . diff --git a/linkml_runtime/linkml_model/shacl/meta.shacl.ttl b/linkml_runtime/linkml_model/shacl/meta.shacl.ttl new file mode 100644 index 00000000..933e0c2d --- /dev/null +++ b/linkml_runtime/linkml_model/shacl/meta.shacl.ttl @@ -0,0 +1,4001 @@ +@prefix OIO: . +@prefix bibo: . +@prefix linkml: . +@prefix oslc: . +@prefix owl: . +@prefix pav: . +@prefix qudt: . +@prefix rdf: . +@prefix rdfs: . +@prefix schema: . +@prefix sh: . +@prefix sh1: . +@prefix skos: . +@prefix skosxl: . +@prefix xsd: . + +linkml:Annotatable a sh:NodeShape ; + sh:closed true ; + sh:description "mixin for classes that support annotations" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 0 ; + sh:path linkml:annotations ] ; + sh:targetClass linkml:Annotatable . + +linkml:AnonymousExpression a sh:NodeShape ; + sh:closed true ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 22 ; + sh:path skos:closeMatch ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 12 ; + sh:path linkml:imported_from ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 9 ; + sh:path linkml:examples ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 25 ; + sh:path skos:broadMatch ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 1 ; + sh:path linkml:annotations ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 6 ; + sh:path linkml:todos ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 20 ; + sh:path skos:mappingRelation ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 19 ; + sh:path skosxl:altLabel ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 13 ; + sh:path ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:alt_descriptions ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 21 ; + sh:path skos:exactMatch ], + [ sh:description "Alaternate names for the element" ; + sh:order 18 ; + sh:path skos:altLabel ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 8 ; + sh:path skos:note ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 11 ; + sh:path skos:inScheme ], + [ sh:maxCount 1 ; + sh:order 14 ; + sh:path schema:inLanguage ], + [ sh:description "a reference" ; + sh:order 15 ; + sh:path rdfs:seeAlso ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 7 ; + sh:path skos:editorialNote ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path skos:definition ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 26 ; + sh:path sh1:order ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 17 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 10 ; + sh:path OIO:inSubset ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path linkml:deprecated ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 0 ; + sh:path linkml:extensions ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 24 ; + sh:path skos:narrowMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 23 ; + sh:path skos:relatedMatch ] ; + sh:targetClass linkml:AnonymousExpression . + +linkml:ClassExpression a sh:NodeShape ; + sh:closed true ; + sh:description "A boolean expression that can be used to dynamically determine membership of a class" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if at least one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 0 ; + sh:path linkml:any_of ], + [ sh:class linkml:SlotDefinition ; + sh:description "expresses constraints on a group of slots for a class expression" ; + sh:nodeKind sh:IRI ; + sh:order 4 ; + sh:path linkml:slot_conditions ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if all of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:all_of ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if none of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path linkml:none_of ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if only one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 1 ; + sh:path linkml:exactly_one_of ] ; + sh:targetClass linkml:ClassExpression . + +linkml:ClassLevelRule a sh:NodeShape ; + sh:closed true ; + sh:description "A rule that is applied to classes" ; + sh:ignoredProperties ( rdf:type ) ; + sh:targetClass linkml:ClassLevelRule . + +linkml:CommonMetadata a sh:NodeShape ; + sh:closed true ; + sh:description "Generic metadata shared across definitions" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 21 ; + sh:path skos:relatedMatch ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 6 ; + sh:path skos:note ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 9 ; + sh:path skos:inScheme ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 19 ; + sh:path skos:exactMatch ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 17 ; + sh:path skosxl:altLabel ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 24 ; + sh:path sh1:order ], + [ sh:description "a reference" ; + sh:order 13 ; + sh:path rdfs:seeAlso ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path ], + [ sh:maxCount 1 ; + sh:order 12 ; + sh:path schema:inLanguage ], + [ sh:description "Alaternate names for the element" ; + sh:order 16 ; + sh:path skos:altLabel ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 15 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 1 ; + sh:path linkml:alt_descriptions ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 20 ; + sh:path skos:closeMatch ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 5 ; + sh:path skos:editorialNote ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 10 ; + sh:path linkml:imported_from ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 22 ; + sh:path skos:narrowMatch ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 7 ; + sh:path linkml:examples ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 8 ; + sh:path OIO:inSubset ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:deprecated ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 23 ; + sh:path skos:broadMatch ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path skos:definition ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 11 ; + sh:path ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 4 ; + sh:path linkml:todos ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 18 ; + sh:path skos:mappingRelation ] ; + sh:targetClass linkml:CommonMetadata . + +linkml:Expression a sh:NodeShape ; + sh:closed true ; + sh:description "general mixin for any class that can represent some form of expression" ; + sh:ignoredProperties ( rdf:type ) ; + sh:targetClass linkml:Expression . + +linkml:Extensible a sh:NodeShape ; + sh:closed true ; + sh:description "mixin for classes that support extension" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 0 ; + sh:path linkml:extensions ] ; + sh:targetClass linkml:Extensible . + +linkml:ImportExpression a sh:NodeShape ; + sh:closed true ; + sh:description "an expression describing an import" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 25 ; + sh:path skos:closeMatch ], + [ sh:description "Alaternate names for the element" ; + sh:order 21 ; + sh:path skos:altLabel ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 10 ; + sh:path skos:editorialNote ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 11 ; + sh:path skos:note ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 29 ; + sh:path sh1:order ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 20 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 27 ; + sh:path skos:narrowMatch ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:alt_descriptions ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 4 ; + sh:path linkml:annotations ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 23 ; + sh:path skos:mappingRelation ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 9 ; + sh:path linkml:todos ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:extensions ], + [ sh:description "a reference" ; + sh:order 18 ; + sh:path rdfs:seeAlso ], + [ sh:class linkml:Setting ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path linkml:import_map ], + [ sh:maxCount 1 ; + sh:order 1 ; + sh:path linkml:import_as ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 13 ; + sh:path OIO:inSubset ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 28 ; + sh:path skos:broadMatch ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path skos:inScheme ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path linkml:deprecated ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 15 ; + sh:path linkml:imported_from ], + [ sh:maxCount 1 ; + sh:order 17 ; + sh:path schema:inLanguage ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 24 ; + sh:path skos:exactMatch ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path skos:definition ], + [ sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 0 ; + sh:path linkml:import_from ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 22 ; + sh:path skosxl:altLabel ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 12 ; + sh:path linkml:examples ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 26 ; + sh:path skos:relatedMatch ] ; + sh:targetClass linkml:ImportExpression . + +linkml:SchemaDefinition a sh:NodeShape ; + sh:closed true ; + sh:description "a collection of subset, type, slot and class definitions" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "the identifier of this class or slot must begin with the URIs referenced by this prefix" ; + sh:order 24 ; + sh:path linkml:id_prefixes ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 31 ; + sh:path linkml:alt_descriptions ], + [ sh:description "Keywords or tags used to describe the element" ; + sh:order 22 ; + sh:path schema:keywords ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 29 ; + sh:path linkml:annotations ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 45 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:class linkml:Prefix ; + sh:description "prefix / URI definitions to be added to the context beyond those fetched from prefixcommons in id prefixes" ; + sh:nodeKind sh:BlankNode ; + sh:order 4 ; + sh:path sh1:declare ], + [ sh:description "ordered list of prefixcommon biocontexts to be fetched to resolve id prefixes and inline prefix variables" ; + sh:order 6 ; + sh:path linkml:default_curi_maps ], + [ sh:class linkml:SubsetDefinition ; + sh:description "An index to the collection of all subset definitions in the schema" ; + sh:nodeKind sh:IRI ; + sh:order 9 ; + sh:path linkml:subsets ], + [ sh:description "name, uri or description of the source of the schema" ; + sh:maxCount 1 ; + sh:order 15 ; + sh:path linkml:source_file ], + [ sh:description "An established standard to which the element conforms." ; + sh:maxCount 1 ; + sh:order 27 ; + sh:path ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 33 ; + sh:path linkml:deprecated ], + [ sh:class linkml:Setting ; + sh:description "A collection of global variable settings" ; + sh:nodeKind sh:BlankNode ; + sh:order 20 ; + sh:path linkml:settings ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 44 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "date and time that the schema was loaded/generated" ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path linkml:generation_date ], + [ sh:class linkml:TypeDefinition ; + sh:description "default slot range to be used if range element is omitted from a slot definition" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 8 ; + sh:path linkml:default_range ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 51 ; + sh:path skos:relatedMatch ], + [ sh:description "license for the schema" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 47 ; + sh:path skosxl:altLabel ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 35 ; + sh:path skos:editorialNote ], + [ sh:class linkml:TypeDefinition ; + sh:description "An index to the collection of all type definitions in the schema" ; + sh:nodeKind sh:IRI ; + sh:order 10 ; + sh:path linkml:types ], + [ sh:description "size in bytes of the source of the schema" ; + sh:maxCount 1 ; + sh:order 17 ; + sh:path linkml:source_file_size ], + [ sh:description "other schemas that are included in this schema" ; + sh:order 2 ; + sh:path linkml:imports ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 37 ; + sh:path linkml:examples ], + [ sh:description "a unique name for the schema that is both human-readable and consists of only characters from the NCName set" ; + sh:maxCount 1 ; + sh:order 23 ; + sh:path rdfs:label ], + [ sh:description "the \"native\" URI of the element" ; + sh:maxCount 1 ; + sh:order 25 ; + sh:path linkml:definition_uri ], + [ sh:class linkml:SlotDefinition ; + sh:description "An index to the collection of all slot definitions in the schema" ; + sh:nodeKind sh:IRI ; + sh:order 12 ; + sh:path linkml:slot_definitions ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 48 ; + sh:path skos:mappingRelation ], + [ sh:description "a reference" ; + sh:order 43 ; + sh:path rdfs:seeAlso ], + [ sh:class linkml:ClassDefinition ; + sh:description "An index to the collection of all class definitions in the schema" ; + sh:nodeKind sh:IRI ; + sh:order 13 ; + sh:path linkml:classes ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 34 ; + sh:path linkml:todos ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 32 ; + sh:path ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 36 ; + sh:path skos:note ], + [ sh:description "Alaternate names for the element" ; + sh:order 46 ; + sh:path skos:altLabel ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 53 ; + sh:path skos:broadMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 50 ; + sh:path skos:closeMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 52 ; + sh:path skos:narrowMatch ], + [ sh:class linkml:EnumDefinition ; + sh:description "An index to the collection of all enum definitions in the schema" ; + sh:nodeKind sh:IRI ; + sh:order 11 ; + sh:path linkml:enums ], + [ sh:description "controlled terms used to categorize an element" ; + sh:order 21 ; + sh:path ], + [ sh:description "The official schema URI" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 0 ; + sh:path linkml:id ], + [ sh:maxCount 1 ; + sh:order 42 ; + sh:path schema:inLanguage ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 28 ; + sh:path linkml:extensions ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 54 ; + sh:path sh1:order ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 39 ; + sh:path skos:inScheme ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 38 ; + sh:path OIO:inSubset ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 49 ; + sh:path skos:exactMatch ], + [ sh:class linkml:LocalName ; + sh:nodeKind sh:BlankNode ; + sh:order 26 ; + sh:path linkml:local_names ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 30 ; + sh:path skos:definition ], + [ sh:description "a list of Curie prefixes that are used in the representation of instances of the model. All prefixes in this list are added to the prefix sections of the target models." ; + sh:order 5 ; + sh:path linkml:emit_prefixes ], + [ sh:description "particular version of schema" ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path pav:version ], + [ sh:description "default and base prefix -- used for ':' identifiers, @base and @vocab" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path linkml:default_prefix ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 40 ; + sh:path linkml:imported_from ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 41 ; + sh:path ], + [ sh:description "if true then induced/mangled slot names are not created for class_usage and attributes" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path linkml:slot_names_unique ], + [ sh:description "modification date of the source of the schema" ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path linkml:source_file_date ], + [ sh:description "Version of the metamodel used to load the schema" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path linkml:metamodel_version ] ; + sh:targetClass linkml:SchemaDefinition . + +linkml:SlotExpression a sh:NodeShape ; + sh:closed true ; + sh:description "an expression that constrains the range of values a slot can take" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "the slot must have range string and the value of the slot must equal one of the specified values" ; + sh:order 15 ; + sh:path linkml:equals_string_in ], + [ sh:class linkml:Element ; + sh:description """defines the type of the object of the slot. Given the following slot definition + S1: + domain: C1 + range: C2 +the declaration + X: + S1: Y + +implicitly asserts Y is an instance of C2 +""" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 0 ; + sh:path linkml:range ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "the value of the slot is multivalued with all members satisfying the condition" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 21 ; + sh:path linkml:all_members ], + [ sh:description "the minimum number of entries for a multivalued slot" ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path linkml:minimum_cardinality ], + [ sh:description "the slot must have range string and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path linkml:equals_string ], + [ sh:description "True means that an inlined slot is represented as a list of range instances. False means that an inlined slot is represented as a dictionary, whose key is the slot key or identifier and whose value is the range instance." ; + sh:maxCount 1 ; + sh:order 6 ; + sh:path linkml:inlined_as_list ], + [ sh:description "the value of the slot must equal the value of the evaluated expression" ; + sh:maxCount 1 ; + sh:order 17 ; + sh:path linkml:equals_expression ], + [ sh:description "the slot must have range of a number and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path linkml:equals_number ], + [ sh:description "Causes the slot value to be interpreted as a uriorcurie after prefixing with this string" ; + sh:maxCount 1 ; + sh:order 12 ; + sh:path linkml:implicit_prefix ], + [ sh:description "true means that the slot must be present in the loaded definition" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:required ], + [ sh:description "if true then a value must be present (for lists there must be at least one value). If false then a value must be absent (for lists, must be empty)" ; + sh:in ( "UNCOMMITTED" "PRESENT" "ABSENT" ) ; + sh:maxCount 1 ; + sh:order 13 ; + sh:path linkml:value_presence ], + [ sh:class linkml:EnumExpression ; + sh:description "An inlined enumeration" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path linkml:enum_range ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "the value of the slot is multivalued with at least one member satisfying the condition" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 20 ; + sh:path linkml:has_member ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if all of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 25 ; + sh:path linkml:all_of ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "A range that is described as a boolean expression combining existing ranges" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 1 ; + sh:path linkml:range_expression ], + [ sh:description "true means that the slot should be present in the loaded definition, but this is not required" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path linkml:recommended ], + [ sh:description "for slots with ranges of type number, the value must be equal to or higher than this" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path linkml:minimum_value ], + [ sh:description "the maximum number of entries for a multivalued slot" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path linkml:maximum_cardinality ], + [ sh:description "True means that keyed or identified slot appears in an outer structure by value. False means that only the key or identifier for the slot appears within the domain, referencing a structure that appears elsewhere." ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path linkml:inlined ], + [ sh:description "for slots with ranges of type number, the value must be equal to or lowe than this" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path linkml:maximum_value ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if none of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 22 ; + sh:path linkml:none_of ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if only one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 23 ; + sh:path linkml:exactly_one_of ], + [ sh:class qudt:Unit ; + sh:description "an encoding of a unit" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 11 ; + sh:path qudt:unit ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if at least one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 24 ; + sh:path linkml:any_of ], + [ sh:class linkml:PatternExpression ; + sh:description "the string value of the slot must conform to the regular expression in the pattern expression" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 10 ; + sh:path linkml:structured_pattern ], + [ sh:description "the string value of the slot must conform to this regular expression expressed in the string" ; + sh:maxCount 1 ; + sh:order 9 ; + sh:path linkml:pattern ] ; + sh:targetClass linkml:SlotExpression . + +linkml:TypeExpression a sh:NodeShape ; + sh:closed true ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "Causes the slot value to be interpreted as a uriorcurie after prefixing with this string" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:implicit_prefix ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if all of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 12 ; + sh:path linkml:all_of ], + [ sh:description "the slot must have range of a number and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 6 ; + sh:path linkml:equals_number ], + [ sh:description "the slot must have range string and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path linkml:equals_string ], + [ sh:description "the slot must have range string and the value of the slot must equal one of the specified values" ; + sh:order 5 ; + sh:path linkml:equals_string_in ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if none of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 9 ; + sh:path linkml:none_of ], + [ sh:description "for slots with ranges of type number, the value must be equal to or lowe than this" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path linkml:maximum_value ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if only one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 10 ; + sh:path linkml:exactly_one_of ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if at least one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 11 ; + sh:path linkml:any_of ], + [ sh:description "for slots with ranges of type number, the value must be equal to or higher than this" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path linkml:minimum_value ], + [ sh:class linkml:PatternExpression ; + sh:description "the string value of the slot must conform to the regular expression in the pattern expression" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 1 ; + sh:path linkml:structured_pattern ], + [ sh:class qudt:Unit ; + sh:description "an encoding of a unit" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path qudt:unit ], + [ sh:description "the string value of the slot must conform to this regular expression expressed in the string" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:pattern ] ; + sh:targetClass linkml:TypeExpression . + +linkml:ClassRule a sh:NodeShape ; + sh:closed true ; + sh:description "A rule that applies to instances of a class" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 8 ; + sh:path linkml:annotations ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 27 ; + sh:path skos:mappingRelation ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "an expression that must hold in order for the rule to be applicable to an instance" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 0 ; + sh:path sh1:condition ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 11 ; + sh:path ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 31 ; + sh:path skos:narrowMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 32 ; + sh:path skos:broadMatch ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 24 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 28 ; + sh:path skos:exactMatch ], + [ sh:maxCount 1 ; + sh:order 21 ; + sh:path schema:inLanguage ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 15 ; + sh:path skos:note ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path linkml:imported_from ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "an expression that must hold for an instance of the class, if the preconditions no not hold" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path linkml:elseconditions ], + [ sh:description "a deactivated rule is not executed by the rules engine" ; + sh:maxCount 1 ; + sh:order 6 ; + sh:path sh1:deactivated ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 20 ; + sh:path ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path skos:inScheme ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "an expression that must hold for an instance of the class, if the preconditions hold" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 1 ; + sh:path linkml:postconditions ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 13 ; + sh:path linkml:todos ], + [ sh:description "a reference" ; + sh:order 22 ; + sh:path rdfs:seeAlso ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 7 ; + sh:path linkml:extensions ], + [ sh:description "Alaternate names for the element" ; + sh:order 25 ; + sh:path skos:altLabel ], + [ sh:description "in addition to preconditions entailing postconditions, the postconditions entail the preconditions" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:bidirectional ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 16 ; + sh:path linkml:examples ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 12 ; + sh:path linkml:deprecated ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 14 ; + sh:path skos:editorialNote ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 10 ; + sh:path linkml:alt_descriptions ], + [ sh:description "if true, the the postconditions may be omitted in instance data, but it is valid for an inference engine to add these" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path linkml:open_world ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 17 ; + sh:path OIO:inSubset ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 23 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 26 ; + sh:path skosxl:altLabel ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path sh1:order ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 29 ; + sh:path skos:closeMatch ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 9 ; + sh:path skos:definition ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 30 ; + sh:path skos:relatedMatch ] ; + sh:targetClass linkml:ClassRule . + +linkml:Prefix a sh:NodeShape ; + sh:closed true ; + sh:description "prefix URI tuple" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "the nsname (sans ':' for a given prefix)" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path sh1:prefix ], + [ sh:description "A URI associated with a given prefix" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 1 ; + sh:path sh1:namespace ] ; + sh:targetClass linkml:Prefix . + +linkml:UniqueKey a sh:NodeShape ; + sh:closed true ; + sh:description "a collection of slots whose values uniquely identify an instance of a class" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 15 ; + sh:path ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 8 ; + sh:path linkml:todos ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 26 ; + sh:path skos:narrowMatch ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path linkml:extensions ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 12 ; + sh:path OIO:inSubset ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 10 ; + sh:path skos:note ], + [ sh:description "Alaternate names for the element" ; + sh:order 20 ; + sh:path skos:altLabel ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 25 ; + sh:path skos:relatedMatch ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:annotations ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 28 ; + sh:path sh1:order ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 24 ; + sh:path skos:closeMatch ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path linkml:deprecated ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path skos:definition ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path linkml:imported_from ], + [ sh:maxCount 1 ; + sh:order 16 ; + sh:path schema:inLanguage ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 9 ; + sh:path skos:editorialNote ], + [ sh:description "a reference" ; + sh:order 17 ; + sh:path rdfs:seeAlso ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 21 ; + sh:path skosxl:altLabel ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 5 ; + sh:path linkml:alt_descriptions ], + [ sh:description "name of the unique key" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 0 ; + sh:path linkml:unique_key_name ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 13 ; + sh:path skos:inScheme ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 27 ; + sh:path skos:broadMatch ], + [ sh:class linkml:SlotDefinition ; + sh:description "list of slot names that form a key" ; + sh:minCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 1 ; + sh:path linkml:unique_key_slots ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 11 ; + sh:path linkml:examples ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 23 ; + sh:path skos:exactMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 22 ; + sh:path skos:mappingRelation ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 6 ; + sh:path ] ; + sh:targetClass linkml:UniqueKey . + +linkml:Setting a sh:NodeShape ; + sh:closed true ; + sh:description "assignment of a key to a value" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "The value assigned for a setting" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 1 ; + sh:path linkml:setting_value ], + [ sh:description "the variable name for a setting" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:setting_key ] ; + sh:targetClass linkml:Setting . + +linkml:Element a sh:NodeShape ; + sh:closed true ; + sh:description "a named element in the model" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 9 ; + sh:path ], + [ sh:maxCount 1 ; + sh:order 19 ; + sh:path schema:inLanguage ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 17 ; + sh:path linkml:imported_from ], + [ sh:description "An established standard to which the element conforms." ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path ], + [ sh:description "the \"native\" URI of the element" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path linkml:definition_uri ], + [ sh:description "the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class." ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path rdfs:label ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 11 ; + sh:path linkml:todos ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 29 ; + sh:path skos:narrowMatch ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 15 ; + sh:path OIO:inSubset ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 5 ; + sh:path linkml:extensions ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 10 ; + sh:path linkml:deprecated ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 27 ; + sh:path skos:closeMatch ], + [ sh:description "the identifier of this class or slot must begin with the URIs referenced by this prefix" ; + sh:order 1 ; + sh:path linkml:id_prefixes ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 12 ; + sh:path skos:editorialNote ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 25 ; + sh:path skos:mappingRelation ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 22 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 14 ; + sh:path linkml:examples ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 24 ; + sh:path skosxl:altLabel ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 8 ; + sh:path linkml:alt_descriptions ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 31 ; + sh:path sh1:order ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:annotations ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 30 ; + sh:path skos:broadMatch ], + [ sh:description "a reference" ; + sh:order 20 ; + sh:path rdfs:seeAlso ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path skos:inScheme ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 26 ; + sh:path skos:exactMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 28 ; + sh:path skos:relatedMatch ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 21 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:class linkml:LocalName ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:local_names ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 13 ; + sh:path skos:note ], + [ sh:description "Alaternate names for the element" ; + sh:order 23 ; + sh:path skos:altLabel ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path skos:definition ] ; + sh:targetClass linkml:Element . + +linkml:EnumExpression a sh:NodeShape ; + sh:closed true ; + sh:description "An expression that constrains the range of a slot" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "the version identifier of the enumeration code set" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path linkml:code_set_version ], + [ sh:class linkml:AnonymousEnumExpression ; + sh:description "An enum expression that yields a list of permissible values that are to be included, after subtracting the minus set" ; + sh:nodeKind sh:BlankNode ; + sh:order 5 ; + sh:path linkml:include ], + [ sh:description "the identifier of an enumeration code set." ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:code_set ], + [ sh:class linkml:AnonymousEnumExpression ; + sh:description "An enum expression that yields a list of permissible values that are to be subtracted from the enum" ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:minus ], + [ sh:class linkml:EnumDefinition ; + sh:description "An enum definition that is used as the basis to create a new enum" ; + sh:nodeKind sh:IRI ; + sh:order 7 ; + sh:path linkml:inherits ], + [ sh:class linkml:ReachabilityQuery ; + sh:description "Specifies a query for obtaining a list of permissible values based on graph reachability" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 8 ; + sh:path linkml:reachable_from ], + [ sh:description "Defines the specific formula to be used to generate the permissible values." ; + sh:in ( "CODE" "CURIE" "URI" "FHIR_CODING" ) ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:pv_formula ], + [ sh:class linkml:MatchQuery ; + sh:description "Specifies a match query that is used to calculate the list of permissible values" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 9 ; + sh:path linkml:matches ], + [ sh:description "the version tag of the enumeration code set" ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path linkml:code_set_tag ], + [ sh:description "A list of identifiers that are used to construct a set of permissible values" ; + sh:order 10 ; + sh:path linkml:concepts ], + [ sh:class linkml:PermissibleValue ; + sh:description "A list of possible values for a slot range" ; + sh:nodeKind sh:IRI ; + sh:order 4 ; + sh:path linkml:permissible_values ] ; + sh:targetClass linkml:EnumExpression . + +linkml:MatchQuery a sh:NodeShape ; + sh:closed true ; + sh:description "A query that is used on an enum expression to dynamically obtain a set of permissivle values via a query that matches on properties of the external concepts" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "A regular expression that is used to obtain a set of identifiers from a source_ontology to construct a set of permissible values" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:identifier_pattern ], + [ sh:description "An ontology or vocabulary or terminology that is used in a query to obtain a set of permissible values" ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path linkml:source_ontology ] ; + sh:targetClass linkml:MatchQuery . + +linkml:PermissibleValue a sh:NodeShape ; + sh:closed true ; + sh:description "a permissible value, accompanied by intended text and an optional mapping to a concept URI" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 29 ; + sh:path sh1:order ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 23 ; + sh:path skos:mappingRelation ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 27 ; + sh:path skos:narrowMatch ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 20 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "a reference" ; + sh:order 18 ; + sh:path rdfs:seeAlso ], + [ sh:description "the value meaning of a permissible value" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path linkml:meaning ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 10 ; + sh:path skos:editorialNote ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 25 ; + sh:path skos:closeMatch ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 15 ; + sh:path linkml:imported_from ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 26 ; + sh:path skos:relatedMatch ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path skos:definition ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 5 ; + sh:path linkml:annotations ], + [ sh:maxCount 1 ; + sh:order 17 ; + sh:path schema:inLanguage ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 11 ; + sh:path skos:note ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path skos:inScheme ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 24 ; + sh:path skos:exactMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 28 ; + sh:path skos:broadMatch ], + [ sh:class qudt:Unit ; + sh:description "an encoding of a unit" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path qudt:unit ], + [ sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:text ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 9 ; + sh:path linkml:todos ], + [ sh:description "Alaternate names for the element" ; + sh:order 21 ; + sh:path skos:altLabel ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 22 ; + sh:path skosxl:altLabel ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 13 ; + sh:path OIO:inSubset ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path linkml:deprecated ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 4 ; + sh:path linkml:extensions ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:alt_descriptions ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 12 ; + sh:path linkml:examples ] ; + sh:targetClass linkml:PermissibleValue . + +linkml:ReachabilityQuery a sh:NodeShape ; + sh:closed true ; + sh:description "A query that is used on an enum expression to dynamically obtain a set of permissible values via walking from a set of source nodes to a set of descendants or ancestors over a set of relationship types" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "True if the reachability query should only include directly related nodes, if False then include also transitively connected" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:is_direct ], + [ sh:description "A list of nodes that are used in the reachability query" ; + sh:order 1 ; + sh:path linkml:source_nodes ], + [ sh:description "An ontology or vocabulary or terminology that is used in a query to obtain a set of permissible values" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:source_ontology ], + [ sh:description "True if the direction of the reachability query is reversed and ancestors are retrieved" ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path linkml:traverse_up ], + [ sh:description "True if the query is reflexive" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path linkml:include_self ], + [ sh:description "A list of relationship types (properties) that are used in a reachability query" ; + sh:order 2 ; + sh:path linkml:relationship_types ] ; + sh:targetClass linkml:ReachabilityQuery . + +linkml:EnumDefinition a sh:NodeShape ; + sh:closed true ; + sh:description "an element whose instances must be drawn from a specified set of permissible values" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "a reference" ; + sh:order 44 ; + sh:path rdfs:seeAlso ], + [ sh:maxCount 1 ; + sh:order 43 ; + sh:path schema:inLanguage ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 33 ; + sh:path ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 30 ; + sh:path linkml:annotations ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 51 ; + sh:path skos:closeMatch ], + [ sh:class linkml:EnumDefinition ; + sh:description "An enum definition that is used as the basis to create a new enum" ; + sh:nodeKind sh:IRI ; + sh:order 8 ; + sh:path linkml:inherits ], + [ sh:description "A list of identifiers that are used to construct a set of permissible values" ; + sh:order 11 ; + sh:path linkml:concepts ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 35 ; + sh:path linkml:todos ], + [ sh:description "An established standard to which the element conforms." ; + sh:maxCount 1 ; + sh:order 28 ; + sh:path ], + [ sh:description "status of the element" ; + sh:maxCount 1 ; + sh:order 22 ; + sh:path bibo:status ], + [ sh:description "time at which the element was last updated" ; + sh:maxCount 1 ; + sh:order 20 ; + sh:path pav:lastUpdatedOn ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 38 ; + sh:path linkml:examples ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 49 ; + sh:path skos:mappingRelation ], + [ sh:description "the identifier of an enumeration code set." ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path linkml:code_set ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 37 ; + sh:path skos:note ], + [ sh:description "the identifier of this class or slot must begin with the URIs referenced by this prefix" ; + sh:order 25 ; + sh:path linkml:id_prefixes ], + [ sh:class linkml:Definition ; + sh:description "Used to extend class or slot definitions. For example, if we have a core schema where a gene has two slots for identifier and symbol, and we have a specialized schema for my_organism where we wish to add a slot systematic_name, we can avoid subclassing by defining a class gene_my_organism, adding the slot to this class, and then adding an apply_to pointing to the gene class. The new slot will be 'injected into' the gene class." ; + sh:nodeKind sh:IRI ; + sh:order 16 ; + sh:path linkml:apply_to ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 48 ; + sh:path skosxl:altLabel ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 50 ; + sh:path skos:exactMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 52 ; + sh:path skos:relatedMatch ], + [ sh:description "URI of the enum that provides a semantic interpretation of the element in a linked data context. The URI may come from any namespace and may be shared between schemas" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:enum_uri ], + [ sh:description "agent that modified the element" ; + sh:maxCount 1 ; + sh:order 21 ; + sh:path oslc:modifiedBy ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 31 ; + sh:path skos:definition ], + [ sh:class linkml:Definition ; + sh:description "A primary parent class or slot from which inheritable metaslots are propagated from. While multiple inheritance is not allowed, mixins can be provided effectively providing the same thing. The semantics are the same when translated to formalisms that allow MI (e.g. RDFS/OWL). When translating to a SI framework (e.g. java classes, python classes) then is a is used. When translating a framework without polymorphism (e.g. json-schema, solr document schema) then is a and mixins are recursively unfolded" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 12 ; + sh:path linkml:is_a ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 46 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 41 ; + sh:path linkml:imported_from ], + [ sh:class linkml:Definition ; + sh:description "A collection of secondary parent classes or slots from which inheritable metaslots are propagated from." ; + sh:nodeKind sh:IRI ; + sh:order 15 ; + sh:path linkml:mixins ], + [ sh:class linkml:PermissibleValue ; + sh:description "A list of possible values for a slot range" ; + sh:nodeKind sh:IRI ; + sh:order 5 ; + sh:path linkml:permissible_values ], + [ sh:description "time at which the element was created" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path pav:createdOn ], + [ sh:description "Defines the specific formula to be used to generate the permissible values." ; + sh:in ( "CODE" "CURIE" "URI" "FHIR_CODING" ) ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path linkml:pv_formula ], + [ sh:description "Indicates the class or slot is intended to be inherited from without being an is_a parent. mixins should not be inherited from using is_a, except by other mixins." ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path linkml:mixin ], + [ sh:description "The identifier of a \"value set\" -- a set of identifiers that form the possible values for the range of a slot. Note: this is different than 'subproperty_of' in that 'subproperty_of' is intended to be a single ontology term while 'values_from' is the identifier of an entire value set. Additionally, this is different than an enumeration in that in an enumeration, the values of the enumeration are listed directly in the model itself. Setting this property on a slot does not guarantee an expansion of the ontological hiearchy into an enumerated list of possible values in every serialization of the model." ; + sh:order 17 ; + sh:path linkml:values_from ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 29 ; + sh:path linkml:extensions ], + [ sh:class linkml:MatchQuery ; + sh:description "Specifies a match query that is used to calculate the list of permissible values" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 10 ; + sh:path linkml:matches ], + [ sh:description "agent that created the element" ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path pav:createdBy ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 53 ; + sh:path skos:narrowMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 54 ; + sh:path skos:broadMatch ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 34 ; + sh:path linkml:deprecated ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 42 ; + sh:path ], + [ sh:description "the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class." ; + sh:maxCount 1 ; + sh:order 24 ; + sh:path rdfs:label ], + [ sh:description "the \"native\" URI of the element" ; + sh:maxCount 1 ; + sh:order 26 ; + sh:path linkml:definition_uri ], + [ sh:description """Used on a slot that stores the string serialization of the containing object. The syntax follows python formatted strings, with slot names enclosed in {}s. These are expanded using the values of those slots. +We call the slot with the serialization the s-slot, the slots used in the {}s are v-slots. If both s-slots and v-slots are populated on an object then the value of the s-slot should correspond to the expansion. +Implementations of frameworks may choose to use this property to either (a) PARSE: implement automated normalizations by parsing denormalized strings into complex objects (b) GENERARE: implement automated to_string labeling of complex objects +For example, a Measurement class may have 3 fields: unit, value, and string_value. The string_value slot may have a string_serialization of {value}{unit} such that if unit=cm and value=2, the value of string_value shouldd be 2cm""" ; + sh:maxCount 1 ; + sh:order 23 ; + sh:path linkml:string_serialization ], + [ sh:description "the version identifier of the enumeration code set" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:code_set_version ], + [ sh:description "Alaternate names for the element" ; + sh:order 47 ; + sh:path skos:altLabel ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 36 ; + sh:path skos:editorialNote ], + [ sh:class linkml:ReachabilityQuery ; + sh:description "Specifies a query for obtaining a list of permissible values based on graph reachability" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 9 ; + sh:path linkml:reachable_from ], + [ sh:description "the version tag of the enumeration code set" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path linkml:code_set_tag ], + [ sh:class linkml:AnonymousEnumExpression ; + sh:description "An enum expression that yields a list of permissible values that are to be subtracted from the enum" ; + sh:nodeKind sh:BlankNode ; + sh:order 7 ; + sh:path linkml:minus ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 39 ; + sh:path OIO:inSubset ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 55 ; + sh:path sh1:order ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 32 ; + sh:path linkml:alt_descriptions ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 45 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "Indicates the class or slot cannot be directly instantiated and is intended for grouping and specifying core inherited metaslots" ; + sh:maxCount 1 ; + sh:order 13 ; + sh:path linkml:abstract ], + [ sh:class linkml:AnonymousEnumExpression ; + sh:description "An enum expression that yields a list of permissible values that are to be included, after subtracting the minus set" ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:include ], + [ sh:class linkml:LocalName ; + sh:nodeKind sh:BlankNode ; + sh:order 27 ; + sh:path linkml:local_names ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 40 ; + sh:path skos:inScheme ] ; + sh:targetClass linkml:EnumDefinition . + +linkml:TypeDefinition a sh:NodeShape ; + sh:closed true ; + sh:description "an element that whose instances are atomic scalar values that can be mapped to primitive types" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 40 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 48 ; + sh:path skos:broadMatch ], + [ sh:description "Causes the slot value to be interpreted as a uriorcurie after prefixing with this string" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path linkml:implicit_prefix ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if at least one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 16 ; + sh:path linkml:any_of ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 24 ; + sh:path linkml:annotations ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 35 ; + sh:path linkml:imported_from ], + [ sh:description "Alaternate names for the element" ; + sh:order 41 ; + sh:path skos:altLabel ], + [ sh:description "the \"native\" URI of the element" ; + sh:maxCount 1 ; + sh:order 20 ; + sh:path linkml:definition_uri ], + [ sh:description "the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class." ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path rdfs:label ], + [ sh:description "An established standard to which the element conforms." ; + sh:maxCount 1 ; + sh:order 22 ; + sh:path ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if only one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 15 ; + sh:path linkml:exactly_one_of ], + [ sh:description "the string value of the slot must conform to this regular expression expressed in the string" ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path linkml:pattern ], + [ sh:description "the slot must have range string and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 9 ; + sh:path linkml:equals_string ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 43 ; + sh:path skos:mappingRelation ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if none of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 14 ; + sh:path linkml:none_of ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 46 ; + sh:path skos:relatedMatch ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 26 ; + sh:path linkml:alt_descriptions ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 33 ; + sh:path OIO:inSubset ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 28 ; + sh:path linkml:deprecated ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 25 ; + sh:path skos:definition ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 47 ; + sh:path skos:narrowMatch ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 29 ; + sh:path linkml:todos ], + [ sh:description "python base type that implements this type definition" ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path linkml:base ], + [ sh:description "a reference" ; + sh:order 38 ; + sh:path rdfs:seeAlso ], + [ sh:class linkml:TypeDefinition ; + sh:description "Names a parent type" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 0 ; + sh:path linkml:typeof ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 36 ; + sh:path ], + [ sh:description "the name of the python object that implements this type definition" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:repr ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 31 ; + sh:path skos:note ], + [ sh:class linkml:PatternExpression ; + sh:description "the string value of the slot must conform to the regular expression in the pattern expression" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:structured_pattern ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 44 ; + sh:path skos:exactMatch ], + [ sh:class qudt:Unit ; + sh:description "an encoding of a unit" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 7 ; + sh:path qudt:unit ], + [ sh:description "for slots with ranges of type number, the value must be equal to or lowe than this" ; + sh:maxCount 1 ; + sh:order 13 ; + sh:path linkml:maximum_value ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 39 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if all of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 17 ; + sh:path linkml:all_of ], + [ sh:class linkml:LocalName ; + sh:nodeKind sh:BlankNode ; + sh:order 21 ; + sh:path linkml:local_names ], + [ sh:class linkml:TypeDefinition ; + sh:description "indicates that the domain element consists exactly of the members of the element in the range." ; + sh:nodeKind sh:IRI ; + sh:order 4 ; + sh:path linkml:union_of ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 27 ; + sh:path ], + [ sh:description "the identifier of this class or slot must begin with the URIs referenced by this prefix" ; + sh:order 19 ; + sh:path linkml:id_prefixes ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 45 ; + sh:path skos:closeMatch ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 30 ; + sh:path skos:editorialNote ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 34 ; + sh:path skos:inScheme ], + [ sh:description "for slots with ranges of type number, the value must be equal to or higher than this" ; + sh:maxCount 1 ; + sh:order 12 ; + sh:path linkml:minimum_value ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 49 ; + sh:path sh1:order ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 23 ; + sh:path linkml:extensions ], + [ sh:description "The uri that defines the possible values for the type definition" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path linkml:type_uri ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 42 ; + sh:path skosxl:altLabel ], + [ sh:maxCount 1 ; + sh:order 37 ; + sh:path schema:inLanguage ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 32 ; + sh:path linkml:examples ], + [ sh:description "the slot must have range of a number and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 11 ; + sh:path linkml:equals_number ], + [ sh:description "the slot must have range string and the value of the slot must equal one of the specified values" ; + sh:order 10 ; + sh:path linkml:equals_string_in ] ; + sh:targetClass linkml:TypeDefinition . + +linkml:AnonymousEnumExpression a sh:NodeShape ; + sh:closed true ; + sh:description "An enum_expression that is not named" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "Defines the specific formula to be used to generate the permissible values." ; + sh:in ( "CODE" "CURIE" "URI" "FHIR_CODING" ) ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:pv_formula ], + [ sh:class linkml:MatchQuery ; + sh:description "Specifies a match query that is used to calculate the list of permissible values" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 9 ; + sh:path linkml:matches ], + [ sh:description "the version identifier of the enumeration code set" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path linkml:code_set_version ], + [ sh:class linkml:EnumDefinition ; + sh:description "An enum definition that is used as the basis to create a new enum" ; + sh:nodeKind sh:IRI ; + sh:order 7 ; + sh:path linkml:inherits ], + [ sh:class linkml:AnonymousEnumExpression ; + sh:description "An enum expression that yields a list of permissible values that are to be subtracted from the enum" ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:minus ], + [ sh:class linkml:ReachabilityQuery ; + sh:description "Specifies a query for obtaining a list of permissible values based on graph reachability" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 8 ; + sh:path linkml:reachable_from ], + [ sh:description "A list of identifiers that are used to construct a set of permissible values" ; + sh:order 10 ; + sh:path linkml:concepts ], + [ sh:description "the version tag of the enumeration code set" ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path linkml:code_set_tag ], + [ sh:class linkml:PermissibleValue ; + sh:description "A list of possible values for a slot range" ; + sh:nodeKind sh:IRI ; + sh:order 4 ; + sh:path linkml:permissible_values ], + [ sh:description "the identifier of an enumeration code set." ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:code_set ], + [ sh:class linkml:AnonymousEnumExpression ; + sh:description "An enum expression that yields a list of permissible values that are to be included, after subtracting the minus set" ; + sh:nodeKind sh:BlankNode ; + sh:order 5 ; + sh:path linkml:include ] ; + sh:targetClass linkml:AnonymousEnumExpression . + +linkml:PathExpression a sh:NodeShape ; + sh:closed true ; + sh:description "An expression that describes an abstract path from an object to another through a sequence of slot lookups" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 33 ; + sh:path skos:broadMatch ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 14 ; + sh:path linkml:todos ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 12 ; + sh:path ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 10 ; + sh:path skos:definition ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 28 ; + sh:path skos:mappingRelation ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 18 ; + sh:path OIO:inSubset ], + [ sh:class linkml:PathExpression ; + sh:description "holds if only one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 4 ; + sh:path linkml:exactly_one_of ], + [ sh:class linkml:PathExpression ; + sh:description "holds if all of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:all_of ], + [ sh:description "true if the slot is to be inversed" ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path linkml:reversed ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 31 ; + sh:path skos:relatedMatch ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 11 ; + sh:path linkml:alt_descriptions ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "A range that is described as a boolean expression combining existing ranges" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 7 ; + sh:path linkml:range_expression ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 27 ; + sh:path skosxl:altLabel ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path skos:inScheme ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 29 ; + sh:path skos:exactMatch ], + [ sh:description "a reference" ; + sh:order 23 ; + sh:path rdfs:seeAlso ], + [ sh:class linkml:PathExpression ; + sh:description "holds if none of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 1 ; + sh:path linkml:none_of ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 32 ; + sh:path skos:narrowMatch ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 9 ; + sh:path linkml:annotations ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 15 ; + sh:path skos:editorialNote ], + [ sh:maxCount 1 ; + sh:order 22 ; + sh:path schema:inLanguage ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 34 ; + sh:path sh1:order ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 24 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:class linkml:SlotDefinition ; + sh:description "the slot to traverse" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 6 ; + sh:path linkml:traverse ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 30 ; + sh:path skos:closeMatch ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 25 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "Alaternate names for the element" ; + sh:order 26 ; + sh:path skos:altLabel ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 21 ; + sh:path ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 20 ; + sh:path linkml:imported_from ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 13 ; + sh:path linkml:deprecated ], + [ sh:class linkml:PathExpression ; + sh:description "holds if at least one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path linkml:any_of ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 17 ; + sh:path linkml:examples ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 8 ; + sh:path linkml:extensions ], + [ sh:class linkml:PathExpression ; + sh:description "in a sequential list, this indicates the next member" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 0 ; + sh:path linkml:followed_by ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 16 ; + sh:path skos:note ] ; + sh:targetClass linkml:PathExpression . + +linkml:PatternExpression a sh:NodeShape ; + sh:closed true ; + sh:description "a regular expression pattern used to evaluate conformance of a string" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "a reference" ; + sh:order 18 ; + sh:path rdfs:seeAlso ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 13 ; + sh:path OIO:inSubset ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 22 ; + sh:path skosxl:altLabel ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path skos:inScheme ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 4 ; + sh:path linkml:annotations ], + [ sh:description "Alaternate names for the element" ; + sh:order 21 ; + sh:path skos:altLabel ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 12 ; + sh:path linkml:examples ], + [ sh:description "the string value of the slot must conform to this regular expression expressed in the string. May be interpolated." ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:syntax ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 9 ; + sh:path linkml:todos ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 11 ; + sh:path skos:note ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 10 ; + sh:path skos:editorialNote ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path skos:definition ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:extensions ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 28 ; + sh:path skos:broadMatch ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path linkml:deprecated ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 24 ; + sh:path skos:exactMatch ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 20 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 23 ; + sh:path skos:mappingRelation ], + [ sh:maxCount 1 ; + sh:order 17 ; + sh:path schema:inLanguage ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 29 ; + sh:path sh1:order ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:alt_descriptions ], + [ sh:description "if true then the pattern must match the whole string, as if enclosed in ^...$" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path linkml:partial_match ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 15 ; + sh:path linkml:imported_from ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 25 ; + sh:path skos:closeMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 27 ; + sh:path skos:narrowMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 26 ; + sh:path skos:relatedMatch ], + [ sh:description "if true then the pattern is first string interpolated" ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path linkml:interpolated ] ; + sh:targetClass linkml:PatternExpression . + +qudt:Unit a sh:NodeShape ; + sh:closed true ; + sh:description "A unit of measure, or unit, is a particular quantity value that has been chosen as a scale for measuring other quantities the same kind (more generally of equivalent dimension)." ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "Expression for deriving this unit from other units" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:derivation ], + [ sh:description "name of the unit encoded as a symbol" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path qudt:symbol ], + [ sh:description "Used to link a unit to equivalent concepts in ontologies such as UO, SNOMED, OEM, OBOE, NCIT" ; + sh:order 1 ; + sh:path skos:exactMatch ], + [ sh:maxCount 1 ; + sh:order 5 ; + sh:path qudt:iec61360Code ], + [ sh:description "associates a QUDT unit with its UCUM code (case-sensitive)." ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path qudt:ucumCode ], + [ sh:description "Concept in a vocabulary or ontology that denotes the kind of quanity being measured, e.g. length" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path qudt:hasQuantityKind ] ; + sh:targetClass qudt:Unit . + +linkml:ClassDefinition a sh:NodeShape ; + sh:closed true ; + sh:description "an element whose instances are complex objects that may have slot-value assignments" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:maxCount 1 ; + sh:order 51 ; + sh:path schema:inLanguage ], + [ sh:class linkml:ClassDefinition ; + sh:description "Used to extend class or slot definitions. For example, if we have a core schema where a gene has two slots for identifier and symbol, and we have a specialized schema for my_organism where we wish to add a slot systematic_name, we can avoid subclassing by defining a class gene_my_organism, adding the slot to this class, and then adding an apply_to pointing to the gene class. The new slot will be 'injected into' the gene class." ; + sh:nodeKind sh:IRI ; + sh:order 24 ; + sh:path linkml:apply_to ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 40 ; + sh:path linkml:alt_descriptions ], + [ sh:description "An established standard to which the element conforms." ; + sh:maxCount 1 ; + sh:order 36 ; + sh:path ], + [ sh:description "the identifier of this class or slot must begin with the URIs referenced by this prefix" ; + sh:order 33 ; + sh:path linkml:id_prefixes ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if none of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 17 ; + sh:path linkml:none_of ], + [ sh:description "If true then all direct is_a children are mutually disjoint and share no instances in common" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path linkml:children_are_mutually_disjoint ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 41 ; + sh:path ], + [ sh:description "the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class." ; + sh:maxCount 1 ; + sh:order 32 ; + sh:path rdfs:label ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 39 ; + sh:path skos:definition ], + [ sh:description "time at which the element was created" ; + sh:maxCount 1 ; + sh:order 27 ; + sh:path pav:createdOn ], + [ sh:class linkml:UniqueKey ; + sh:description "A collection of unique keys for this class. Unique keys may be singular or compound." ; + sh:nodeKind sh:BlankNode ; + sh:order 8 ; + sh:path linkml:unique_keys ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 47 ; + sh:path OIO:inSubset ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 42 ; + sh:path linkml:deprecated ], + [ sh:description "if true then induced/mangled slot names are not created for class_usage and attributes" ; + sh:maxCount 1 ; + sh:order 11 ; + sh:path linkml:slot_names_unique ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 60 ; + sh:path skos:relatedMatch ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 54 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 61 ; + sh:path skos:narrowMatch ], + [ sh:class linkml:SlotDefinition ; + sh:description "The combination of is a plus defining slots form a genus-differentia definition, or the set of necessary and sufficient conditions that can be transformed into an OWL equivalence axiom" ; + sh:nodeKind sh:IRI ; + sh:order 6 ; + sh:path linkml:defining_slots ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 50 ; + sh:path ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 38 ; + sh:path linkml:annotations ], + [ sh:description "a reference" ; + sh:order 52 ; + sh:path rdfs:seeAlso ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 58 ; + sh:path skos:exactMatch ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 45 ; + sh:path skos:note ], + [ sh:description "Indicates the class or slot cannot be directly instantiated and is intended for grouping and specifying core inherited metaslots" ; + sh:maxCount 1 ; + sh:order 21 ; + sh:path linkml:abstract ], + [ sh:description "true if this class represents a relationship rather than an entity" ; + sh:maxCount 1 ; + sh:order 12 ; + sh:path linkml:represents_relationship ], + [ sh:description "rdfs:subClassOf to be emitted in OWL generation" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path rdfs:subClassOf ], + [ sh:description "URI of the class that provides a semantic interpretation of the element in a linked data context. The URI may come from any namespace and may be shared between schemas" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:class_uri ], + [ sh:description "The identifier of a \"value set\" -- a set of identifiers that form the possible values for the range of a slot. Note: this is different than 'subproperty_of' in that 'subproperty_of' is intended to be a single ontology term while 'values_from' is the identifier of an entire value set. Additionally, this is different than an enumeration in that in an enumeration, the values of the enumeration are listed directly in the model itself. Setting this property on a slot does not guarantee an expansion of the ontological hiearchy into an enumerated list of possible values in every serialization of the model." ; + sh:order 25 ; + sh:path linkml:values_from ], + [ sh:class linkml:ClassDefinition ; + sh:description "A primary parent class from which inheritable metaslots are propagated" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 20 ; + sh:path linkml:is_a ], + [ sh:description "indicator that this is the root class in tree structures" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path linkml:tree_root ], + [ sh:class linkml:LocalName ; + sh:nodeKind sh:BlankNode ; + sh:order 35 ; + sh:path linkml:local_names ], + [ sh:class linkml:ClassDefinition ; + sh:description "Two classes are disjoint if they have no instances in common, two slots are disjoint if they can never hold between the same two instances" ; + sh:nodeKind sh:IRI ; + sh:order 13 ; + sh:path linkml:disjoint_with ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 62 ; + sh:path skos:broadMatch ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if all of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 18 ; + sh:path linkml:all_of ], + [ sh:class linkml:SlotDefinition ; + sh:description "expresses constraints on a group of slots for a class expression" ; + sh:nodeKind sh:IRI ; + sh:order 19 ; + sh:path linkml:slot_conditions ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 57 ; + sh:path skos:mappingRelation ], + [ sh:class linkml:ClassDefinition ; + sh:description "A collection of secondary parent mixin classes from which inheritable metaslots are propagated" ; + sh:nodeKind sh:IRI ; + sh:order 23 ; + sh:path linkml:mixins ], + [ sh:description "agent that modified the element" ; + sh:maxCount 1 ; + sh:order 29 ; + sh:path oslc:modifiedBy ], + [ sh:class linkml:ClassDefinition ; + sh:description "indicates that the domain element consists exactly of the members of the element in the range." ; + sh:nodeKind sh:IRI ; + sh:order 5 ; + sh:path linkml:union_of ], + [ sh:description "time at which the element was last updated" ; + sh:maxCount 1 ; + sh:order 28 ; + sh:path pav:lastUpdatedOn ], + [ sh:description "Alaternate names for the element" ; + sh:order 55 ; + sh:path skos:altLabel ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 59 ; + sh:path skos:closeMatch ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "the collection of classification rules that apply to all members of this class" ; + sh:nodeKind sh:BlankNode ; + sh:order 10 ; + sh:path linkml:classification_rules ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 37 ; + sh:path linkml:extensions ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 48 ; + sh:path skos:inScheme ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 46 ; + sh:path linkml:examples ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 43 ; + sh:path linkml:todos ], + [ sh:description "agent that created the element" ; + sh:maxCount 1 ; + sh:order 26 ; + sh:path pav:createdBy ], + [ sh:description "Indicates the class or slot is intended to be inherited from without being an is_a parent. mixins should not be inherited from using is_a, except by other mixins." ; + sh:maxCount 1 ; + sh:order 22 ; + sh:path linkml:mixin ], + [ sh:class linkml:ClassRule ; + sh:description "the collection of rules that apply to all members of this class" ; + sh:nodeKind sh:BlankNode ; + sh:order 9 ; + sh:path sh1:rule ], + [ sh:description "the \"native\" URI of the element" ; + sh:maxCount 1 ; + sh:order 34 ; + sh:path linkml:definition_uri ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 56 ; + sh:path skosxl:altLabel ], + [ sh:description """Used on a slot that stores the string serialization of the containing object. The syntax follows python formatted strings, with slot names enclosed in {}s. These are expanded using the values of those slots. +We call the slot with the serialization the s-slot, the slots used in the {}s are v-slots. If both s-slots and v-slots are populated on an object then the value of the s-slot should correspond to the expansion. +Implementations of frameworks may choose to use this property to either (a) PARSE: implement automated normalizations by parsing denormalized strings into complex objects (b) GENERARE: implement automated to_string labeling of complex objects +For example, a Measurement class may have 3 fields: unit, value, and string_value. The string_value slot may have a string_serialization of {value}{unit} such that if unit=cm and value=2, the value of string_value shouldd be 2cm""" ; + sh:maxCount 1 ; + sh:order 31 ; + sh:path linkml:string_serialization ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 44 ; + sh:path skos:editorialNote ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if at least one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 15 ; + sh:path linkml:any_of ], + [ sh:description "status of the element" ; + sh:maxCount 1 ; + sh:order 30 ; + sh:path bibo:status ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if only one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 16 ; + sh:path linkml:exactly_one_of ], + [ sh:class linkml:SlotDefinition ; + sh:description "the refinement of a slot in the context of the containing class definition." ; + sh:nodeKind sh:IRI ; + sh:order 1 ; + sh:path linkml:slot_usage ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 49 ; + sh:path linkml:imported_from ], + [ sh:class linkml:SlotDefinition ; + sh:description "Inline definition of slots" ; + sh:nodeKind sh:IRI ; + sh:order 2 ; + sh:path linkml:attributes ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 63 ; + sh:path sh1:order ], + [ sh:class linkml:SlotDefinition ; + sh:description "collection of slot names that are applicable to a class" ; + sh:nodeKind sh:IRI ; + sh:order 0 ; + sh:path linkml:slots ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 53 ; + sh:path linkml:deprecated_element_has_exact_replacement ] ; + sh:targetClass linkml:ClassDefinition . + +linkml:Definition a sh:NodeShape ; + sh:closed true ; + sh:description "abstract base class for core metaclasses" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "a reference" ; + sh:order 32 ; + sh:path rdfs:seeAlso ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 30 ; + sh:path ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 17 ; + sh:path linkml:extensions ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 20 ; + sh:path linkml:alt_descriptions ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 33 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "An established standard to which the element conforms." ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path ], + [ sh:description "status of the element" ; + sh:maxCount 1 ; + sh:order 10 ; + sh:path bibo:status ], + [ sh:description "the identifier of this class or slot must begin with the URIs referenced by this prefix" ; + sh:order 13 ; + sh:path linkml:id_prefixes ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 36 ; + sh:path skosxl:altLabel ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 42 ; + sh:path skos:broadMatch ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 43 ; + sh:path sh1:order ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 41 ; + sh:path skos:narrowMatch ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 29 ; + sh:path linkml:imported_from ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 26 ; + sh:path linkml:examples ], + [ sh:description "the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class." ; + sh:maxCount 1 ; + sh:order 12 ; + sh:path rdfs:label ], + [ sh:description "agent that created the element" ; + sh:maxCount 1 ; + sh:order 6 ; + sh:path pav:createdBy ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 34 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 38 ; + sh:path skos:exactMatch ], + [ sh:description "agent that modified the element" ; + sh:maxCount 1 ; + sh:order 9 ; + sh:path oslc:modifiedBy ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 21 ; + sh:path ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 39 ; + sh:path skos:closeMatch ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 24 ; + sh:path skos:editorialNote ], + [ sh:description "Indicates the class or slot cannot be directly instantiated and is intended for grouping and specifying core inherited metaslots" ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path linkml:abstract ], + [ sh:class linkml:Definition ; + sh:description "A primary parent class or slot from which inheritable metaslots are propagated from. While multiple inheritance is not allowed, mixins can be provided effectively providing the same thing. The semantics are the same when translated to formalisms that allow MI (e.g. RDFS/OWL). When translating to a SI framework (e.g. java classes, python classes) then is a is used. When translating a framework without polymorphism (e.g. json-schema, solr document schema) then is a and mixins are recursively unfolded" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 0 ; + sh:path linkml:is_a ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 18 ; + sh:path linkml:annotations ], + [ sh:description "Alaternate names for the element" ; + sh:order 35 ; + sh:path skos:altLabel ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 27 ; + sh:path OIO:inSubset ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 28 ; + sh:path skos:inScheme ], + [ sh:description "time at which the element was last updated" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path pav:lastUpdatedOn ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 25 ; + sh:path skos:note ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 37 ; + sh:path skos:mappingRelation ], + [ sh:class linkml:Definition ; + sh:description "A collection of secondary parent classes or slots from which inheritable metaslots are propagated from." ; + sh:nodeKind sh:IRI ; + sh:order 3 ; + sh:path linkml:mixins ], + [ sh:maxCount 1 ; + sh:order 31 ; + sh:path schema:inLanguage ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path skos:definition ], + [ sh:class linkml:Definition ; + sh:description "Used to extend class or slot definitions. For example, if we have a core schema where a gene has two slots for identifier and symbol, and we have a specialized schema for my_organism where we wish to add a slot systematic_name, we can avoid subclassing by defining a class gene_my_organism, adding the slot to this class, and then adding an apply_to pointing to the gene class. The new slot will be 'injected into' the gene class." ; + sh:nodeKind sh:IRI ; + sh:order 4 ; + sh:path linkml:apply_to ], + [ sh:description "Indicates the class or slot is intended to be inherited from without being an is_a parent. mixins should not be inherited from using is_a, except by other mixins." ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path linkml:mixin ], + [ sh:description "the \"native\" URI of the element" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path linkml:definition_uri ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 23 ; + sh:path linkml:todos ], + [ sh:description "time at which the element was created" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path pav:createdOn ], + [ sh:description "The identifier of a \"value set\" -- a set of identifiers that form the possible values for the range of a slot. Note: this is different than 'subproperty_of' in that 'subproperty_of' is intended to be a single ontology term while 'values_from' is the identifier of an entire value set. Additionally, this is different than an enumeration in that in an enumeration, the values of the enumeration are listed directly in the model itself. Setting this property on a slot does not guarantee an expansion of the ontological hiearchy into an enumerated list of possible values in every serialization of the model." ; + sh:order 5 ; + sh:path linkml:values_from ], + [ sh:class linkml:LocalName ; + sh:nodeKind sh:BlankNode ; + sh:order 15 ; + sh:path linkml:local_names ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 40 ; + sh:path skos:relatedMatch ], + [ sh:description """Used on a slot that stores the string serialization of the containing object. The syntax follows python formatted strings, with slot names enclosed in {}s. These are expanded using the values of those slots. +We call the slot with the serialization the s-slot, the slots used in the {}s are v-slots. If both s-slots and v-slots are populated on an object then the value of the s-slot should correspond to the expansion. +Implementations of frameworks may choose to use this property to either (a) PARSE: implement automated normalizations by parsing denormalized strings into complex objects (b) GENERARE: implement automated to_string labeling of complex objects +For example, a Measurement class may have 3 fields: unit, value, and string_value. The string_value slot may have a string_serialization of {value}{unit} such that if unit=cm and value=2, the value of string_value shouldd be 2cm""" ; + sh:maxCount 1 ; + sh:order 11 ; + sh:path linkml:string_serialization ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 22 ; + sh:path linkml:deprecated ] ; + sh:targetClass linkml:Definition . + +linkml:LocalName a sh:NodeShape ; + sh:closed true ; + sh:description "an attributed label" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "a name assigned to an element in a given ontology" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 1 ; + sh:path skos:altLabel ], + [ sh:description "the ncname of the source of the name" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:local_name_source ] ; + sh:targetClass linkml:LocalName . + +linkml:AnonymousTypeExpression a sh:NodeShape ; + sh:closed true ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if none of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 9 ; + sh:path linkml:none_of ], + [ sh:class qudt:Unit ; + sh:description "an encoding of a unit" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path qudt:unit ], + [ sh:description "the string value of the slot must conform to this regular expression expressed in the string" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:pattern ], + [ sh:description "the slot must have range string and the value of the slot must equal one of the specified values" ; + sh:order 5 ; + sh:path linkml:equals_string_in ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if only one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 10 ; + sh:path linkml:exactly_one_of ], + [ sh:description "for slots with ranges of type number, the value must be equal to or lowe than this" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path linkml:maximum_value ], + [ sh:class linkml:PatternExpression ; + sh:description "the string value of the slot must conform to the regular expression in the pattern expression" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 1 ; + sh:path linkml:structured_pattern ], + [ sh:description "the slot must have range of a number and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 6 ; + sh:path linkml:equals_number ], + [ sh:description "Causes the slot value to be interpreted as a uriorcurie after prefixing with this string" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:implicit_prefix ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if at least one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 11 ; + sh:path linkml:any_of ], + [ sh:description "for slots with ranges of type number, the value must be equal to or higher than this" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path linkml:minimum_value ], + [ sh:description "the slot must have range string and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path linkml:equals_string ], + [ sh:class linkml:AnonymousTypeExpression ; + sh:description "holds if all of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 12 ; + sh:path linkml:all_of ] ; + sh:targetClass linkml:AnonymousTypeExpression . + +linkml:AnonymousSlotExpression a sh:NodeShape ; + sh:closed true ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "true means that the slot should be present in the loaded definition, but this is not required" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path linkml:recommended ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 27 ; + sh:path linkml:annotations ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 49 ; + sh:path skos:relatedMatch ], + [ sh:maxCount 1 ; + sh:order 40 ; + sh:path schema:inLanguage ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 36 ; + sh:path OIO:inSubset ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 35 ; + sh:path linkml:examples ], + [ sh:description "the slot must have range string and the value of the slot must equal one of the specified values" ; + sh:order 15 ; + sh:path linkml:equals_string_in ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if all of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 25 ; + sh:path linkml:all_of ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 32 ; + sh:path linkml:todos ], + [ sh:description "the string value of the slot must conform to this regular expression expressed in the string" ; + sh:maxCount 1 ; + sh:order 9 ; + sh:path linkml:pattern ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "A range that is described as a boolean expression combining existing ranges" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 1 ; + sh:path linkml:range_expression ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 28 ; + sh:path skos:definition ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 43 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:class qudt:Unit ; + sh:description "an encoding of a unit" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 11 ; + sh:path qudt:unit ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 31 ; + sh:path linkml:deprecated ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if at least one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 24 ; + sh:path linkml:any_of ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "the value of the slot is multivalued with all members satisfying the condition" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 21 ; + sh:path linkml:all_members ], + [ sh:description "the slot must have range string and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path linkml:equals_string ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 37 ; + sh:path skos:inScheme ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 29 ; + sh:path linkml:alt_descriptions ], + [ sh:description "Alaternate names for the element" ; + sh:order 44 ; + sh:path skos:altLabel ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 45 ; + sh:path skosxl:altLabel ], + [ sh:class linkml:EnumExpression ; + sh:description "An inlined enumeration" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path linkml:enum_range ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 46 ; + sh:path skos:mappingRelation ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "the value of the slot is multivalued with at least one member satisfying the condition" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 20 ; + sh:path linkml:has_member ], + [ sh:description "if true then a value must be present (for lists there must be at least one value). If false then a value must be absent (for lists, must be empty)" ; + sh:in ( "UNCOMMITTED" "PRESENT" "ABSENT" ) ; + sh:maxCount 1 ; + sh:order 13 ; + sh:path linkml:value_presence ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 26 ; + sh:path linkml:extensions ], + [ sh:class linkml:PatternExpression ; + sh:description "the string value of the slot must conform to the regular expression in the pattern expression" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 10 ; + sh:path linkml:structured_pattern ], + [ sh:description "True means that keyed or identified slot appears in an outer structure by value. False means that only the key or identifier for the slot appears within the domain, referencing a structure that appears elsewhere." ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path linkml:inlined ], + [ sh:description "the value of the slot must equal the value of the evaluated expression" ; + sh:maxCount 1 ; + sh:order 17 ; + sh:path linkml:equals_expression ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 33 ; + sh:path skos:editorialNote ], + [ sh:description "for slots with ranges of type number, the value must be equal to or higher than this" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path linkml:minimum_value ], + [ sh:description "the maximum number of entries for a multivalued slot" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path linkml:maximum_cardinality ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 52 ; + sh:path sh1:order ], + [ sh:class linkml:Element ; + sh:description """defines the type of the object of the slot. Given the following slot definition + S1: + domain: C1 + range: C2 +the declaration + X: + S1: Y + +implicitly asserts Y is an instance of C2 +""" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 0 ; + sh:path linkml:range ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if none of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 22 ; + sh:path linkml:none_of ], + [ sh:description "for slots with ranges of type number, the value must be equal to or lowe than this" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path linkml:maximum_value ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 30 ; + sh:path ], + [ sh:description "Causes the slot value to be interpreted as a uriorcurie after prefixing with this string" ; + sh:maxCount 1 ; + sh:order 12 ; + sh:path linkml:implicit_prefix ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 47 ; + sh:path skos:exactMatch ], + [ sh:description "the minimum number of entries for a multivalued slot" ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path linkml:minimum_cardinality ], + [ sh:description "a reference" ; + sh:order 41 ; + sh:path rdfs:seeAlso ], + [ sh:description "the slot must have range of a number and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path linkml:equals_number ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 50 ; + sh:path skos:narrowMatch ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 48 ; + sh:path skos:closeMatch ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 38 ; + sh:path linkml:imported_from ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if only one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 23 ; + sh:path linkml:exactly_one_of ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 34 ; + sh:path skos:note ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 42 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 51 ; + sh:path skos:broadMatch ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 39 ; + sh:path ], + [ sh:description "True means that an inlined slot is represented as a list of range instances. False means that an inlined slot is represented as a dictionary, whose key is the slot key or identifier and whose value is the range instance." ; + sh:maxCount 1 ; + sh:order 6 ; + sh:path linkml:inlined_as_list ], + [ sh:description "true means that the slot must be present in the loaded definition" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:required ] ; + sh:targetClass linkml:AnonymousSlotExpression . + +skosxl:Label a sh:NodeShape ; + sh:closed true ; + sh:description "object that contains meta data about a synonym or alias including where it came from (source) and its scope (narrow, broad, etc.)" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "The relationship between an element and its alias " ; + sh:in ( skos:exactMatch skos:relatedMatch skos:broaderMatch skos:narrowerMatch ) ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path rdf:predicate ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 25 ; + sh:path skos:closeMatch ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path skos:definition ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 15 ; + sh:path linkml:imported_from ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 13 ; + sh:path OIO:inSubset ], + [ sh:maxCount 1 ; + sh:order 17 ; + sh:path schema:inLanguage ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 20 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "The category or categories of an alias. This can be drawn from any relevant vocabulary" ; + sh:order 2 ; + sh:path ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 12 ; + sh:path linkml:examples ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 24 ; + sh:path skos:exactMatch ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 29 ; + sh:path sh1:order ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 11 ; + sh:path skos:note ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 23 ; + sh:path skos:mappingRelation ], + [ sh:description "Alaternate names for the element" ; + sh:order 21 ; + sh:path skos:altLabel ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 28 ; + sh:path skos:broadMatch ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:alt_descriptions ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 14 ; + sh:path skos:inScheme ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 22 ; + sh:path skosxl:altLabel ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 26 ; + sh:path skos:relatedMatch ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:extensions ], + [ sh:description "The literal lexical form of a structured alias" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 0 ; + sh:path skosxl:literalForm ], + [ sh:description "a reference" ; + sh:order 18 ; + sh:path rdfs:seeAlso ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 10 ; + sh:path skos:editorialNote ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path linkml:deprecated ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 27 ; + sh:path skos:narrowMatch ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 4 ; + sh:path linkml:annotations ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 9 ; + sh:path linkml:todos ] ; + sh:targetClass skosxl:Label . + +linkml:AltDescription a sh:NodeShape ; + sh:closed true ; + sh:description "an attributed description" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "the source of an attributed description" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path linkml:alt_description_source ], + [ sh:description "text of an attributed description" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 1 ; + sh:path linkml:alt_description_text ] ; + sh:targetClass linkml:AltDescription . + +linkml:Example a sh:NodeShape ; + sh:closed true ; + sh:description "usage example and description" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "description of what the value is doing" ; + sh:maxCount 1 ; + sh:order 1 ; + sh:path linkml:value_description ], + [ sh:description "example value" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path skos:example ] ; + sh:targetClass linkml:Example . + +linkml:Annotation a sh:NodeShape ; + sh:closed true ; + sh:description "a tag/value pair with the semantics of OWL Annotation" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "the actual annotation" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 2 ; + sh:path linkml:extension_value ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:extensions ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 0 ; + sh:path linkml:annotations ], + [ sh:description "a tag associated with an extension" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 1 ; + sh:path linkml:extension_tag ] ; + sh:targetClass linkml:Annotation . + +linkml:AnonymousClassExpression a sh:NodeShape ; + sh:closed true ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "a reference" ; + sh:order 21 ; + sh:path rdfs:seeAlso ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if none of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:none_of ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 11 ; + sh:path linkml:deprecated ], + [ sh:maxCount 1 ; + sh:order 20 ; + sh:path schema:inLanguage ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 23 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:class linkml:SlotDefinition ; + sh:description "expresses constraints on a group of slots for a class expression" ; + sh:nodeKind sh:IRI ; + sh:order 5 ; + sh:path linkml:slot_conditions ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 29 ; + sh:path skos:relatedMatch ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if only one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path linkml:exactly_one_of ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 25 ; + sh:path skosxl:altLabel ], + [ sh:class linkml:Definition ; + sh:description "A primary parent class or slot from which inheritable metaslots are propagated from. While multiple inheritance is not allowed, mixins can be provided effectively providing the same thing. The semantics are the same when translated to formalisms that allow MI (e.g. RDFS/OWL). When translating to a SI framework (e.g. java classes, python classes) then is a is used. When translating a framework without polymorphism (e.g. json-schema, solr document schema) then is a and mixins are recursively unfolded" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 0 ; + sh:path linkml:is_a ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 10 ; + sh:path ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 31 ; + sh:path skos:broadMatch ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 12 ; + sh:path linkml:todos ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 15 ; + sh:path linkml:examples ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 14 ; + sh:path skos:note ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 16 ; + sh:path OIO:inSubset ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 28 ; + sh:path skos:closeMatch ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 26 ; + sh:path skos:mappingRelation ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path linkml:imported_from ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if all of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 4 ; + sh:path linkml:all_of ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 13 ; + sh:path skos:editorialNote ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 32 ; + sh:path sh1:order ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 30 ; + sh:path skos:narrowMatch ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "holds if at least one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 1 ; + sh:path linkml:any_of ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:extensions ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path skos:definition ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 7 ; + sh:path linkml:annotations ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 22 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 27 ; + sh:path skos:exactMatch ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 17 ; + sh:path skos:inScheme ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 9 ; + sh:path linkml:alt_descriptions ], + [ sh:description "Alaternate names for the element" ; + sh:order 24 ; + sh:path skos:altLabel ] ; + sh:targetClass linkml:AnonymousClassExpression . + +linkml:SlotDefinition a sh:NodeShape ; + sh:closed true ; + sh:description "an element that describes how instances are related to other instances" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 100 ; + sh:path skos:mappingRelation ], + [ sh:description """function that provides a default value for the slot. Possible values for this slot are defined in +linkml_runtime.utils.ifabsent_functions.default_library: + * [Tt]rue -- boolean True + * [Ff]alse -- boolean False + * int(value) -- integer value + * str(value) -- string value + * default_range -- schema default range + * bnode -- blank node identifier + * slot_uri -- URI for the slot + * class_curie -- CURIE for the containing class + * class_uri -- URI for the containing class""" ; + sh:maxCount 1 ; + sh:order 6 ; + sh:path linkml:ifabsent ], + [ sh:class linkml:SlotDefinition ; + sh:description "transitive_form_of including the reflexive case" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 26 ; + sh:path linkml:reflexive_transitive_form_of ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 80 ; + sh:path linkml:extensions ], + [ sh:class linkml:SlotDefinition ; + sh:description "A primary parent slot from which inheritable metaslots are propagated" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 63 ; + sh:path linkml:is_a ], + [ sh:class linkml:Definition ; + sh:description "the \"owner\" of the slot. It is the class if it appears in the slots list, otherwise the declaring slot" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 14 ; + sh:path linkml:owner ], + [ sh:class linkml:SlotDefinition ; + sh:description "Used to extend class or slot definitions. For example, if we have a core schema where a gene has two slots for identifier and symbol, and we have a specialized schema for my_organism where we wish to add a slot systematic_name, we can avoid subclassing by defining a class gene_my_organism, adding the slot to this class, and then adding an apply_to pointing to the gene class. The new slot will be 'injected into' the gene class." ; + sh:nodeKind sh:IRI ; + sh:order 67 ; + sh:path linkml:apply_to ], + [ sh:description "a reference" ; + sh:order 95 ; + sh:path rdfs:seeAlso ], + [ sh:class qudt:Unit ; + sh:description "an encoding of a unit" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 48 ; + sh:path qudt:unit ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 90 ; + sh:path OIO:inSubset ], + [ sh:description "the \"native\" URI of the element" ; + sh:maxCount 1 ; + sh:order 77 ; + sh:path linkml:definition_uri ], + [ sh:description "the identifier of this class or slot must begin with the URIs referenced by this prefix" ; + sh:order 76 ; + sh:path linkml:id_prefixes ], + [ sh:description "the value of the slot must equal the value of the evaluated expression" ; + sh:maxCount 1 ; + sh:order 54 ; + sh:path linkml:equals_expression ], + [ sh:description "True means that the key slot(s) uniquely identify the container. There can be at most one identifier or key per container" ; + sh:maxCount 1 ; + sh:order 11 ; + sh:path linkml:identifier ], + [ sh:description "true means that the slot should be present in the loaded definition, but this is not required" ; + sh:maxCount 1 ; + sh:order 41 ; + sh:path linkml:recommended ], + [ sh:class linkml:SlotDefinition ; + sh:description "allows for grouping of related slots into a grouping slot that serves the role of a group" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 31 ; + sh:path sh1:group ], + [ sh:class linkml:LocalName ; + sh:nodeKind sh:BlankNode ; + sh:order 78 ; + sh:path linkml:local_names ], + [ sh:description "if true then a value must be present (for lists there must be at least one value). If false then a value must be absent (for lists, must be empty)" ; + sh:in ( "UNCOMMITTED" "PRESENT" "ABSENT" ) ; + sh:maxCount 1 ; + sh:order 50 ; + sh:path linkml:value_presence ], + [ sh:class linkml:ClassDefinition ; + sh:description "the class(es) that reference the slot in a \"slots\" or \"slot_usage\" context" ; + sh:nodeKind sh:IRI ; + sh:order 15 ; + sh:path linkml:domain_of ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 99 ; + sh:path skosxl:altLabel ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 83 ; + sh:path linkml:alt_descriptions ], + [ sh:description "status of the element" ; + sh:maxCount 1 ; + sh:order 73 ; + sh:path bibo:status ], + [ sh:description "If true then all direct is_a children are mutually disjoint and share no instances in common" ; + sh:maxCount 1 ; + sh:order 35 ; + sh:path linkml:children_are_mutually_disjoint ], + [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 84 ; + sh:path ], + [ sh:description "Alaternate names for the element" ; + sh:order 98 ; + sh:path skos:altLabel ], + [ sh:description """Used on a slot that stores the string serialization of the containing object. The syntax follows python formatted strings, with slot names enclosed in {}s. These are expanded using the values of those slots. +We call the slot with the serialization the s-slot, the slots used in the {}s are v-slots. If both s-slots and v-slots are populated on an object then the value of the s-slot should correspond to the expansion. +Implementations of frameworks may choose to use this property to either (a) PARSE: implement automated normalizations by parsing denormalized strings into complex objects (b) GENERARE: implement automated to_string labeling of complex objects +For example, a Measurement class may have 3 fields: unit, value, and string_value. The string_value slot may have a string_serialization of {value}{unit} such that if unit=cm and value=2, the value of string_value shouldd be 2cm""" ; + sh:maxCount 1 ; + sh:order 74 ; + sh:path linkml:string_serialization ], + [ sh:description "Indicates the class or slot is intended to be inherited from without being an is_a parent. mixins should not be inherited from using is_a, except by other mixins." ; + sh:maxCount 1 ; + sh:order 65 ; + sh:path linkml:mixin ], + [ sh:description "for slots with ranges of type number, the value must be equal to or lowe than this" ; + sh:maxCount 1 ; + sh:order 45 ; + sh:path linkml:maximum_value ], + [ sh:description "true means that the *value* of a slot is inherited by subclasses" ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path linkml:inherited ], + [ sh:description "indicates that for any instance, i, the domain of this slot will include an assertion of i s range" ; + sh:maxCount 1 ; + sh:order 24 ; + sh:path linkml:is_class_field ], + [ sh:description "True means that keyed or identified slot appears in an outer structure by value. False means that only the key or identifier for the slot appears within the domain, referencing a structure that appears elsewhere." ; + sh:maxCount 1 ; + sh:order 42 ; + sh:path linkml:inlined ], + [ sh:description "for slots with ranges of type number, the value must be equal to or higher than this" ; + sh:maxCount 1 ; + sh:order 44 ; + sh:path linkml:minimum_value ], + [ sh:class linkml:AnonymousClassExpression ; + sh:description "A range that is described as a boolean expression combining existing ranges" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 38 ; + sh:path linkml:range_expression ], + [ sh:class linkml:EnumExpression ; + sh:description "An inlined enumeration" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 39 ; + sh:path linkml:enum_range ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if only one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 60 ; + sh:path linkml:exactly_one_of ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 103 ; + sh:path skos:relatedMatch ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "the value of the slot is multivalued with at least one member satisfying the condition" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 57 ; + sh:path linkml:has_member ], + [ sh:description "a textual descriptor that indicates the role played by the slot range" ; + sh:maxCount 1 ; + sh:order 27 ; + sh:path linkml:role ], + [ sh:description "Indicates the class or slot cannot be directly instantiated and is intended for grouping and specifying core inherited metaslots" ; + sh:maxCount 1 ; + sh:order 64 ; + sh:path linkml:abstract ], + [ sh:description "Causes the slot value to be interpreted as a uriorcurie after prefixing with this string" ; + sh:maxCount 1 ; + sh:order 49 ; + sh:path linkml:implicit_prefix ], + [ sh:class linkml:PatternExpression ; + sh:description "the string value of the slot must conform to the regular expression in the pattern expression" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 47 ; + sh:path linkml:structured_pattern ], + [ sh:description "If s is irreflexive, then there exists no i such i.s=i" ; + sh:maxCount 1 ; + sh:order 20 ; + sh:path linkml:irreflexive ], + [ sh:description "the name used for a slot in the context of its owning class. If present, this is used instead of the actual slot name." ; + sh:maxCount 1 ; + sh:order 13 ; + sh:path skos:prefLabel ], + [ sh:description "the slot must have range string and the value of the slot must equal one of the specified values" ; + sh:order 52 ; + sh:path linkml:equals_string_in ], + [ sh:description "time at which the element was last updated" ; + sh:maxCount 1 ; + sh:order 71 ; + sh:path pav:lastUpdatedOn ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 87 ; + sh:path skos:editorialNote ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "the value of the slot is multivalued with all members satisfying the condition" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 58 ; + sh:path linkml:all_members ], + [ sh:description "the slot must have range string and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 51 ; + sh:path linkml:equals_string ], + [ sh:class linkml:PathExpression ; + sh:description "a rule for inferring a slot assignment based on evaluating a path through a sequence of slot assignemnts" ; + sh:maxCount 1 ; + sh:nodeKind sh:BlankNode ; + sh:order 33 ; + sh:path linkml:path_rule ], + [ sh:description "If s is locally_reflexive, then i.s=i for all instances i where s is a class slot for the type of i" ; + sh:maxCount 1 ; + sh:order 19 ; + sh:path linkml:locally_reflexive ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 97 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:description "The identifier of a \"value set\" -- a set of identifiers that form the possible values for the range of a slot. Note: this is different than 'subproperty_of' in that 'subproperty_of' is intended to be a single ontology term while 'values_from' is the identifier of an entire value set. Additionally, this is different than an enumeration in that in an enumeration, the values of the enumeration are listed directly in the model itself. Setting this property on a slot does not guarantee an expansion of the ontological hiearchy into an enumerated list of possible values in every serialization of the model." ; + sh:order 68 ; + sh:path linkml:values_from ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 93 ; + sh:path ], + [ sh:description "the minimum number of entries for a multivalued slot" ; + sh:maxCount 1 ; + sh:order 55 ; + sh:path linkml:minimum_cardinality ], + [ sh:description "the maximum number of entries for a multivalued slot" ; + sh:maxCount 1 ; + sh:order 56 ; + sh:path linkml:maximum_cardinality ], + [ sh:class linkml:SlotDefinition ; + sh:description "If s transitive_form_of d, then (1) s holds whenever d holds (2) s is transitive (3) d holds whenever s holds and there are no intermediates, and s is not reflexive" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 25 ; + sh:path linkml:transitive_form_of ], + [ sh:description "An established standard to which the element conforms." ; + sh:maxCount 1 ; + sh:order 79 ; + sh:path ], + [ sh:class linkml:Element ; + sh:description """defines the type of the object of the slot. Given the following slot definition + S1: + domain: C1 + range: C2 +the declaration + X: + S1: Y + +implicitly asserts Y is an instance of C2 +""" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 37 ; + sh:path linkml:range ], + [ sh:class linkml:SlotDefinition ; + sh:description "A collection of secondary parent mixin slots from which inheritable metaslots are propagated" ; + sh:nodeKind sh:IRI ; + sh:order 66 ; + sh:path linkml:mixins ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 92 ; + sh:path linkml:imported_from ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 102 ; + sh:path skos:closeMatch ], + [ sh:description "the slot must have range of a number and the value of the slot must equal the specified value" ; + sh:maxCount 1 ; + sh:order 53 ; + sh:path linkml:equals_number ], + [ sh:description "True means that the key slot(s) is used to determine the instantiation (types) relation between objects and a ClassDefinition" ; + sh:maxCount 1 ; + sh:order 12 ; + sh:path linkml:designates_type ], + [ sh:class linkml:SlotDefinition ; + sh:description "Two classes are disjoint if they have no instances in common, two slots are disjoint if they can never hold between the same two instances" ; + sh:nodeKind sh:IRI ; + sh:order 34 ; + sh:path linkml:disjoint_with ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 105 ; + sh:path skos:broadMatch ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 81 ; + sh:path linkml:annotations ], + [ sh:description "predicate of this slot for semantic web application" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path linkml:slot_uri ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 101 ; + sh:path skos:exactMatch ], + [ sh:description "True means that an inlined slot is represented as a list of range instances. False means that an inlined slot is represented as a dictionary, whose key is the slot key or identifier and whose value is the range instance." ; + sh:maxCount 1 ; + sh:order 43 ; + sh:path linkml:inlined_as_list ], + [ sh:description "true if this slot is a grouping slot" ; + sh:maxCount 1 ; + sh:order 32 ; + sh:path linkml:is_grouping_slot ], + [ sh:description "If s is reflexive, then i.s=i for all instances i" ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path linkml:reflexive ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if all of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 62 ; + sh:path linkml:all_of ], + [ sh:description "If s is symmetric, and i.s=v, then v.s=i" ; + sh:maxCount 1 ; + sh:order 17 ; + sh:path linkml:symmetric ], + [ sh:description "a name that is used in the singular form" ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path skos:altLabel ], + [ sh:description "The name of the slot referenced in the slot_usage" ; + sh:maxCount 1 ; + sh:order 29 ; + sh:path linkml:usage_slot_name ], + [ sh:class linkml:ClassDefinition ; + sh:description """defines the type of the subject of the slot. Given the following slot definition + S1: + domain: C1 + range: C2 +the declaration + X: + S1: Y + +implicitly asserts that X is an instance of C1 +""" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 1 ; + sh:path linkml:domain ], + [ sh:description "If s is transitive, and i.s=z, and s.s=j, then i.s=j" ; + sh:maxCount 1 ; + sh:order 22 ; + sh:path linkml:transitive ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 106 ; + sh:path sh1:order ], + [ sh:description "the role a slot on a relationship class plays, for example, the subject, object or predicate roles" ; + sh:in ( rdf:subject rdf:object rdf:predicate "NODE" "OTHER_ROLE" ) ; + sh:maxCount 1 ; + sh:order 30 ; + sh:path linkml:relational_role ], + [ sh:class linkml:SlotDefinition ; + sh:description "indicates that the domain element consists exactly of the members of the element in the range." ; + sh:nodeKind sh:IRI ; + sh:order 36 ; + sh:path linkml:union_of ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 96 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:class linkml:SlotDefinition ; + sh:description "Ontology property which this slot is a subproperty of. Note: setting this property on a slot does not guarantee an expansion of the ontological hiearchy into an enumerated list of possible values in every serialization of the model." ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 16 ; + sh:path rdfs:subPropertyOf ], + [ sh:description "If s is antisymmetric, and i.s=v where i is different from v, v.s cannot have value i" ; + sh:maxCount 1 ; + sh:order 21 ; + sh:path linkml:asymmetric ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 88 ; + sh:path skos:note ], + [ sh:description "the string value of the slot must conform to this regular expression expressed in the string" ; + sh:maxCount 1 ; + sh:order 46 ; + sh:path linkml:pattern ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if none of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 59 ; + sh:path linkml:none_of ], + [ sh:description "true means that slot can have more than one value" ; + sh:maxCount 1 ; + sh:order 3 ; + sh:path linkml:multivalued ], + [ sh:description "If True, then the relationship between the slot domain and range is many to one or many to many" ; + sh:maxCount 1 ; + sh:order 9 ; + sh:path linkml:shared ], + [ sh:class linkml:SlotDefinition ; + sh:description "indicates that any instance of d s r implies that there is also an instance of r s' d" ; + sh:maxCount 1 ; + sh:nodeKind sh:IRI ; + sh:order 23 ; + sh:path owl:inverseOf ], + [ sh:description "If True, then the order of elements of a multivalued slot is guaranteed to be preserved. If False, the order may still be preserved but this is not guaranteed" ; + sh:maxCount 1 ; + sh:order 8 ; + sh:path linkml:list_elements_ordered ], + [ sh:description "If present, slot is read only. Text explains why" ; + sh:maxCount 1 ; + sh:order 5 ; + sh:path linkml:readonly ], + [ sh:description "If True, then there must be no duplicates in the elements of a multivalued slot" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path linkml:list_elements_unique ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 89 ; + sh:path linkml:examples ], + [ sh:description "true means that the slot must be present in the loaded definition" ; + sh:maxCount 1 ; + sh:order 40 ; + sh:path linkml:required ], + [ sh:description "the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class." ; + sh:maxCount 1 ; + sh:order 75 ; + sh:path rdfs:label ], + [ sh:maxCount 1 ; + sh:order 94 ; + sh:path schema:inLanguage ], + [ sh:description "True means that the key slot(s) uniquely identify the container." ; + sh:maxCount 1 ; + sh:order 10 ; + sh:path linkml:key ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 85 ; + sh:path linkml:deprecated ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 104 ; + sh:path skos:narrowMatch ], + [ sh:description "agent that modified the element" ; + sh:maxCount 1 ; + sh:order 72 ; + sh:path oslc:modifiedBy ], + [ sh:description "agent that created the element" ; + sh:maxCount 1 ; + sh:order 69 ; + sh:path pav:createdBy ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 86 ; + sh:path linkml:todos ], + [ sh:description "time at which the element was created" ; + sh:maxCount 1 ; + sh:order 70 ; + sh:path pav:createdOn ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 91 ; + sh:path skos:inScheme ], + [ sh:description "True means that this slot was defined in a slot_usage situation" ; + sh:maxCount 1 ; + sh:order 28 ; + sh:path linkml:is_usage_slot ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 82 ; + sh:path skos:definition ], + [ sh:class linkml:AnonymousSlotExpression ; + sh:description "holds if at least one of the expressions hold" ; + sh:nodeKind sh:BlankNode ; + sh:order 61 ; + sh:path linkml:any_of ] ; + sh:targetClass linkml:SlotDefinition . + +linkml:SubsetDefinition a sh:NodeShape ; + sh:closed true ; + sh:description "an element that can be used to group other metamodel elements" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "the official title of the element" ; + sh:maxCount 1 ; + sh:order 9 ; + sh:path ], + [ sh:description "A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective." ; + sh:order 25 ; + sh:path skos:mappingRelation ], + [ sh:description "A list of terms from different schemas or terminology systems that have broader meaning." ; + sh:order 30 ; + sh:path skos:broadMatch ], + [ sh:class skosxl:Label ; + sh:description "A list of structured_alias objects." ; + sh:nodeKind sh:BlankNode ; + sh:order 24 ; + sh:path skosxl:altLabel ], + [ sh:description "When an element is deprecated, it can be potentially replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 22 ; + sh:path linkml:deprecated_element_has_possible_replacement ], + [ sh:class linkml:Annotation ; + sh:description "a collection of tag/text tuples with the semantics of OWL Annotation" ; + sh:nodeKind sh:BlankNode ; + sh:order 6 ; + sh:path linkml:annotations ], + [ sh:description "Description of why and when this element will no longer be used" ; + sh:maxCount 1 ; + sh:order 10 ; + sh:path linkml:deprecated ], + [ sh:description "An established standard to which the element conforms." ; + sh:maxCount 1 ; + sh:order 4 ; + sh:path ], + [ sh:description "editorial notes about an element intended for internal consumption" ; + sh:order 12 ; + sh:path skos:editorialNote ], + [ sh:class linkml:SubsetDefinition ; + sh:description "used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph)" ; + sh:nodeKind sh:IRI ; + sh:order 15 ; + sh:path OIO:inSubset ], + [ sh:description "the identifier of this class or slot must begin with the URIs referenced by this prefix" ; + sh:order 1 ; + sh:path linkml:id_prefixes ], + [ sh:description "A list of terms from different schemas or terminology systems that have narrower meaning." ; + sh:order 29 ; + sh:path skos:narrowMatch ], + [ sh:class linkml:Example ; + sh:description "example usages of an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 14 ; + sh:path linkml:examples ], + [ sh:description "A list of terms from different schemas or terminology systems that have related meaning." ; + sh:order 28 ; + sh:path skos:relatedMatch ], + [ sh:description "the relative order in which the element occurs, lower values are given precedence" ; + sh:maxCount 1 ; + sh:order 31 ; + sh:path sh1:order ], + [ sh:description "id of the schema that defined the element" ; + sh:maxCount 1 ; + sh:order 16 ; + sh:path skos:inScheme ], + [ sh:description "A list of terms from different schemas or terminology systems that have close meaning." ; + sh:order 27 ; + sh:path skos:closeMatch ], + [ sh:description "A related resource from which the element is derived." ; + sh:maxCount 1 ; + sh:order 18 ; + sh:path ], + [ sh:description "Alaternate names for the element" ; + sh:order 23 ; + sh:path skos:altLabel ], + [ sh:description "a description of the element's purpose and use" ; + sh:maxCount 1 ; + sh:order 7 ; + sh:path skos:definition ], + [ sh:description "the imports entry that this element was derived from. Empty means primary source" ; + sh:maxCount 1 ; + sh:order 17 ; + sh:path linkml:imported_from ], + [ sh:description "the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class." ; + sh:maxCount 1 ; + sh:order 0 ; + sh:path rdfs:label ], + [ sh:description "When an element is deprecated, it can be automatically replaced by this uri or curie" ; + sh:maxCount 1 ; + sh:order 21 ; + sh:path linkml:deprecated_element_has_exact_replacement ], + [ sh:description "A list of terms from different schemas or terminology systems that have identical meaning." ; + sh:order 26 ; + sh:path skos:exactMatch ], + [ sh:description "notes and comments about an element intended for external consumption" ; + sh:order 13 ; + sh:path skos:note ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 5 ; + sh:path linkml:extensions ], + [ sh:description "a reference" ; + sh:order 20 ; + sh:path rdfs:seeAlso ], + [ sh:class linkml:LocalName ; + sh:nodeKind sh:BlankNode ; + sh:order 3 ; + sh:path linkml:local_names ], + [ sh:description "Outstanding issue that needs resolution" ; + sh:order 11 ; + sh:path linkml:todos ], + [ sh:description "the \"native\" URI of the element" ; + sh:maxCount 1 ; + sh:order 2 ; + sh:path linkml:definition_uri ], + [ sh:maxCount 1 ; + sh:order 19 ; + sh:path schema:inLanguage ], + [ sh:class linkml:AltDescription ; + sh:description "A sourced alternative description for an element" ; + sh:nodeKind sh:BlankNode ; + sh:order 8 ; + sh:path linkml:alt_descriptions ] ; + sh:targetClass linkml:SubsetDefinition . + +linkml:Extension a sh:NodeShape ; + sh:closed true ; + sh:description "a tag/value pair used to add non-model information to an entry" ; + sh:ignoredProperties ( rdf:type ) ; + sh:property [ sh:description "the actual annotation" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 1 ; + sh:path linkml:extension_value ], + [ sh:class linkml:Extension ; + sh:description "a tag/text tuple attached to an arbitrary element" ; + sh:nodeKind sh:BlankNode ; + sh:order 2 ; + sh:path linkml:extensions ], + [ sh:description "a tag associated with an extension" ; + sh:maxCount 1 ; + sh:minCount 1 ; + sh:order 0 ; + sh:path linkml:extension_tag ] ; + sh:targetClass linkml:Extension . + diff --git a/linkml_runtime/linkml_model/shex/annotations.shex b/linkml_runtime/linkml_model/shex/annotations.shex index c0c80772..fcc6c8a3 100644 --- a/linkml_runtime/linkml_model/shex/annotations.shex +++ b/linkml_runtime/linkml_model/shex/annotations.shex @@ -23,8 +23,6 @@ PREFIX xsd: xsd:dateTime - - IRI IRI diff --git a/linkml_runtime/linkml_model/shex/annotations.shexj b/linkml_runtime/linkml_model/shex/annotations.shexj index c38dffdc..15fa872e 100644 --- a/linkml_runtime/linkml_model/shex/annotations.shexj +++ b/linkml_runtime/linkml_model/shex/annotations.shexj @@ -54,11 +54,6 @@ "id": "https://w3id.org/linkml/Datetime", "datatype": "http://www.w3.org/2001/XMLSchema#dateTime" }, - { - "type": "NodeConstraint", - "id": "https://w3id.org/linkml/DateOrDatetime", - "datatype": "https://w3id.org/linkml/DateOrDatetime" - }, { "type": "NodeConstraint", "id": "https://w3id.org/linkml/Uriorcurie", diff --git a/linkml_runtime/linkml_model/shex/datasets.shex b/linkml_runtime/linkml_model/shex/datasets.shex new file mode 100644 index 00000000..86c624d3 --- /dev/null +++ b/linkml_runtime/linkml_model/shex/datasets.shex @@ -0,0 +1,109 @@ +# metamodel_version: 1.7.0 +BASE +PREFIX csvw: +PREFIX dcat: +PREFIX dcterms: +PREFIX prov: +PREFIX rdf: +PREFIX void: +PREFIX xsd: +PREFIX linkml: +PREFIX datasets: +PREFIX pav: + + +linkml:String xsd:string + +linkml:Integer xsd:integer + +linkml:Boolean xsd:boolean + +linkml:Float xsd:float + +linkml:Double xsd:double + +linkml:Decimal xsd:decimal + +linkml:Time xsd:dateTime + +linkml:Date xsd:date + +linkml:Datetime xsd:dateTime + +linkml:Uriorcurie IRI + +linkml:Uri IRI + +linkml:Ncname xsd:string + +linkml:Objectidentifier IRI + +linkml:Nodeidentifier NONLITERAL + +datasets:DataPackage CLOSED { + ( $datasets:DataPackage_tes ( &datasets:Information_tes ; + rdf:type [ datasets:Information ] ? ; + dcat:distribution @datasets:DataResource * + ) ; + rdf:type [ void:Dataset ] + ) +} + +datasets:DataResource CLOSED { + ( $datasets:DataResource_tes ( &datasets:Information_tes ; + rdf:type [ datasets:Information ] ? ; + datasets:path @linkml:String ? ; + dcterms:format @datasets:FormatEnum ? ; + dcat:mediaType @linkml:String ? ; + datasets:encoding @linkml:String ? ; + dcat:byteSize @linkml:Integer ? ; + datasets:hash @linkml:String ? ; + datasets:md5 @linkml:String ? ; + datasets:sha256 @linkml:String ? ; + csvw:dialect @linkml:String ? + ) ; + rdf:type [ dcat:Distribution ] + ) +} + +datasets:FormatDialect CLOSED { + ( $datasets:FormatDialect_tes ( datasets:comment_prefix @linkml:String ? ; + datasets:delimiter @linkml:String ? ; + datasets:double_quote @linkml:String ? ; + datasets:header @linkml:String ? ; + datasets:quote_char @linkml:String ? + ) ; + rdf:type [ datasets:FormatDialect ] ? + ) +} + +datasets:Information ( + @datasets:DataPackage OR @datasets:DataResource +) + +datasets:Information_struct { + ( $datasets:Information_tes ( dcat:downloadURL @linkml:Uri ? ; + dcterms:license @linkml:String ? ; + dcterms:title @linkml:String ? ; + dcterms:description @linkml:String ? ; + dcterms:conformsTo @linkml:Uriorcurie ? ; + datasets:conforms_to_schema @linkml:Uriorcurie ? ; + datasets:conforms_to_class @linkml:Uriorcurie ? ; + pav:version @linkml:String ? ; + datasets:language @linkml:String ? ; + dcterms:publisher @linkml:Uriorcurie ? ; + dcat:keyword @linkml:String * ; + dcterms:issued @linkml:Datetime ? ; + pav:createdBy @linkml:Uriorcurie ? ; + pav:createdOn @linkml:Datetime ? ; + datasets:compression @linkml:String ? ; + prov:wasDerivedFrom @linkml:String ? ; + dcat:landingPage @linkml:String ? ; + datasets:test_roles @datasets:TestRole * + ) ; + rdf:type [ datasets:Information ] + ) +} + + + diff --git a/linkml_runtime/linkml_model/shex/datasets.shexj b/linkml_runtime/linkml_model/shex/datasets.shexj new file mode 100644 index 00000000..1b8be37e --- /dev/null +++ b/linkml_runtime/linkml_model/shex/datasets.shexj @@ -0,0 +1,454 @@ +# metamodel_version: 1.7.0 +{ + "type": "Schema", + "@context": [ + "http://www.w3.org/ns/shex.jsonld", + { + "@base": "https://w3id.org/linkml/report" + } + ], + "shapes": [ + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/String", + "datatype": "http://www.w3.org/2001/XMLSchema#string" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Integer", + "datatype": "http://www.w3.org/2001/XMLSchema#integer" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Boolean", + "datatype": "http://www.w3.org/2001/XMLSchema#boolean" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Float", + "datatype": "http://www.w3.org/2001/XMLSchema#float" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Double", + "datatype": "http://www.w3.org/2001/XMLSchema#double" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Decimal", + "datatype": "http://www.w3.org/2001/XMLSchema#decimal" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Time", + "datatype": "http://www.w3.org/2001/XMLSchema#dateTime" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Date", + "datatype": "http://www.w3.org/2001/XMLSchema#date" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Datetime", + "datatype": "http://www.w3.org/2001/XMLSchema#dateTime" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Uriorcurie", + "nodeKind": "iri" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Uri", + "nodeKind": "iri" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Ncname", + "datatype": "http://www.w3.org/2001/XMLSchema#string" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Objectidentifier", + "nodeKind": "iri" + }, + { + "type": "NodeConstraint", + "id": "https://w3id.org/linkml/Nodeidentifier", + "nodeKind": "nonliteral" + }, + { + "type": "Shape", + "id": "https://w3id.org/linkml/reportDataPackage", + "closed": true, + "expression": { + "type": "EachOf", + "expressions": [ + { + "type": "EachOf", + "id": "https://w3id.org/linkml/reportDataPackage_tes", + "expressions": [ + "https://w3id.org/linkml/reportInformation_tes", + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", + "valueExpr": { + "type": "NodeConstraint", + "values": [ + "https://w3id.org/linkml/reportInformation" + ] + }, + "min": 0 + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/ns/dcat#distribution", + "valueExpr": "https://w3id.org/linkml/reportDataResource", + "min": 0, + "max": -1 + } + ] + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", + "valueExpr": { + "type": "NodeConstraint", + "values": [ + "http://rdfs.org/ns/void#Dataset" + ] + }, + "min": 1 + } + ] + } + }, + { + "type": "Shape", + "id": "https://w3id.org/linkml/reportDataResource", + "closed": true, + "expression": { + "type": "EachOf", + "expressions": [ + { + "type": "EachOf", + "id": "https://w3id.org/linkml/reportDataResource_tes", + "expressions": [ + "https://w3id.org/linkml/reportInformation_tes", + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", + "valueExpr": { + "type": "NodeConstraint", + "values": [ + "https://w3id.org/linkml/reportInformation" + ] + }, + "min": 0 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportpath", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://purl.org/dc/terms/format", + "valueExpr": "https://w3id.org/linkml/reportFormatEnum", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/ns/dcat#mediaType", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportencoding", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/ns/dcat#byteSize", + "valueExpr": "https://w3id.org/linkml/Integer", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reporthash", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportmd5", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportsha256", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/ns/csvw#dialect", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + } + ] + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", + "valueExpr": { + "type": "NodeConstraint", + "values": [ + "http://www.w3.org/ns/dcat#Distribution" + ] + }, + "min": 1 + } + ] + } + }, + { + "type": "Shape", + "id": "https://w3id.org/linkml/reportFormatDialect", + "closed": true, + "expression": { + "type": "EachOf", + "expressions": [ + { + "type": "EachOf", + "id": "https://w3id.org/linkml/reportFormatDialect_tes", + "expressions": [ + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportcomment_prefix", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportdelimiter", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportdouble_quote", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportheader", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportquote_char", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + } + ] + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", + "valueExpr": { + "type": "NodeConstraint", + "values": [ + "https://w3id.org/linkml/reportFormatDialect" + ] + }, + "min": 0 + } + ] + } + }, + { + "type": "ShapeOr", + "id": "https://w3id.org/linkml/reportInformation", + "shapeExprs": [ + "https://w3id.org/linkml/reportDataPackage", + "https://w3id.org/linkml/reportDataResource" + ] + }, + { + "type": "Shape", + "id": "https://w3id.org/linkml/reportInformation_struct", + "closed": false, + "expression": { + "type": "EachOf", + "expressions": [ + { + "type": "EachOf", + "id": "https://w3id.org/linkml/reportInformation_tes", + "expressions": [ + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/ns/dcat#downloadURL", + "valueExpr": "https://w3id.org/linkml/Uri", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://purl.org/dc/terms/license", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://purl.org/dc/terms/title", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://purl.org/dc/terms/description", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://purl.org/dc/terms/conformsTo", + "valueExpr": "https://w3id.org/linkml/Uriorcurie", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportconforms_to_schema", + "valueExpr": "https://w3id.org/linkml/Uriorcurie", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportconforms_to_class", + "valueExpr": "https://w3id.org/linkml/Uriorcurie", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://purl.org/pav/version", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportlanguage", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://purl.org/dc/terms/publisher", + "valueExpr": "https://w3id.org/linkml/Uriorcurie", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/ns/dcat#keyword", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": -1 + }, + { + "type": "TripleConstraint", + "predicate": "http://purl.org/dc/terms/issued", + "valueExpr": "https://w3id.org/linkml/Datetime", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://purl.org/pav/createdBy", + "valueExpr": "https://w3id.org/linkml/Uriorcurie", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://purl.org/pav/createdOn", + "valueExpr": "https://w3id.org/linkml/Datetime", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reportcompression", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/ns/prov#wasDerivedFrom", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/ns/dcat#landingPage", + "valueExpr": "https://w3id.org/linkml/String", + "min": 0, + "max": 1 + }, + { + "type": "TripleConstraint", + "predicate": "https://w3id.org/linkml/reporttest_roles", + "valueExpr": "https://w3id.org/linkml/reportTestRole", + "min": 0, + "max": -1 + } + ] + }, + { + "type": "TripleConstraint", + "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", + "valueExpr": { + "type": "NodeConstraint", + "values": [ + "https://w3id.org/linkml/reportInformation" + ] + }, + "min": 1 + } + ] + } + } + ] +} + diff --git a/linkml_runtime/linkml_model/shex/extensions.shex b/linkml_runtime/linkml_model/shex/extensions.shex index 302d124f..90306175 100644 --- a/linkml_runtime/linkml_model/shex/extensions.shex +++ b/linkml_runtime/linkml_model/shex/extensions.shex @@ -23,8 +23,6 @@ PREFIX xsd: xsd:dateTime - - IRI IRI diff --git a/linkml_runtime/linkml_model/shex/extensions.shexj b/linkml_runtime/linkml_model/shex/extensions.shexj index 978472a3..c96e3e15 100644 --- a/linkml_runtime/linkml_model/shex/extensions.shexj +++ b/linkml_runtime/linkml_model/shex/extensions.shexj @@ -54,11 +54,6 @@ "id": "https://w3id.org/linkml/Datetime", "datatype": "http://www.w3.org/2001/XMLSchema#dateTime" }, - { - "type": "NodeConstraint", - "id": "https://w3id.org/linkml/DateOrDatetime", - "datatype": "https://w3id.org/linkml/DateOrDatetime" - }, { "type": "NodeConstraint", "id": "https://w3id.org/linkml/Uriorcurie", diff --git a/linkml_runtime/linkml_model/shex/mappings.shexj b/linkml_runtime/linkml_model/shex/mappings.shexj index 1d13e3b9..1452033a 100644 --- a/linkml_runtime/linkml_model/shex/mappings.shexj +++ b/linkml_runtime/linkml_model/shex/mappings.shexj @@ -54,11 +54,6 @@ "id": "https://w3id.org/linkml/Datetime", "datatype": "http://www.w3.org/2001/XMLSchema#dateTime" }, - { - "type": "NodeConstraint", - "id": "https://w3id.org/linkml/DateOrDatetime", - "datatype": "https://w3id.org/linkml/DateOrDatetime" - }, { "type": "NodeConstraint", "id": "https://w3id.org/linkml/Uriorcurie", diff --git a/linkml_runtime/linkml_model/shex/meta.shexj b/linkml_runtime/linkml_model/shex/meta.shexj index 32c61ee6..8d67bb43 100644 --- a/linkml_runtime/linkml_model/shex/meta.shexj +++ b/linkml_runtime/linkml_model/shex/meta.shexj @@ -54,11 +54,6 @@ "id": "https://w3id.org/linkml/Datetime", "datatype": "http://www.w3.org/2001/XMLSchema#dateTime" }, - { - "type": "NodeConstraint", - "id": "https://w3id.org/linkml/DateOrDatetime", - "datatype": "https://w3id.org/linkml/DateOrDatetime" - }, { "type": "NodeConstraint", "id": "https://w3id.org/linkml/Uriorcurie", @@ -298,122 +293,6 @@ ] } }, - { - "type": "Shape", - "id": "https://w3id.org/linkml/AnonymousEnumExpression", - "closed": true, - "expression": { - "type": "EachOf", - "expressions": [ - { - "type": "EachOf", - "id": "https://w3id.org/linkml/AnonymousEnumExpression_tes", - "expressions": [ - "https://w3id.org/linkml/EnumExpression_tes", - { - "type": "TripleConstraint", - "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", - "valueExpr": { - "type": "NodeConstraint", - "values": [ - "https://w3id.org/linkml/EnumExpression" - ] - }, - "min": 0 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/code_set", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/code_set_tag", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/code_set_version", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/pv_formula", - "valueExpr": "https://w3id.org/linkml/PvFormulaOptions", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/permissible_values", - "valueExpr": "https://w3id.org/linkml/PermissibleValue", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/include", - "valueExpr": "https://w3id.org/linkml/AnonymousEnumExpression", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/minus", - "valueExpr": "https://w3id.org/linkml/AnonymousEnumExpression", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/inherits", - "valueExpr": "https://w3id.org/linkml/EnumDefinition", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/reachable_from", - "valueExpr": "https://w3id.org/linkml/ReachabilityQuery", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/matches", - "valueExpr": "https://w3id.org/linkml/MatchQuery", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/concepts", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": -1 - } - ] - }, - { - "type": "TripleConstraint", - "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", - "valueExpr": { - "type": "NodeConstraint", - "values": [ - "https://w3id.org/linkml/AnonymousEnumExpression" - ] - }, - "min": 0 - } - ] - } - }, { "type": "ShapeOr", "id": "https://w3id.org/linkml/AnonymousExpression", @@ -735,13 +614,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/enum_range", - "valueExpr": "https://w3id.org/linkml/EnumExpression", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/required", @@ -798,13 +670,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/unit", - "valueExpr": "https://w3id.org/linkml/UnitOfMeasure", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/implicit_prefix", @@ -949,20 +814,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/unit", - "valueExpr": "https://w3id.org/linkml/UnitOfMeasure", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/implicit_prefix", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/equals_string", @@ -1856,7 +1707,6 @@ "id": "https://w3id.org/linkml/Definition", "shapeExprs": [ "https://w3id.org/linkml/ClassDefinition", - "https://w3id.org/linkml/EnumDefinition", "https://w3id.org/linkml/SlotDefinition" ] }, @@ -1981,6 +1831,7 @@ "id": "https://w3id.org/linkml/Element", "shapeExprs": [ "https://w3id.org/linkml/Definition", + "https://w3id.org/linkml/EnumDefinition", "https://w3id.org/linkml/SchemaDefinition", "https://w3id.org/linkml/SubsetDefinition", "https://w3id.org/linkml/TypeDefinition" @@ -2277,37 +2128,18 @@ "type": "EachOf", "id": "https://w3id.org/linkml/EnumDefinition_tes", "expressions": [ - "https://w3id.org/linkml/Definition_tes", - { - "type": "TripleConstraint", - "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", - "valueExpr": { - "type": "NodeConstraint", - "values": [ - "https://w3id.org/linkml/Definition" - ] - }, - "min": 0 - }, - "https://w3id.org/linkml/EnumExpression_tes", + "https://w3id.org/linkml/Element_tes", { "type": "TripleConstraint", "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", "valueExpr": { "type": "NodeConstraint", "values": [ - "https://w3id.org/linkml/EnumExpression" + "https://w3id.org/linkml/Element" ] }, "min": 0 }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/enum_uri", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/code_set", @@ -2342,48 +2174,6 @@ "valueExpr": "https://w3id.org/linkml/PermissibleValue", "min": 0, "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/include", - "valueExpr": "https://w3id.org/linkml/AnonymousEnumExpression", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/minus", - "valueExpr": "https://w3id.org/linkml/AnonymousEnumExpression", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/inherits", - "valueExpr": "https://w3id.org/linkml/EnumDefinition", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/reachable_from", - "valueExpr": "https://w3id.org/linkml/ReachabilityQuery", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/matches", - "valueExpr": "https://w3id.org/linkml/MatchQuery", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/concepts", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": -1 } ] }, @@ -2401,122 +2191,6 @@ ] } }, - { - "type": "Shape", - "id": "https://w3id.org/linkml/EnumExpression", - "closed": true, - "expression": { - "type": "EachOf", - "expressions": [ - { - "type": "EachOf", - "id": "https://w3id.org/linkml/EnumExpression_tes", - "expressions": [ - "https://w3id.org/linkml/Expression_tes", - { - "type": "TripleConstraint", - "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", - "valueExpr": { - "type": "NodeConstraint", - "values": [ - "https://w3id.org/linkml/Expression" - ] - }, - "min": 0 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/code_set", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/code_set_tag", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/code_set_version", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/pv_formula", - "valueExpr": "https://w3id.org/linkml/PvFormulaOptions", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/permissible_values", - "valueExpr": "https://w3id.org/linkml/PermissibleValue", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/include", - "valueExpr": "https://w3id.org/linkml/AnonymousEnumExpression", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/minus", - "valueExpr": "https://w3id.org/linkml/AnonymousEnumExpression", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/inherits", - "valueExpr": "https://w3id.org/linkml/EnumDefinition", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/reachable_from", - "valueExpr": "https://w3id.org/linkml/ReachabilityQuery", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/matches", - "valueExpr": "https://w3id.org/linkml/MatchQuery", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/concepts", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": -1 - } - ] - }, - { - "type": "TripleConstraint", - "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", - "valueExpr": { - "type": "NodeConstraint", - "values": [ - "https://w3id.org/linkml/EnumExpression" - ] - }, - "min": 0 - } - ] - } - }, { "type": "Shape", "id": "https://w3id.org/linkml/Example", @@ -2562,7 +2236,6 @@ "type": "ShapeOr", "id": "https://w3id.org/linkml/Expression", "shapeExprs": [ - "https://w3id.org/linkml/EnumExpression", "https://w3id.org/linkml/SlotExpression", "https://w3id.org/linkml/TypeExpression" ] @@ -2992,47 +2665,6 @@ ] } }, - { - "type": "Shape", - "id": "https://w3id.org/linkml/MatchQuery", - "closed": true, - "expression": { - "type": "EachOf", - "expressions": [ - { - "type": "EachOf", - "id": "https://w3id.org/linkml/MatchQuery_tes", - "expressions": [ - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/identifier_pattern", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/source_ontology", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": 1 - } - ] - }, - { - "type": "TripleConstraint", - "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", - "valueExpr": { - "type": "NodeConstraint", - "values": [ - "https://w3id.org/linkml/MatchQuery" - ] - }, - "min": 0 - } - ] - } - }, { "type": "Shape", "id": "https://w3id.org/linkml/PathExpression", @@ -3687,13 +3319,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/unit", - "valueExpr": "https://w3id.org/linkml/UnitOfMeasure", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/mixins", @@ -3940,75 +3565,6 @@ ] } }, - { - "type": "Shape", - "id": "https://w3id.org/linkml/ReachabilityQuery", - "closed": true, - "expression": { - "type": "EachOf", - "expressions": [ - { - "type": "EachOf", - "id": "https://w3id.org/linkml/ReachabilityQuery_tes", - "expressions": [ - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/source_ontology", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/source_nodes", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/relationship_types", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/is_direct", - "valueExpr": "https://w3id.org/linkml/Boolean", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/include_self", - "valueExpr": "https://w3id.org/linkml/Boolean", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/traverse_up", - "valueExpr": "https://w3id.org/linkml/Boolean", - "min": 0, - "max": 1 - } - ] - }, - { - "type": "TripleConstraint", - "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", - "valueExpr": { - "type": "NodeConstraint", - "values": [ - "https://w3id.org/linkml/ReachabilityQuery" - ] - }, - "min": 0 - } - ] - } - }, { "type": "Shape", "id": "https://w3id.org/linkml/SchemaDefinition", @@ -4537,13 +4093,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/union_of", - "valueExpr": "https://w3id.org/linkml/TypeDefinition", - "min": 0, - "max": -1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/mixins", @@ -4572,13 +4121,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/enum_range", - "valueExpr": "https://w3id.org/linkml/EnumExpression", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/required", @@ -4635,13 +4177,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/unit", - "valueExpr": "https://w3id.org/linkml/UnitOfMeasure", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/implicit_prefix", @@ -4786,13 +4321,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/enum_range", - "valueExpr": "https://w3id.org/linkml/EnumExpression", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/required", @@ -4849,13 +4377,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/unit", - "valueExpr": "https://w3id.org/linkml/UnitOfMeasure", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/implicit_prefix", @@ -5350,13 +4871,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/union_of", - "valueExpr": "https://w3id.org/linkml/TypeDefinition", - "min": 0, - "max": -1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/pattern", @@ -5371,20 +4885,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/unit", - "valueExpr": "https://w3id.org/linkml/UnitOfMeasure", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/implicit_prefix", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/equals_string", @@ -5501,20 +5001,6 @@ "min": 0, "max": 1 }, - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/unit", - "valueExpr": "https://w3id.org/linkml/UnitOfMeasure", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/implicit_prefix", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, { "type": "TripleConstraint", "predicate": "https://w3id.org/linkml/equals_string", @@ -5859,75 +5345,6 @@ } ] } - }, - { - "type": "Shape", - "id": "https://w3id.org/linkml/UnitOfMeasure", - "closed": true, - "expression": { - "type": "EachOf", - "expressions": [ - { - "type": "EachOf", - "id": "https://w3id.org/linkml/UnitOfMeasure_tes", - "expressions": [ - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/symbol", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "http://www.w3.org/2004/02/skos/core#exactMatch", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": -1 - }, - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/ucumCode", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/derivation", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/hasQuantityKind", - "valueExpr": "https://w3id.org/linkml/Uriorcurie", - "min": 0, - "max": 1 - }, - { - "type": "TripleConstraint", - "predicate": "http://qudt.org/schema/qudt/iec61360Code", - "valueExpr": "https://w3id.org/linkml/String", - "min": 0, - "max": 1 - } - ] - }, - { - "type": "TripleConstraint", - "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", - "valueExpr": { - "type": "NodeConstraint", - "values": [ - "http://qudt.org/schema/qudt/Unit" - ] - }, - "min": 0 - } - ] - } } ] } diff --git a/linkml_runtime/linkml_model/shex/types.shex b/linkml_runtime/linkml_model/shex/types.shex index 42bb4d99..e0a49039 100644 --- a/linkml_runtime/linkml_model/shex/types.shex +++ b/linkml_runtime/linkml_model/shex/types.shex @@ -22,8 +22,6 @@ PREFIX xsd: xsd:dateTime - - IRI IRI diff --git a/linkml_runtime/linkml_model/shex/types.shexj b/linkml_runtime/linkml_model/shex/types.shexj index 1d13e3b9..1452033a 100644 --- a/linkml_runtime/linkml_model/shex/types.shexj +++ b/linkml_runtime/linkml_model/shex/types.shexj @@ -54,11 +54,6 @@ "id": "https://w3id.org/linkml/Datetime", "datatype": "http://www.w3.org/2001/XMLSchema#dateTime" }, - { - "type": "NodeConstraint", - "id": "https://w3id.org/linkml/DateOrDatetime", - "datatype": "https://w3id.org/linkml/DateOrDatetime" - }, { "type": "NodeConstraint", "id": "https://w3id.org/linkml/Uriorcurie", diff --git a/linkml_runtime/linkml_model/shex/validation.shex b/linkml_runtime/linkml_model/shex/validation.shex index d7a5d0e5..cc5f131e 100644 --- a/linkml_runtime/linkml_model/shex/validation.shex +++ b/linkml_runtime/linkml_model/shex/validation.shex @@ -25,8 +25,6 @@ linkml:Date xsd:date linkml:Datetime xsd:dateTime -linkml:DateOrDatetime linkml:DateOrDatetime - linkml:Uriorcurie IRI linkml:Uri IRI @@ -51,7 +49,7 @@ reporting:ValidationResult CLOSED { reporting:predicate @linkml:Nodeidentifier ? ; sh1:value @linkml:Nodeidentifier ? ; reporting:object_str @linkml:String ? ; - reporting:node_source @linkml:Nodeidentifier ? ; + reporting:source @linkml:Nodeidentifier ? ; reporting:info @linkml:String ? ) ; rdf:type [ sh1:ValidationResult ] ? diff --git a/linkml_runtime/linkml_model/shex/validation.shexj b/linkml_runtime/linkml_model/shex/validation.shexj index 7fbbf7c8..dfb70844 100644 --- a/linkml_runtime/linkml_model/shex/validation.shexj +++ b/linkml_runtime/linkml_model/shex/validation.shexj @@ -53,11 +53,6 @@ "id": "https://w3id.org/linkml/Datetime", "datatype": "http://www.w3.org/2001/XMLSchema#dateTime" }, - { - "type": "NodeConstraint", - "id": "https://w3id.org/linkml/DateOrDatetime", - "datatype": "https://w3id.org/linkml/DateOrDatetime" - }, { "type": "NodeConstraint", "id": "https://w3id.org/linkml/Uriorcurie", @@ -174,7 +169,7 @@ }, { "type": "TripleConstraint", - "predicate": "https://w3id.org/linkml/reportnode_source", + "predicate": "https://w3id.org/linkml/reportsource", "valueExpr": "https://w3id.org/linkml/Nodeidentifier", "min": 0, "max": 1 diff --git a/linkml_runtime/linkml_model/sqlddl/meta.sql b/linkml_runtime/linkml_model/sqlddl/meta.sql new file mode 100644 index 00000000..a96c43c5 --- /dev/null +++ b/linkml_runtime/linkml_model/sqlddl/meta.sql @@ -0,0 +1,4196 @@ +-- # Class: "common_metadata" Description: "Generic metadata shared across definitions" +-- * Slot: id Description: +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- # Class: "element" Description: "a named element in the model" +-- * Slot: name Description: the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class. +-- * Slot: definition_uri Description: the "native" URI of the element +-- * Slot: conforms_to Description: An established standard to which the element conforms. +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- # Class: "schema_definition" Description: "a collection of subset, type, slot and class definitions" +-- * Slot: id Description: The official schema URI +-- * Slot: version Description: particular version of schema +-- * Slot: license Description: license for the schema +-- * Slot: default_prefix Description: default and base prefix -- used for ':' identifiers, @base and @vocab +-- * Slot: default_range Description: default slot range to be used if range element is omitted from a slot definition +-- * Slot: metamodel_version Description: Version of the metamodel used to load the schema +-- * Slot: source_file Description: name, uri or description of the source of the schema +-- * Slot: source_file_date Description: modification date of the source of the schema +-- * Slot: source_file_size Description: size in bytes of the source of the schema +-- * Slot: generation_date Description: date and time that the schema was loaded/generated +-- * Slot: slot_names_unique Description: if true then induced/mangled slot names are not created for class_usage and attributes +-- * Slot: name Description: the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class. +-- * Slot: definition_uri Description: the "native" URI of the element +-- * Slot: conforms_to Description: An established standard to which the element conforms. +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- # Class: "type_expression" Description: "" +-- * Slot: id Description: +-- * Slot: pattern Description: the string value of the slot must conform to this regular expression expressed in the string +-- * Slot: equals_string Description: the slot must have range string and the value of the slot must equal the specified value +-- * Slot: equals_number Description: the slot must have range of a number and the value of the slot must equal the specified value +-- * Slot: minimum_value Description: for slots with ranges of type number, the value must be equal to or higher than this +-- * Slot: maximum_value Description: for slots with ranges of type number, the value must be equal to or lowe than this +-- * Slot: structured_pattern_id Description: the string value of the slot must conform to the regular expression in the pattern expression +-- # Class: "anonymous_type_expression" Description: "" +-- * Slot: id Description: +-- * Slot: pattern Description: the string value of the slot must conform to this regular expression expressed in the string +-- * Slot: equals_string Description: the slot must have range string and the value of the slot must equal the specified value +-- * Slot: equals_number Description: the slot must have range of a number and the value of the slot must equal the specified value +-- * Slot: minimum_value Description: for slots with ranges of type number, the value must be equal to or higher than this +-- * Slot: maximum_value Description: for slots with ranges of type number, the value must be equal to or lowe than this +-- * Slot: structured_pattern_id Description: the string value of the slot must conform to the regular expression in the pattern expression +-- # Class: "type_definition" Description: "A data type definition." +-- * Slot: typeof Description: Names a parent type +-- * Slot: base Description: python base type that implements this type definition +-- * Slot: uri Description: The uri that defines the possible values for the type definition +-- * Slot: repr Description: the name of the python object that implements this type definition +-- * Slot: pattern Description: the string value of the slot must conform to this regular expression expressed in the string +-- * Slot: equals_string Description: the slot must have range string and the value of the slot must equal the specified value +-- * Slot: equals_number Description: the slot must have range of a number and the value of the slot must equal the specified value +-- * Slot: minimum_value Description: for slots with ranges of type number, the value must be equal to or higher than this +-- * Slot: maximum_value Description: for slots with ranges of type number, the value must be equal to or lowe than this +-- * Slot: name Description: the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class. +-- * Slot: definition_uri Description: the "native" URI of the element +-- * Slot: conforms_to Description: An established standard to which the element conforms. +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: structured_pattern_id Description: the string value of the slot must conform to the regular expression in the pattern expression +-- # Class: "subset_definition" Description: "the name and description of a subset" +-- * Slot: name Description: the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class. +-- * Slot: definition_uri Description: the "native" URI of the element +-- * Slot: conforms_to Description: An established standard to which the element conforms. +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- # Class: "definition" Description: "base class for definitions" +-- * Slot: is_a Description: specifies single-inheritance between classes or slots. While multiple inheritance is not allowed, mixins can be provided effectively providing the same thing. The semantics are the same when translated to formalisms that allow MI (e.g. RDFS/OWL). When translating to a SI framework (e.g. java classes, python classes) then is a is used. When translating a framework without polymorphism (e.g. json-schema, solr document schema) then is a and mixins are recursively unfolded +-- * Slot: abstract Description: an abstract class is a high level class or slot that is typically used to group common slots together and cannot be directly instantiated. +-- * Slot: mixin Description: this slot or class can only be used as a mixin. +-- * Slot: created_by Description: agent that created the element +-- * Slot: created_on Description: time at which the element was created +-- * Slot: last_updated_on Description: time at which the element was last updated +-- * Slot: modified_by Description: agent that modified the element +-- * Slot: status Description: status of the element +-- * Slot: string_serialization Description: Used on a slot that stores the string serialization of the containing object. The syntax follows python formatted strings, with slot names enclosed in {}s. These are expanded using the values of those slots.We call the slot with the serialization the s-slot, the slots used in the {}s are v-slots. If both s-slots and v-slots are populated on an object then the value of the s-slot should correspond to the expansion.Implementations of frameworks may choose to use this property to either (a) PARSE: implement automated normalizations by parsing denormalized strings into complex objects (b) GENERARE: implement automated to_string labeling of complex objectsFor example, a Measurement class may have 3 fields: unit, value, and string_value. The string_value slot may have a string_serialization of {value}{unit} such that if unit=cm and value=2, the value of string_value shouldd be 2cm +-- * Slot: name Description: the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class. +-- * Slot: definition_uri Description: the "native" URI of the element +-- * Slot: conforms_to Description: An established standard to which the element conforms. +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- # Class: "enum_definition" Description: "List of values that constrain the range of a slot" +-- * Slot: code_set Description: the identifier of an enumeration code set. +-- * Slot: code_set_tag Description: the version tag of the enumeration code set +-- * Slot: code_set_version Description: the version identifier of the enumeration code set +-- * Slot: pv_formula Description: Defines the specific formula to be used to generate the permissible values. +-- * Slot: name Description: the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class. +-- * Slot: definition_uri Description: the "native" URI of the element +-- * Slot: conforms_to Description: An established standard to which the element conforms. +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- # Class: "structured_alias" Description: "object that contains meta data about a synonym or alias including where it came from (source) and its scope (narrow, broad, etc.)" +-- * Slot: id Description: +-- * Slot: literal_form Description: The literal lexical form of a structured alias +-- * Slot: predicate Description: The relationship between an element and its alias +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- # Class: "expression" Description: "general mixin for any class that can represent some form of expression" +-- * Slot: id Description: +-- # Class: "anonymous_expression" Description: "" +-- * Slot: id Description: +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- # Class: "path_expression" Description: "An expression that describes an abstract path from an object to another through a sequence of slot lookups" +-- * Slot: id Description: +-- * Slot: reversed Description: true if the slot is to be inversed +-- * Slot: traverse Description: the slot to traverse +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: followed_by_id Description: in a sequential list, this indicates the next member +-- * Slot: range_expression_id Description: A range that is described as a boolean expression combining existing ranges +-- # Class: "slot_expression" Description: "an expression that constrains the range of values a slot can take" +-- * Slot: id Description: +-- * Slot: range Description: defines the type of the object of the slot. Given the following slot definition S1: domain: C1 range: C2the declaration X: S1: Yimplicitly asserts Y is an instance of C2 +-- * Slot: required Description: true means that the slot must be present in the loaded definition +-- * Slot: recommended Description: true means that the slot should be present in the loaded definition, but this is not required +-- * Slot: inlined Description: True means that keyed or identified slot appears in an outer structure by value. False means that only the key or identifier for the slot appears within the domain, referencing a structure that appears elsewhere. +-- * Slot: inlined_as_list Description: True means that an inlined slot is represented as a list of range instances. False means that an inlined slot is represented as a dictionary, whose key is the slot key or identifier and whose value is the range instance. +-- * Slot: minimum_value Description: for slots with ranges of type number, the value must be equal to or higher than this +-- * Slot: maximum_value Description: for slots with ranges of type number, the value must be equal to or lowe than this +-- * Slot: pattern Description: the string value of the slot must conform to this regular expression expressed in the string +-- * Slot: implicit_prefix Description: Causes the slot value to be interpreted as a uriorcurie after prefixing with this string +-- * Slot: equals_string Description: the slot must have range string and the value of the slot must equal the specified value +-- * Slot: equals_number Description: the slot must have range of a number and the value of the slot must equal the specified value +-- * Slot: equals_expression Description: the value of the slot must equal the value of the evaluated expression +-- * Slot: minimum_cardinality Description: the minimum number of entries for a multivalued slot +-- * Slot: maximum_cardinality Description: the maximum number of entries for a multivalued slot +-- * Slot: range_expression_id Description: A range that is described as a boolean expression combining existing ranges +-- * Slot: structured_pattern_id Description: the string value of the slot must conform to the regular expression in the pattern expression +-- * Slot: has_member_id Description: the values of the slot is multivalued with at least one member satisfying the condition +-- # Class: "anonymous_slot_expression" Description: "" +-- * Slot: id Description: +-- * Slot: range Description: defines the type of the object of the slot. Given the following slot definition S1: domain: C1 range: C2the declaration X: S1: Yimplicitly asserts Y is an instance of C2 +-- * Slot: required Description: true means that the slot must be present in the loaded definition +-- * Slot: recommended Description: true means that the slot should be present in the loaded definition, but this is not required +-- * Slot: inlined Description: True means that keyed or identified slot appears in an outer structure by value. False means that only the key or identifier for the slot appears within the domain, referencing a structure that appears elsewhere. +-- * Slot: inlined_as_list Description: True means that an inlined slot is represented as a list of range instances. False means that an inlined slot is represented as a dictionary, whose key is the slot key or identifier and whose value is the range instance. +-- * Slot: minimum_value Description: for slots with ranges of type number, the value must be equal to or higher than this +-- * Slot: maximum_value Description: for slots with ranges of type number, the value must be equal to or lowe than this +-- * Slot: pattern Description: the string value of the slot must conform to this regular expression expressed in the string +-- * Slot: implicit_prefix Description: Causes the slot value to be interpreted as a uriorcurie after prefixing with this string +-- * Slot: equals_string Description: the slot must have range string and the value of the slot must equal the specified value +-- * Slot: equals_number Description: the slot must have range of a number and the value of the slot must equal the specified value +-- * Slot: equals_expression Description: the value of the slot must equal the value of the evaluated expression +-- * Slot: minimum_cardinality Description: the minimum number of entries for a multivalued slot +-- * Slot: maximum_cardinality Description: the maximum number of entries for a multivalued slot +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: range_expression_id Description: A range that is described as a boolean expression combining existing ranges +-- * Slot: structured_pattern_id Description: the string value of the slot must conform to the regular expression in the pattern expression +-- * Slot: has_member_id Description: the values of the slot is multivalued with at least one member satisfying the condition +-- # Class: "slot_definition" Description: "the definition of a property or a slot" +-- * Slot: singular_name Description: a name that is used in the singular form +-- * Slot: domain Description: defines the type of the subject of the slot. Given the following slot definition S1: domain: C1 range: C2the declaration X: S1: Yimplicitly asserts that X is an instance of C1 +-- * Slot: slot_uri Description: predicate of this slot for semantic web application +-- * Slot: multivalued Description: true means that slot can have more than one value +-- * Slot: inherited Description: true means that the *value* of a slot is inherited by subclasses +-- * Slot: readonly Description: If present, slot is read only. Text explains why +-- * Slot: ifabsent Description: function that provides a default value for the slot. Possible values for this slot are defined inlinkml_runtime.utils.ifabsent_functions.default_library: * [Tt]rue -- boolean True * [Ff]alse -- boolean False * int(value) -- integer value * str(value) -- string value * default_range -- schema default range * bnode -- blank node identifier * slot_uri -- URI for the slot * class_curie -- CURIE for the containing class * class_uri -- URI for the containing class +-- * Slot: list_elements_unique Description: If True, then there must be no duplicates in the elements of a multivalued slot +-- * Slot: list_elements_ordered Description: If True, then the order of elements of a multivalued slot is guaranteed to be preserved. If False, the order may still be preserved but this is not guaranteed +-- * Slot: shared Description: If True, then the relationship between the slot domain and range is many to one or many to many +-- * Slot: key Description: True means that the key slot(s) uniquely identify the container. +-- * Slot: identifier Description: True means that the key slot(s) uniquely identify the container. There can be at most one identifier or key per container +-- * Slot: designates_type Description: True means that the key slot(s) is used to determine the instantiation (types) relation between objects and a ClassDefinition +-- * Slot: alias Description: the name used for a slot in the context of its owning class. If present, this is used instead of the actual slot name. +-- * Slot: owner Description: the "owner" of the slot. It is the class if it appears in the slots list, otherwise the declaring slot +-- * Slot: subproperty_of Description: Ontology property which this slot is a subproperty of +-- * Slot: symmetric Description: If s is symmetric, and i.s=v, then v.s=i +-- * Slot: reflexive Description: If s is reflexive, then i.s=i for all instances i +-- * Slot: locally_reflexive Description: If s is locally_reflexive, then i.s=i for all instances i where s if a class slot for the type of i +-- * Slot: irreflexive Description: If s is irreflexive, then there exists no i such i.s=i +-- * Slot: asymmetric Description: If s is antisymmetric, and i.s=v where i is different from v, v.s cannot have value i +-- * Slot: transitive Description: If s is transitive, and i.s=z, and s.s=j, then i.s=j +-- * Slot: inverse Description: indicates that any instance of d s r implies that there is also an instance of r s' d +-- * Slot: is_class_field Description: indicates that any instance, i, the domain of this slot will include an assert of i s range +-- * Slot: transitive_form_of Description: If s transitive_form_of d, then (1) s holds whenever d holds (2) s is transitive (3) d holds whenever s holds and there are no intermediates, and s is not reflexive +-- * Slot: reflexive_transitive_form_of Description: transitive_form_of including the reflexive case +-- * Slot: role Description: the role played by the slot range +-- * Slot: is_usage_slot Description: True means that this slot was defined in a slot_usage situation +-- * Slot: usage_slot_name Description: The name of the slot referenced in the slot_usage +-- * Slot: relational_role Description: the role a slot on a relationship class plays, for example, the subject, object or predicate roles +-- * Slot: slot_group Description: allows for grouping of related slots into a grouping slot that serves the role of a group +-- * Slot: is_grouping_slot Description: true if this slot is a grouping slot +-- * Slot: children_are_mutually_disjoint Description: If true then all direct is_a children are mutually disjoint and share no instances in common +-- * Slot: range Description: defines the type of the object of the slot. Given the following slot definition S1: domain: C1 range: C2the declaration X: S1: Yimplicitly asserts Y is an instance of C2 +-- * Slot: required Description: true means that the slot must be present in the loaded definition +-- * Slot: recommended Description: true means that the slot should be present in the loaded definition, but this is not required +-- * Slot: inlined Description: True means that keyed or identified slot appears in an outer structure by value. False means that only the key or identifier for the slot appears within the domain, referencing a structure that appears elsewhere. +-- * Slot: inlined_as_list Description: True means that an inlined slot is represented as a list of range instances. False means that an inlined slot is represented as a dictionary, whose key is the slot key or identifier and whose value is the range instance. +-- * Slot: minimum_value Description: for slots with ranges of type number, the value must be equal to or higher than this +-- * Slot: maximum_value Description: for slots with ranges of type number, the value must be equal to or lowe than this +-- * Slot: pattern Description: the string value of the slot must conform to this regular expression expressed in the string +-- * Slot: implicit_prefix Description: Causes the slot value to be interpreted as a uriorcurie after prefixing with this string +-- * Slot: equals_string Description: the slot must have range string and the value of the slot must equal the specified value +-- * Slot: equals_number Description: the slot must have range of a number and the value of the slot must equal the specified value +-- * Slot: equals_expression Description: the value of the slot must equal the value of the evaluated expression +-- * Slot: minimum_cardinality Description: the minimum number of entries for a multivalued slot +-- * Slot: maximum_cardinality Description: the maximum number of entries for a multivalued slot +-- * Slot: is_a Description: specifies single-inheritance between classes or slots. While multiple inheritance is not allowed, mixins can be provided effectively providing the same thing. The semantics are the same when translated to formalisms that allow MI (e.g. RDFS/OWL). When translating to a SI framework (e.g. java classes, python classes) then is a is used. When translating a framework without polymorphism (e.g. json-schema, solr document schema) then is a and mixins are recursively unfolded +-- * Slot: abstract Description: an abstract class is a high level class or slot that is typically used to group common slots together and cannot be directly instantiated. +-- * Slot: mixin Description: this slot or class can only be used as a mixin. +-- * Slot: created_by Description: agent that created the element +-- * Slot: created_on Description: time at which the element was created +-- * Slot: last_updated_on Description: time at which the element was last updated +-- * Slot: modified_by Description: agent that modified the element +-- * Slot: status Description: status of the element +-- * Slot: string_serialization Description: Used on a slot that stores the string serialization of the containing object. The syntax follows python formatted strings, with slot names enclosed in {}s. These are expanded using the values of those slots.We call the slot with the serialization the s-slot, the slots used in the {}s are v-slots. If both s-slots and v-slots are populated on an object then the value of the s-slot should correspond to the expansion.Implementations of frameworks may choose to use this property to either (a) PARSE: implement automated normalizations by parsing denormalized strings into complex objects (b) GENERARE: implement automated to_string labeling of complex objectsFor example, a Measurement class may have 3 fields: unit, value, and string_value. The string_value slot may have a string_serialization of {value}{unit} such that if unit=cm and value=2, the value of string_value shouldd be 2cm +-- * Slot: name Description: the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class. +-- * Slot: definition_uri Description: the "native" URI of the element +-- * Slot: conforms_to Description: An established standard to which the element conforms. +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: slot_expression_id Description: Autocreated FK slot +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: class_expression_id Description: Autocreated FK slot +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: path_rule_id Description: a rule for inferring a slot assignment based on evaluating a path through a sequence of slot assignemnts +-- * Slot: range_expression_id Description: A range that is described as a boolean expression combining existing ranges +-- * Slot: structured_pattern_id Description: the string value of the slot must conform to the regular expression in the pattern expression +-- * Slot: has_member_id Description: the values of the slot is multivalued with at least one member satisfying the condition +-- # Class: "class_expression" Description: "A boolean expression that can be used to dynamically determine membership of a class" +-- * Slot: id Description: +-- # Class: "anonymous_class_expression" Description: "" +-- * Slot: id Description: +-- * Slot: is_a Description: specifies single-inheritance between classes or slots. While multiple inheritance is not allowed, mixins can be provided effectively providing the same thing. The semantics are the same when translated to formalisms that allow MI (e.g. RDFS/OWL). When translating to a SI framework (e.g. java classes, python classes) then is a is used. When translating a framework without polymorphism (e.g. json-schema, solr document schema) then is a and mixins are recursively unfolded +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: class_definition_name Description: Autocreated FK slot +-- # Class: "class_definition" Description: "the definition of a class or interface" +-- * Slot: class_uri Description: URI of the class in an RDF environment +-- * Slot: subclass_of Description: rdfs:subClassOf to be emitted in OWL generation +-- * Slot: tree_root Description: indicator that this is the root class in tree structures +-- * Slot: slot_names_unique Description: if true then induced/mangled slot names are not created for class_usage and attributes +-- * Slot: represents_relationship Description: true if this class represents a relationship rather than an entity +-- * Slot: children_are_mutually_disjoint Description: If true then all direct is_a children are mutually disjoint and share no instances in common +-- * Slot: is_a Description: specifies single-inheritance between classes or slots. While multiple inheritance is not allowed, mixins can be provided effectively providing the same thing. The semantics are the same when translated to formalisms that allow MI (e.g. RDFS/OWL). When translating to a SI framework (e.g. java classes, python classes) then is a is used. When translating a framework without polymorphism (e.g. json-schema, solr document schema) then is a and mixins are recursively unfolded +-- * Slot: abstract Description: an abstract class is a high level class or slot that is typically used to group common slots together and cannot be directly instantiated. +-- * Slot: mixin Description: this slot or class can only be used as a mixin. +-- * Slot: created_by Description: agent that created the element +-- * Slot: created_on Description: time at which the element was created +-- * Slot: last_updated_on Description: time at which the element was last updated +-- * Slot: modified_by Description: agent that modified the element +-- * Slot: status Description: status of the element +-- * Slot: string_serialization Description: Used on a slot that stores the string serialization of the containing object. The syntax follows python formatted strings, with slot names enclosed in {}s. These are expanded using the values of those slots.We call the slot with the serialization the s-slot, the slots used in the {}s are v-slots. If both s-slots and v-slots are populated on an object then the value of the s-slot should correspond to the expansion.Implementations of frameworks may choose to use this property to either (a) PARSE: implement automated normalizations by parsing denormalized strings into complex objects (b) GENERARE: implement automated to_string labeling of complex objectsFor example, a Measurement class may have 3 fields: unit, value, and string_value. The string_value slot may have a string_serialization of {value}{unit} such that if unit=cm and value=2, the value of string_value shouldd be 2cm +-- * Slot: name Description: the unique name of the element within the context of the schema. Name is combined with the default prefix to form the globally unique subject of the target class. +-- * Slot: definition_uri Description: the "native" URI of the element +-- * Slot: conforms_to Description: An established standard to which the element conforms. +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- # Class: "class_level_rule" Description: "A rule that is applied to classes" +-- * Slot: id Description: +-- # Class: "class_rule" Description: "A rule that applies to instances of a class" +-- * Slot: id Description: +-- * Slot: bidirectional Description: in addition to preconditions entailing postconditions, the postconditions entail the preconditions +-- * Slot: open_world Description: if true, the the postconditions may be omitted in instance data, but it is valid for an inference engine to add these +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: deactivated Description: a deactivated rule is not executed by the rules engine +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: preconditions_id Description: an expression that must hold in order for the rule to be applicable to an instance +-- * Slot: postconditions_id Description: an expression that must hold for an instance of the class, if the preconditions hold +-- * Slot: elseconditions_id Description: an expression that must hold for an instance of the class, if the preconditions no not hold +-- # Class: "pattern_expression" Description: "a regular expression pattern used to evaluate conformance of a string" +-- * Slot: id Description: +-- * Slot: syntax Description: the string value of the slot must conform to this regular expression expressed in the string. May be interpolated. +-- * Slot: interpolated Description: if true then the pattern is first string interpolated +-- * Slot: partial_match Description: if true then the pattern must match the whole string, as if enclosed in ^...$ +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- # Class: "import_expression" Description: "an expression describing an import" +-- * Slot: id Description: +-- * Slot: import_from Description: +-- * Slot: import_as Description: +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- # Class: "setting" Description: "assignment of a key to a value" +-- * Slot: setting_key Description: the variable name for a setting +-- * Slot: setting_value Description: The value assigned for a setting +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: import_expression_id Description: Autocreated FK slot +-- # Class: "prefix" Description: "prefix URI tuple" +-- * Slot: prefix_prefix Description: the nsname (sans ':' for a given prefix) +-- * Slot: prefix_reference Description: A URI associated with a given prefix +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- # Class: "local_name" Description: "an attributed label" +-- * Slot: local_name_source Description: the ncname of the source of the name +-- * Slot: local_name_value Description: a name assigned to an element in a given ontology +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: class_definition_name Description: Autocreated FK slot +-- # Class: "example" Description: "usage example and description" +-- * Slot: id Description: +-- * Slot: value Description: example value +-- * Slot: description Description: description of what the value is doing +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- # Class: "alt_description" Description: "an attributed description" +-- * Slot: source Description: the source of an attributed description +-- * Slot: description Description: text of an attributed description +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- # Class: "permissible_value" Description: "a permissible value, accompanied by intended text and an optional mapping to a concept URI" +-- * Slot: text Description: +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: meaning Description: the value meaning of a permissible value +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- # Class: "unique_key" Description: "a collection of slots whose values uniquely identify an instance of a class" +-- * Slot: unique_key_name Description: name of the unique key +-- * Slot: description Description: a description of the element's purpose and use +-- * Slot: title Description: the official title of the element +-- * Slot: deprecated Description: Description of why and when this element will no longer be used +-- * Slot: from_schema Description: id of the schema that defined the element +-- * Slot: imported_from Description: the imports entry that this element was derived from. Empty means primary source +-- * Slot: source Description: A related resource from which the element is derived. +-- * Slot: in_language Description: +-- * Slot: deprecated_element_has_exact_replacement Description: When an element is deprecated, it can be automatically replaced by this uri or curie +-- * Slot: deprecated_element_has_possible_replacement Description: When an element is deprecated, it can be potentially replaced by this uri or curie +-- * Slot: rank Description: the relative order in which the element occurs, lower values are given precedence +-- * Slot: class_definition_name Description: Autocreated FK slot +-- # Class: "annotatable" Description: "mixin for classes that support annotations" +-- * Slot: id Description: +-- # Class: "annotation" Description: "a tag/value pair with the semantics of OWL Annotation" +-- * Slot: tag Description: a tag associated with an extension +-- * Slot: value Description: the actual annotation +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: annotatable_id Description: Autocreated FK slot +-- * Slot: annotation_tag Description: Autocreated FK slot +-- # Class: "extension" Description: "a tag/value pair used to add non-model information to an entry" +-- * Slot: tag Description: a tag associated with an extension +-- * Slot: value Description: the actual annotation +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: annotation_tag Description: Autocreated FK slot +-- * Slot: extension_tag Description: Autocreated FK slot +-- * Slot: extensible_id Description: Autocreated FK slot +-- # Class: "extensible" Description: "mixin for classes that support extension" +-- * Slot: id Description: +-- # Class: "common_metadata_todos" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "common_metadata_notes" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "common_metadata_comments" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "common_metadata_in_subset" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "common_metadata_see_also" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "common_metadata_aliases" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "common_metadata_mappings" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "common_metadata_exact_mappings" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "common_metadata_close_mappings" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "common_metadata_related_mappings" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "common_metadata_narrow_mappings" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "common_metadata_broad_mappings" Description: "" +-- * Slot: common_metadata_id Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "element_id_prefixes" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: id_prefixes Description: the identifier of this class or slot must begin with the URIs referenced by this prefix +-- # Class: "element_todos" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "element_notes" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "element_comments" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "element_in_subset" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "element_see_also" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "element_aliases" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "element_mappings" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "element_exact_mappings" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "element_close_mappings" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "element_related_mappings" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "element_narrow_mappings" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "element_broad_mappings" Description: "" +-- * Slot: element_name Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "schema_definition_imports" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: imports Description: other schemas that are included in this schema +-- # Class: "schema_definition_emit_prefixes" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: emit_prefixes Description: a list of Curie prefixes that are used in the representation of instances of the model. All prefixes in this list are added to the prefix sections of the target models. +-- # Class: "schema_definition_default_curi_maps" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: default_curi_maps Description: ordered list of prefixcommon biocontexts to be fetched to resolve id prefixes and inline prefix variables +-- # Class: "schema_definition_category" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: category Description: controlled terms used to categorize an element +-- # Class: "schema_definition_keyword" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: keyword Description: Keywords or tags used to describe the element +-- # Class: "schema_definition_id_prefixes" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: id_prefixes Description: the identifier of this class or slot must begin with the URIs referenced by this prefix +-- # Class: "schema_definition_todos" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "schema_definition_notes" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "schema_definition_comments" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "schema_definition_in_subset" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "schema_definition_see_also" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "schema_definition_aliases" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "schema_definition_mappings" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "schema_definition_exact_mappings" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "schema_definition_close_mappings" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "schema_definition_related_mappings" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "schema_definition_narrow_mappings" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "schema_definition_broad_mappings" Description: "" +-- * Slot: schema_definition_name Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "type_expression_equals_string_in" Description: "" +-- * Slot: type_expression_id Description: Autocreated FK slot +-- * Slot: equals_string_in Description: the slot must have range string and the value of the slot must equal one of the specified values +-- # Class: "type_expression_none_of" Description: "" +-- * Slot: type_expression_id Description: Autocreated FK slot +-- * Slot: none_of_id Description: holds if none of the expressions hold +-- # Class: "type_expression_exactly_one_of" Description: "" +-- * Slot: type_expression_id Description: Autocreated FK slot +-- * Slot: exactly_one_of_id Description: holds if only one of the expressions hold +-- # Class: "type_expression_any_of" Description: "" +-- * Slot: type_expression_id Description: Autocreated FK slot +-- * Slot: any_of_id Description: holds if at least one of the expressions hold +-- # Class: "type_expression_all_of" Description: "" +-- * Slot: type_expression_id Description: Autocreated FK slot +-- * Slot: all_of_id Description: holds if all of the expressions hold +-- # Class: "anonymous_type_expression_equals_string_in" Description: "" +-- * Slot: anonymous_type_expression_id Description: Autocreated FK slot +-- * Slot: equals_string_in Description: the slot must have range string and the value of the slot must equal one of the specified values +-- # Class: "anonymous_type_expression_none_of" Description: "" +-- * Slot: anonymous_type_expression_id Description: Autocreated FK slot +-- * Slot: none_of_id Description: holds if none of the expressions hold +-- # Class: "anonymous_type_expression_exactly_one_of" Description: "" +-- * Slot: anonymous_type_expression_id Description: Autocreated FK slot +-- * Slot: exactly_one_of_id Description: holds if only one of the expressions hold +-- # Class: "anonymous_type_expression_any_of" Description: "" +-- * Slot: anonymous_type_expression_id Description: Autocreated FK slot +-- * Slot: any_of_id Description: holds if at least one of the expressions hold +-- # Class: "anonymous_type_expression_all_of" Description: "" +-- * Slot: anonymous_type_expression_id Description: Autocreated FK slot +-- * Slot: all_of_id Description: holds if all of the expressions hold +-- # Class: "type_definition_equals_string_in" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: equals_string_in Description: the slot must have range string and the value of the slot must equal one of the specified values +-- # Class: "type_definition_none_of" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: none_of_id Description: holds if none of the expressions hold +-- # Class: "type_definition_exactly_one_of" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: exactly_one_of_id Description: holds if only one of the expressions hold +-- # Class: "type_definition_any_of" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: any_of_id Description: holds if at least one of the expressions hold +-- # Class: "type_definition_all_of" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: all_of_id Description: holds if all of the expressions hold +-- # Class: "type_definition_id_prefixes" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: id_prefixes Description: the identifier of this class or slot must begin with the URIs referenced by this prefix +-- # Class: "type_definition_todos" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "type_definition_notes" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "type_definition_comments" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "type_definition_in_subset" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "type_definition_see_also" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "type_definition_aliases" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "type_definition_mappings" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "type_definition_exact_mappings" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "type_definition_close_mappings" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "type_definition_related_mappings" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "type_definition_narrow_mappings" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "type_definition_broad_mappings" Description: "" +-- * Slot: type_definition_name Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "subset_definition_id_prefixes" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: id_prefixes Description: the identifier of this class or slot must begin with the URIs referenced by this prefix +-- # Class: "subset_definition_todos" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "subset_definition_notes" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "subset_definition_comments" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "subset_definition_in_subset" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "subset_definition_see_also" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "subset_definition_aliases" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "subset_definition_mappings" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "subset_definition_exact_mappings" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "subset_definition_close_mappings" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "subset_definition_related_mappings" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "subset_definition_narrow_mappings" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "subset_definition_broad_mappings" Description: "" +-- * Slot: subset_definition_name Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "definition_mixins" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: mixins Description: List of definitions to be mixed in. Targets may be any definition of the same type +-- # Class: "definition_apply_to" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: apply_to Description: Used to extend class or slot definitions. For example, if we have a core schema where a gene has two slots for identifier and symbol, and we have a specialized schema for my_organism where we wish to add a slot systematic_name, we can avoid subclassing by defining a class gene_my_organism, adding the slot to this class, and then adding an apply_to pointing to the gene class. The new slot will be 'injected into' the gene class. +-- # Class: "definition_values_from" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: values_from Description: the identifier of a "value set" -- a set of identifiers that form the possible values for the range of a slot +-- # Class: "definition_id_prefixes" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: id_prefixes Description: the identifier of this class or slot must begin with the URIs referenced by this prefix +-- # Class: "definition_todos" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "definition_notes" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "definition_comments" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "definition_in_subset" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "definition_see_also" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "definition_aliases" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "definition_mappings" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "definition_exact_mappings" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "definition_close_mappings" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "definition_related_mappings" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "definition_narrow_mappings" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "definition_broad_mappings" Description: "" +-- * Slot: definition_name Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "enum_definition_id_prefixes" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: id_prefixes Description: the identifier of this class or slot must begin with the URIs referenced by this prefix +-- # Class: "enum_definition_todos" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "enum_definition_notes" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "enum_definition_comments" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "enum_definition_in_subset" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "enum_definition_see_also" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "enum_definition_aliases" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "enum_definition_mappings" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "enum_definition_exact_mappings" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "enum_definition_close_mappings" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "enum_definition_related_mappings" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "enum_definition_narrow_mappings" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "enum_definition_broad_mappings" Description: "" +-- * Slot: enum_definition_name Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "structured_alias_category" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: category Description: The category or categories of an alias. This can be drawn from any relevant vocabulary +-- # Class: "structured_alias_todos" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "structured_alias_notes" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "structured_alias_comments" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "structured_alias_in_subset" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "structured_alias_see_also" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "structured_alias_aliases" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "structured_alias_mappings" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "structured_alias_exact_mappings" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "structured_alias_close_mappings" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "structured_alias_related_mappings" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "structured_alias_narrow_mappings" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "structured_alias_broad_mappings" Description: "" +-- * Slot: structured_alias_id Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "anonymous_expression_todos" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "anonymous_expression_notes" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "anonymous_expression_comments" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "anonymous_expression_in_subset" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "anonymous_expression_see_also" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "anonymous_expression_aliases" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "anonymous_expression_mappings" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "anonymous_expression_exact_mappings" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "anonymous_expression_close_mappings" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "anonymous_expression_related_mappings" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "anonymous_expression_narrow_mappings" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "anonymous_expression_broad_mappings" Description: "" +-- * Slot: anonymous_expression_id Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "path_expression_none_of" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: none_of_id Description: holds if none of the expressions hold +-- # Class: "path_expression_any_of" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: any_of_id Description: holds if at least one of the expressions hold +-- # Class: "path_expression_all_of" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: all_of_id Description: holds if all of the expressions hold +-- # Class: "path_expression_exactly_one_of" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: exactly_one_of_id Description: holds if only one of the expressions hold +-- # Class: "path_expression_todos" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "path_expression_notes" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "path_expression_comments" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "path_expression_in_subset" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "path_expression_see_also" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "path_expression_aliases" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "path_expression_mappings" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "path_expression_exact_mappings" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "path_expression_close_mappings" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "path_expression_related_mappings" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "path_expression_narrow_mappings" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "path_expression_broad_mappings" Description: "" +-- * Slot: path_expression_id Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "slot_expression_equals_string_in" Description: "" +-- * Slot: slot_expression_id Description: Autocreated FK slot +-- * Slot: equals_string_in Description: the slot must have range string and the value of the slot must equal one of the specified values +-- # Class: "slot_expression_none_of" Description: "" +-- * Slot: slot_expression_id Description: Autocreated FK slot +-- * Slot: none_of_id Description: holds if none of the expressions hold +-- # Class: "slot_expression_exactly_one_of" Description: "" +-- * Slot: slot_expression_id Description: Autocreated FK slot +-- * Slot: exactly_one_of_id Description: holds if only one of the expressions hold +-- # Class: "slot_expression_any_of" Description: "" +-- * Slot: slot_expression_id Description: Autocreated FK slot +-- * Slot: any_of_id Description: holds if at least one of the expressions hold +-- # Class: "slot_expression_all_of" Description: "" +-- * Slot: slot_expression_id Description: Autocreated FK slot +-- * Slot: all_of_id Description: holds if all of the expressions hold +-- # Class: "anonymous_slot_expression_equals_string_in" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: equals_string_in Description: the slot must have range string and the value of the slot must equal one of the specified values +-- # Class: "anonymous_slot_expression_none_of" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: none_of_id Description: holds if none of the expressions hold +-- # Class: "anonymous_slot_expression_exactly_one_of" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: exactly_one_of_id Description: holds if only one of the expressions hold +-- # Class: "anonymous_slot_expression_any_of" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: any_of_id Description: holds if at least one of the expressions hold +-- # Class: "anonymous_slot_expression_all_of" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: all_of_id Description: holds if all of the expressions hold +-- # Class: "anonymous_slot_expression_todos" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "anonymous_slot_expression_notes" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "anonymous_slot_expression_comments" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "anonymous_slot_expression_in_subset" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "anonymous_slot_expression_see_also" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "anonymous_slot_expression_aliases" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "anonymous_slot_expression_mappings" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "anonymous_slot_expression_exact_mappings" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "anonymous_slot_expression_close_mappings" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "anonymous_slot_expression_related_mappings" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "anonymous_slot_expression_narrow_mappings" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "anonymous_slot_expression_broad_mappings" Description: "" +-- * Slot: anonymous_slot_expression_id Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "slot_definition_domain_of" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: domain_of Description: the class(es) that reference the slot in a "slots" or "slot_usage" context +-- # Class: "slot_definition_disjoint_with" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: disjoint_with Description: Two classes are disjoint if they have no instances in common, two slots are disjoint if they can never hold between the same two instances +-- # Class: "slot_definition_equals_string_in" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: equals_string_in Description: the slot must have range string and the value of the slot must equal one of the specified values +-- # Class: "slot_definition_none_of" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: none_of_id Description: holds if none of the expressions hold +-- # Class: "slot_definition_exactly_one_of" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: exactly_one_of_id Description: holds if only one of the expressions hold +-- # Class: "slot_definition_any_of" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: any_of_id Description: holds if at least one of the expressions hold +-- # Class: "slot_definition_all_of" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: all_of_id Description: holds if all of the expressions hold +-- # Class: "slot_definition_mixins" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: mixins Description: List of definitions to be mixed in. Targets may be any definition of the same type +-- # Class: "slot_definition_apply_to" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: apply_to Description: Used to extend class or slot definitions. For example, if we have a core schema where a gene has two slots for identifier and symbol, and we have a specialized schema for my_organism where we wish to add a slot systematic_name, we can avoid subclassing by defining a class gene_my_organism, adding the slot to this class, and then adding an apply_to pointing to the gene class. The new slot will be 'injected into' the gene class. +-- # Class: "slot_definition_values_from" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: values_from Description: the identifier of a "value set" -- a set of identifiers that form the possible values for the range of a slot +-- # Class: "slot_definition_id_prefixes" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: id_prefixes Description: the identifier of this class or slot must begin with the URIs referenced by this prefix +-- # Class: "slot_definition_todos" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "slot_definition_notes" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "slot_definition_comments" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "slot_definition_in_subset" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "slot_definition_see_also" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "slot_definition_aliases" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "slot_definition_mappings" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "slot_definition_exact_mappings" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "slot_definition_close_mappings" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "slot_definition_related_mappings" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "slot_definition_narrow_mappings" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "slot_definition_broad_mappings" Description: "" +-- * Slot: slot_definition_name Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "class_expression_any_of" Description: "" +-- * Slot: class_expression_id Description: Autocreated FK slot +-- * Slot: any_of_id Description: holds if at least one of the expressions hold +-- # Class: "class_expression_exactly_one_of" Description: "" +-- * Slot: class_expression_id Description: Autocreated FK slot +-- * Slot: exactly_one_of_id Description: holds if only one of the expressions hold +-- # Class: "class_expression_none_of" Description: "" +-- * Slot: class_expression_id Description: Autocreated FK slot +-- * Slot: none_of_id Description: holds if none of the expressions hold +-- # Class: "class_expression_all_of" Description: "" +-- * Slot: class_expression_id Description: Autocreated FK slot +-- * Slot: all_of_id Description: holds if all of the expressions hold +-- # Class: "anonymous_class_expression_any_of" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: any_of_id Description: holds if at least one of the expressions hold +-- # Class: "anonymous_class_expression_exactly_one_of" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: exactly_one_of_id Description: holds if only one of the expressions hold +-- # Class: "anonymous_class_expression_none_of" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: none_of_id Description: holds if none of the expressions hold +-- # Class: "anonymous_class_expression_all_of" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: all_of_id Description: holds if all of the expressions hold +-- # Class: "anonymous_class_expression_todos" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "anonymous_class_expression_notes" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "anonymous_class_expression_comments" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "anonymous_class_expression_in_subset" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "anonymous_class_expression_see_also" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "anonymous_class_expression_aliases" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "anonymous_class_expression_mappings" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "anonymous_class_expression_exact_mappings" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "anonymous_class_expression_close_mappings" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "anonymous_class_expression_related_mappings" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "anonymous_class_expression_narrow_mappings" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "anonymous_class_expression_broad_mappings" Description: "" +-- * Slot: anonymous_class_expression_id Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "class_definition_slots" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: slots Description: list of slot names that are applicable to a class +-- # Class: "class_definition_union_of" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: union_of Description: indicates that the domain class consists exactly of the members of the classes in the range +-- # Class: "class_definition_defining_slots" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: defining_slots Description: The combination of is a plus defining slots form a genus-differentia definition, or the set of necessary and sufficient conditions that can be transformed into an OWL equivalence axiom +-- # Class: "class_definition_disjoint_with" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: disjoint_with Description: Two classes are disjoint if they have no instances in common, two slots are disjoint if they can never hold between the same two instances +-- # Class: "class_definition_any_of" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: any_of_id Description: holds if at least one of the expressions hold +-- # Class: "class_definition_exactly_one_of" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: exactly_one_of_id Description: holds if only one of the expressions hold +-- # Class: "class_definition_none_of" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: none_of_id Description: holds if none of the expressions hold +-- # Class: "class_definition_all_of" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: all_of_id Description: holds if all of the expressions hold +-- # Class: "class_definition_mixins" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: mixins Description: List of definitions to be mixed in. Targets may be any definition of the same type +-- # Class: "class_definition_apply_to" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: apply_to Description: Used to extend class or slot definitions. For example, if we have a core schema where a gene has two slots for identifier and symbol, and we have a specialized schema for my_organism where we wish to add a slot systematic_name, we can avoid subclassing by defining a class gene_my_organism, adding the slot to this class, and then adding an apply_to pointing to the gene class. The new slot will be 'injected into' the gene class. +-- # Class: "class_definition_values_from" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: values_from Description: the identifier of a "value set" -- a set of identifiers that form the possible values for the range of a slot +-- # Class: "class_definition_id_prefixes" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: id_prefixes Description: the identifier of this class or slot must begin with the URIs referenced by this prefix +-- # Class: "class_definition_todos" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "class_definition_notes" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "class_definition_comments" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "class_definition_in_subset" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "class_definition_see_also" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "class_definition_aliases" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "class_definition_mappings" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "class_definition_exact_mappings" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "class_definition_close_mappings" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "class_definition_related_mappings" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "class_definition_narrow_mappings" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "class_definition_broad_mappings" Description: "" +-- * Slot: class_definition_name Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "class_rule_todos" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "class_rule_notes" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "class_rule_comments" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "class_rule_in_subset" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "class_rule_see_also" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "class_rule_aliases" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "class_rule_mappings" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "class_rule_exact_mappings" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "class_rule_close_mappings" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "class_rule_related_mappings" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "class_rule_narrow_mappings" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "class_rule_broad_mappings" Description: "" +-- * Slot: class_rule_id Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "pattern_expression_todos" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "pattern_expression_notes" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "pattern_expression_comments" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "pattern_expression_in_subset" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "pattern_expression_see_also" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "pattern_expression_aliases" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "pattern_expression_mappings" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "pattern_expression_exact_mappings" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "pattern_expression_close_mappings" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "pattern_expression_related_mappings" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "pattern_expression_narrow_mappings" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "pattern_expression_broad_mappings" Description: "" +-- * Slot: pattern_expression_id Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "import_expression_todos" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "import_expression_notes" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "import_expression_comments" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "import_expression_in_subset" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "import_expression_see_also" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "import_expression_aliases" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "import_expression_mappings" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "import_expression_exact_mappings" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "import_expression_close_mappings" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "import_expression_related_mappings" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "import_expression_narrow_mappings" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "import_expression_broad_mappings" Description: "" +-- * Slot: import_expression_id Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "permissible_value_todos" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "permissible_value_notes" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "permissible_value_comments" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "permissible_value_in_subset" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "permissible_value_see_also" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "permissible_value_aliases" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "permissible_value_mappings" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "permissible_value_exact_mappings" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "permissible_value_close_mappings" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "permissible_value_related_mappings" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "permissible_value_narrow_mappings" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "permissible_value_broad_mappings" Description: "" +-- * Slot: permissible_value_text Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. +-- # Class: "unique_key_unique_key_slots" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: unique_key_slots Description: list of slot names that form a key +-- # Class: "unique_key_todos" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: todos Description: Outstanding issue that needs resolution +-- # Class: "unique_key_notes" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: notes Description: editorial notes about an element intended for internal consumption +-- # Class: "unique_key_comments" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: comments Description: notes and comments about an element intended for external consumption +-- # Class: "unique_key_in_subset" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: in_subset Description: used to indicate membership of a term in a defined subset of terms used for a particular domain or application (e.g. the translator_minimal subset holding the minimal set of predicates used in a translator knowledge graph) +-- # Class: "unique_key_see_also" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: see_also Description: a reference +-- # Class: "unique_key_aliases" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: aliases Description: +-- # Class: "unique_key_mappings" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: mappings Description: A list of terms from different schemas or terminology systems that have comparable meaning. These may include terms that are precisely equivalent, broader or narrower in meaning, or otherwise semantically related but not equivalent from a strict ontological perspective. +-- # Class: "unique_key_exact_mappings" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: exact_mappings Description: A list of terms from different schemas or terminology systems that have identical meaning. +-- # Class: "unique_key_close_mappings" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: close_mappings Description: A list of terms from different schemas or terminology systems that have close meaning. +-- # Class: "unique_key_related_mappings" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: related_mappings Description: A list of terms from different schemas or terminology systems that have related meaning. +-- # Class: "unique_key_narrow_mappings" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: narrow_mappings Description: A list of terms from different schemas or terminology systems that have narrower meaning. +-- # Class: "unique_key_broad_mappings" Description: "" +-- * Slot: unique_key_unique_key_name Description: Autocreated FK slot +-- * Slot: broad_mappings Description: A list of terms from different schemas or terminology systems that have broader meaning. + +CREATE TABLE common_metadata ( + id INTEGER, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + PRIMARY KEY (id) +); +CREATE TABLE element ( + name TEXT, + definition_uri TEXT, + conforms_to TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + PRIMARY KEY (name) +); +CREATE TABLE schema_definition ( + id TEXT NOT NULL, + version TEXT, + license TEXT, + default_prefix TEXT, + default_range TEXT, + metamodel_version TEXT, + source_file TEXT, + source_file_date DATETIME, + source_file_size INTEGER, + generation_date DATETIME, + slot_names_unique BOOLEAN, + name TEXT, + definition_uri TEXT, + conforms_to TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + PRIMARY KEY (id), + FOREIGN KEY(default_range) REFERENCES type_definition (name) +); +CREATE TABLE type_definition ( + typeof TEXT, + base TEXT, + uri TEXT, + repr TEXT, + pattern TEXT, + equals_string TEXT, + equals_number INTEGER, + minimum_value INTEGER, + maximum_value INTEGER, + name TEXT, + definition_uri TEXT, + conforms_to TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + schema_definition_name TEXT, + structured_pattern_id TEXT, + PRIMARY KEY (name), + FOREIGN KEY(typeof) REFERENCES type_definition (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id), + FOREIGN KEY(structured_pattern_id) REFERENCES pattern_expression (id) +); +CREATE TABLE definition ( + is_a TEXT, + abstract BOOLEAN, + mixin BOOLEAN, + created_by TEXT, + created_on DATETIME, + last_updated_on DATETIME, + modified_by TEXT, + status TEXT, + string_serialization TEXT, + name TEXT, + definition_uri TEXT, + conforms_to TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + PRIMARY KEY (name), + FOREIGN KEY(is_a) REFERENCES definition (name) +); +CREATE TABLE expression ( + id INTEGER, + PRIMARY KEY (id) +); +CREATE TABLE anonymous_expression ( + id INTEGER, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + PRIMARY KEY (id) +); +CREATE TABLE path_expression ( + id INTEGER, + reversed BOOLEAN, + traverse TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + followed_by_id TEXT, + range_expression_id TEXT, + PRIMARY KEY (id), + FOREIGN KEY(traverse) REFERENCES slot_definition (name), + FOREIGN KEY(followed_by_id) REFERENCES path_expression (id), + FOREIGN KEY(range_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE slot_definition ( + singular_name TEXT, + domain TEXT, + slot_uri TEXT, + multivalued BOOLEAN, + inherited BOOLEAN, + readonly TEXT, + ifabsent TEXT, + list_elements_unique BOOLEAN, + list_elements_ordered BOOLEAN, + shared BOOLEAN, + "key" BOOLEAN, + identifier BOOLEAN, + designates_type BOOLEAN, + alias TEXT, + owner TEXT, + subproperty_of TEXT, + symmetric BOOLEAN, + reflexive BOOLEAN, + locally_reflexive BOOLEAN, + irreflexive BOOLEAN, + asymmetric BOOLEAN, + transitive BOOLEAN, + inverse TEXT, + is_class_field BOOLEAN, + transitive_form_of TEXT, + reflexive_transitive_form_of TEXT, + role TEXT, + is_usage_slot BOOLEAN, + usage_slot_name TEXT, + relational_role VARCHAR(10), + slot_group TEXT, + is_grouping_slot BOOLEAN, + children_are_mutually_disjoint BOOLEAN, + range TEXT, + required BOOLEAN, + recommended BOOLEAN, + inlined BOOLEAN, + inlined_as_list BOOLEAN, + minimum_value INTEGER, + maximum_value INTEGER, + pattern TEXT, + implicit_prefix TEXT, + equals_string TEXT, + equals_number INTEGER, + equals_expression TEXT, + minimum_cardinality INTEGER, + maximum_cardinality INTEGER, + is_a TEXT, + abstract BOOLEAN, + mixin BOOLEAN, + created_by TEXT, + created_on DATETIME, + last_updated_on DATETIME, + modified_by TEXT, + status TEXT, + string_serialization TEXT, + name TEXT, + definition_uri TEXT, + conforms_to TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + schema_definition_name TEXT, + slot_expression_id TEXT, + anonymous_slot_expression_id TEXT, + slot_definition_name TEXT, + class_expression_id TEXT, + anonymous_class_expression_id TEXT, + class_definition_name TEXT, + path_rule_id TEXT, + range_expression_id TEXT, + structured_pattern_id TEXT, + has_member_id TEXT, + PRIMARY KEY (name), + FOREIGN KEY(domain) REFERENCES class_definition (name), + FOREIGN KEY(owner) REFERENCES definition (name), + FOREIGN KEY(subproperty_of) REFERENCES slot_definition (name), + FOREIGN KEY(inverse) REFERENCES slot_definition (name), + FOREIGN KEY(transitive_form_of) REFERENCES slot_definition (name), + FOREIGN KEY(reflexive_transitive_form_of) REFERENCES slot_definition (name), + FOREIGN KEY(slot_group) REFERENCES slot_definition (name), + FOREIGN KEY(range) REFERENCES element (name), + FOREIGN KEY(is_a) REFERENCES slot_definition (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id), + FOREIGN KEY(slot_expression_id) REFERENCES slot_expression (id), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(class_expression_id) REFERENCES class_expression (id), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(path_rule_id) REFERENCES path_expression (id), + FOREIGN KEY(range_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(structured_pattern_id) REFERENCES pattern_expression (id), + FOREIGN KEY(has_member_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE class_expression ( + id INTEGER, + PRIMARY KEY (id) +); +CREATE TABLE class_level_rule ( + id INTEGER, + PRIMARY KEY (id) +); +CREATE TABLE pattern_expression ( + id INTEGER, + syntax TEXT, + interpolated BOOLEAN, + partial_match BOOLEAN, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + PRIMARY KEY (id) +); +CREATE TABLE import_expression ( + id INTEGER, + import_from TEXT NOT NULL, + import_as TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + PRIMARY KEY (id) +); +CREATE TABLE annotatable ( + id INTEGER, + PRIMARY KEY (id) +); +CREATE TABLE extensible ( + id INTEGER, + PRIMARY KEY (id) +); +CREATE TABLE type_expression ( + id INTEGER, + pattern TEXT, + equals_string TEXT, + equals_number INTEGER, + minimum_value INTEGER, + maximum_value INTEGER, + structured_pattern_id TEXT, + PRIMARY KEY (id), + FOREIGN KEY(structured_pattern_id) REFERENCES pattern_expression (id) +); +CREATE TABLE anonymous_type_expression ( + id INTEGER, + pattern TEXT, + equals_string TEXT, + equals_number INTEGER, + minimum_value INTEGER, + maximum_value INTEGER, + structured_pattern_id TEXT, + PRIMARY KEY (id), + FOREIGN KEY(structured_pattern_id) REFERENCES pattern_expression (id) +); +CREATE TABLE subset_definition ( + name TEXT, + definition_uri TEXT, + conforms_to TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + schema_definition_name TEXT, + PRIMARY KEY (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE enum_definition ( + code_set TEXT, + code_set_tag TEXT, + code_set_version TEXT, + pv_formula VARCHAR(11), + name TEXT, + definition_uri TEXT, + conforms_to TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + schema_definition_name TEXT, + PRIMARY KEY (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE class_definition ( + class_uri TEXT, + subclass_of TEXT, + tree_root BOOLEAN, + slot_names_unique BOOLEAN, + represents_relationship BOOLEAN, + children_are_mutually_disjoint BOOLEAN, + is_a TEXT, + abstract BOOLEAN, + mixin BOOLEAN, + created_by TEXT, + created_on DATETIME, + last_updated_on DATETIME, + modified_by TEXT, + status TEXT, + string_serialization TEXT, + name TEXT, + definition_uri TEXT, + conforms_to TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + schema_definition_name TEXT, + PRIMARY KEY (name), + FOREIGN KEY(is_a) REFERENCES class_definition (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE setting ( + setting_key TEXT, + setting_value TEXT NOT NULL, + schema_definition_name TEXT, + import_expression_id TEXT, + PRIMARY KEY (setting_key, setting_value, schema_definition_name, import_expression_id), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE prefix ( + prefix_prefix TEXT, + prefix_reference TEXT NOT NULL, + schema_definition_name TEXT, + PRIMARY KEY (prefix_prefix, prefix_reference, schema_definition_name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE common_metadata_todos ( + common_metadata_id TEXT, + todos TEXT, + PRIMARY KEY (common_metadata_id, todos), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE common_metadata_notes ( + common_metadata_id TEXT, + notes TEXT, + PRIMARY KEY (common_metadata_id, notes), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE common_metadata_comments ( + common_metadata_id TEXT, + comments TEXT, + PRIMARY KEY (common_metadata_id, comments), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE common_metadata_see_also ( + common_metadata_id TEXT, + see_also TEXT, + PRIMARY KEY (common_metadata_id, see_also), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE common_metadata_aliases ( + common_metadata_id TEXT, + aliases TEXT, + PRIMARY KEY (common_metadata_id, aliases), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE common_metadata_mappings ( + common_metadata_id TEXT, + mappings TEXT, + PRIMARY KEY (common_metadata_id, mappings), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE common_metadata_exact_mappings ( + common_metadata_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (common_metadata_id, exact_mappings), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE common_metadata_close_mappings ( + common_metadata_id TEXT, + close_mappings TEXT, + PRIMARY KEY (common_metadata_id, close_mappings), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE common_metadata_related_mappings ( + common_metadata_id TEXT, + related_mappings TEXT, + PRIMARY KEY (common_metadata_id, related_mappings), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE common_metadata_narrow_mappings ( + common_metadata_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (common_metadata_id, narrow_mappings), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE common_metadata_broad_mappings ( + common_metadata_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (common_metadata_id, broad_mappings), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id) +); +CREATE TABLE element_id_prefixes ( + element_name TEXT, + id_prefixes TEXT, + PRIMARY KEY (element_name, id_prefixes), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_todos ( + element_name TEXT, + todos TEXT, + PRIMARY KEY (element_name, todos), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_notes ( + element_name TEXT, + notes TEXT, + PRIMARY KEY (element_name, notes), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_comments ( + element_name TEXT, + comments TEXT, + PRIMARY KEY (element_name, comments), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_see_also ( + element_name TEXT, + see_also TEXT, + PRIMARY KEY (element_name, see_also), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_aliases ( + element_name TEXT, + aliases TEXT, + PRIMARY KEY (element_name, aliases), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_mappings ( + element_name TEXT, + mappings TEXT, + PRIMARY KEY (element_name, mappings), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_exact_mappings ( + element_name TEXT, + exact_mappings TEXT, + PRIMARY KEY (element_name, exact_mappings), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_close_mappings ( + element_name TEXT, + close_mappings TEXT, + PRIMARY KEY (element_name, close_mappings), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_related_mappings ( + element_name TEXT, + related_mappings TEXT, + PRIMARY KEY (element_name, related_mappings), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_narrow_mappings ( + element_name TEXT, + narrow_mappings TEXT, + PRIMARY KEY (element_name, narrow_mappings), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE element_broad_mappings ( + element_name TEXT, + broad_mappings TEXT, + PRIMARY KEY (element_name, broad_mappings), + FOREIGN KEY(element_name) REFERENCES element (name) +); +CREATE TABLE schema_definition_imports ( + schema_definition_name TEXT, + imports TEXT, + PRIMARY KEY (schema_definition_name, imports), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_emit_prefixes ( + schema_definition_name TEXT, + emit_prefixes TEXT, + PRIMARY KEY (schema_definition_name, emit_prefixes), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_default_curi_maps ( + schema_definition_name TEXT, + default_curi_maps TEXT, + PRIMARY KEY (schema_definition_name, default_curi_maps), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_category ( + schema_definition_name TEXT, + category TEXT, + PRIMARY KEY (schema_definition_name, category), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_keyword ( + schema_definition_name TEXT, + keyword TEXT, + PRIMARY KEY (schema_definition_name, keyword), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_id_prefixes ( + schema_definition_name TEXT, + id_prefixes TEXT, + PRIMARY KEY (schema_definition_name, id_prefixes), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_todos ( + schema_definition_name TEXT, + todos TEXT, + PRIMARY KEY (schema_definition_name, todos), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_notes ( + schema_definition_name TEXT, + notes TEXT, + PRIMARY KEY (schema_definition_name, notes), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_comments ( + schema_definition_name TEXT, + comments TEXT, + PRIMARY KEY (schema_definition_name, comments), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_see_also ( + schema_definition_name TEXT, + see_also TEXT, + PRIMARY KEY (schema_definition_name, see_also), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_aliases ( + schema_definition_name TEXT, + aliases TEXT, + PRIMARY KEY (schema_definition_name, aliases), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_mappings ( + schema_definition_name TEXT, + mappings TEXT, + PRIMARY KEY (schema_definition_name, mappings), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_exact_mappings ( + schema_definition_name TEXT, + exact_mappings TEXT, + PRIMARY KEY (schema_definition_name, exact_mappings), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_close_mappings ( + schema_definition_name TEXT, + close_mappings TEXT, + PRIMARY KEY (schema_definition_name, close_mappings), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_related_mappings ( + schema_definition_name TEXT, + related_mappings TEXT, + PRIMARY KEY (schema_definition_name, related_mappings), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_narrow_mappings ( + schema_definition_name TEXT, + narrow_mappings TEXT, + PRIMARY KEY (schema_definition_name, narrow_mappings), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE schema_definition_broad_mappings ( + schema_definition_name TEXT, + broad_mappings TEXT, + PRIMARY KEY (schema_definition_name, broad_mappings), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id) +); +CREATE TABLE type_definition_equals_string_in ( + type_definition_name TEXT, + equals_string_in TEXT, + PRIMARY KEY (type_definition_name, equals_string_in), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_id_prefixes ( + type_definition_name TEXT, + id_prefixes TEXT, + PRIMARY KEY (type_definition_name, id_prefixes), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_todos ( + type_definition_name TEXT, + todos TEXT, + PRIMARY KEY (type_definition_name, todos), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_notes ( + type_definition_name TEXT, + notes TEXT, + PRIMARY KEY (type_definition_name, notes), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_comments ( + type_definition_name TEXT, + comments TEXT, + PRIMARY KEY (type_definition_name, comments), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_see_also ( + type_definition_name TEXT, + see_also TEXT, + PRIMARY KEY (type_definition_name, see_also), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_aliases ( + type_definition_name TEXT, + aliases TEXT, + PRIMARY KEY (type_definition_name, aliases), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_mappings ( + type_definition_name TEXT, + mappings TEXT, + PRIMARY KEY (type_definition_name, mappings), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_exact_mappings ( + type_definition_name TEXT, + exact_mappings TEXT, + PRIMARY KEY (type_definition_name, exact_mappings), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_close_mappings ( + type_definition_name TEXT, + close_mappings TEXT, + PRIMARY KEY (type_definition_name, close_mappings), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_related_mappings ( + type_definition_name TEXT, + related_mappings TEXT, + PRIMARY KEY (type_definition_name, related_mappings), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_narrow_mappings ( + type_definition_name TEXT, + narrow_mappings TEXT, + PRIMARY KEY (type_definition_name, narrow_mappings), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE type_definition_broad_mappings ( + type_definition_name TEXT, + broad_mappings TEXT, + PRIMARY KEY (type_definition_name, broad_mappings), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name) +); +CREATE TABLE definition_mixins ( + definition_name TEXT, + mixins TEXT, + PRIMARY KEY (definition_name, mixins), + FOREIGN KEY(definition_name) REFERENCES definition (name), + FOREIGN KEY(mixins) REFERENCES definition (name) +); +CREATE TABLE definition_apply_to ( + definition_name TEXT, + apply_to TEXT, + PRIMARY KEY (definition_name, apply_to), + FOREIGN KEY(definition_name) REFERENCES definition (name), + FOREIGN KEY(apply_to) REFERENCES definition (name) +); +CREATE TABLE definition_values_from ( + definition_name TEXT, + values_from TEXT, + PRIMARY KEY (definition_name, values_from), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_id_prefixes ( + definition_name TEXT, + id_prefixes TEXT, + PRIMARY KEY (definition_name, id_prefixes), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_todos ( + definition_name TEXT, + todos TEXT, + PRIMARY KEY (definition_name, todos), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_notes ( + definition_name TEXT, + notes TEXT, + PRIMARY KEY (definition_name, notes), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_comments ( + definition_name TEXT, + comments TEXT, + PRIMARY KEY (definition_name, comments), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_see_also ( + definition_name TEXT, + see_also TEXT, + PRIMARY KEY (definition_name, see_also), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_aliases ( + definition_name TEXT, + aliases TEXT, + PRIMARY KEY (definition_name, aliases), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_mappings ( + definition_name TEXT, + mappings TEXT, + PRIMARY KEY (definition_name, mappings), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_exact_mappings ( + definition_name TEXT, + exact_mappings TEXT, + PRIMARY KEY (definition_name, exact_mappings), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_close_mappings ( + definition_name TEXT, + close_mappings TEXT, + PRIMARY KEY (definition_name, close_mappings), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_related_mappings ( + definition_name TEXT, + related_mappings TEXT, + PRIMARY KEY (definition_name, related_mappings), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_narrow_mappings ( + definition_name TEXT, + narrow_mappings TEXT, + PRIMARY KEY (definition_name, narrow_mappings), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE definition_broad_mappings ( + definition_name TEXT, + broad_mappings TEXT, + PRIMARY KEY (definition_name, broad_mappings), + FOREIGN KEY(definition_name) REFERENCES definition (name) +); +CREATE TABLE anonymous_expression_todos ( + anonymous_expression_id TEXT, + todos TEXT, + PRIMARY KEY (anonymous_expression_id, todos), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE anonymous_expression_notes ( + anonymous_expression_id TEXT, + notes TEXT, + PRIMARY KEY (anonymous_expression_id, notes), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE anonymous_expression_comments ( + anonymous_expression_id TEXT, + comments TEXT, + PRIMARY KEY (anonymous_expression_id, comments), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE anonymous_expression_see_also ( + anonymous_expression_id TEXT, + see_also TEXT, + PRIMARY KEY (anonymous_expression_id, see_also), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE anonymous_expression_aliases ( + anonymous_expression_id TEXT, + aliases TEXT, + PRIMARY KEY (anonymous_expression_id, aliases), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE anonymous_expression_mappings ( + anonymous_expression_id TEXT, + mappings TEXT, + PRIMARY KEY (anonymous_expression_id, mappings), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE anonymous_expression_exact_mappings ( + anonymous_expression_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (anonymous_expression_id, exact_mappings), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE anonymous_expression_close_mappings ( + anonymous_expression_id TEXT, + close_mappings TEXT, + PRIMARY KEY (anonymous_expression_id, close_mappings), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE anonymous_expression_related_mappings ( + anonymous_expression_id TEXT, + related_mappings TEXT, + PRIMARY KEY (anonymous_expression_id, related_mappings), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE anonymous_expression_narrow_mappings ( + anonymous_expression_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (anonymous_expression_id, narrow_mappings), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE anonymous_expression_broad_mappings ( + anonymous_expression_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (anonymous_expression_id, broad_mappings), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id) +); +CREATE TABLE path_expression_none_of ( + path_expression_id TEXT, + none_of_id TEXT, + PRIMARY KEY (path_expression_id, none_of_id), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id), + FOREIGN KEY(none_of_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_any_of ( + path_expression_id TEXT, + any_of_id TEXT, + PRIMARY KEY (path_expression_id, any_of_id), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id), + FOREIGN KEY(any_of_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_all_of ( + path_expression_id TEXT, + all_of_id TEXT, + PRIMARY KEY (path_expression_id, all_of_id), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id), + FOREIGN KEY(all_of_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_exactly_one_of ( + path_expression_id TEXT, + exactly_one_of_id TEXT, + PRIMARY KEY (path_expression_id, exactly_one_of_id), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id), + FOREIGN KEY(exactly_one_of_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_todos ( + path_expression_id TEXT, + todos TEXT, + PRIMARY KEY (path_expression_id, todos), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_notes ( + path_expression_id TEXT, + notes TEXT, + PRIMARY KEY (path_expression_id, notes), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_comments ( + path_expression_id TEXT, + comments TEXT, + PRIMARY KEY (path_expression_id, comments), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_see_also ( + path_expression_id TEXT, + see_also TEXT, + PRIMARY KEY (path_expression_id, see_also), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_aliases ( + path_expression_id TEXT, + aliases TEXT, + PRIMARY KEY (path_expression_id, aliases), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_mappings ( + path_expression_id TEXT, + mappings TEXT, + PRIMARY KEY (path_expression_id, mappings), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_exact_mappings ( + path_expression_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (path_expression_id, exact_mappings), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_close_mappings ( + path_expression_id TEXT, + close_mappings TEXT, + PRIMARY KEY (path_expression_id, close_mappings), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_related_mappings ( + path_expression_id TEXT, + related_mappings TEXT, + PRIMARY KEY (path_expression_id, related_mappings), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_narrow_mappings ( + path_expression_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (path_expression_id, narrow_mappings), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE path_expression_broad_mappings ( + path_expression_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (path_expression_id, broad_mappings), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id) +); +CREATE TABLE slot_definition_disjoint_with ( + slot_definition_name TEXT, + disjoint_with TEXT, + PRIMARY KEY (slot_definition_name, disjoint_with), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(disjoint_with) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_equals_string_in ( + slot_definition_name TEXT, + equals_string_in TEXT, + PRIMARY KEY (slot_definition_name, equals_string_in), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_mixins ( + slot_definition_name TEXT, + mixins TEXT, + PRIMARY KEY (slot_definition_name, mixins), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(mixins) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_apply_to ( + slot_definition_name TEXT, + apply_to TEXT, + PRIMARY KEY (slot_definition_name, apply_to), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(apply_to) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_values_from ( + slot_definition_name TEXT, + values_from TEXT, + PRIMARY KEY (slot_definition_name, values_from), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_id_prefixes ( + slot_definition_name TEXT, + id_prefixes TEXT, + PRIMARY KEY (slot_definition_name, id_prefixes), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_todos ( + slot_definition_name TEXT, + todos TEXT, + PRIMARY KEY (slot_definition_name, todos), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_notes ( + slot_definition_name TEXT, + notes TEXT, + PRIMARY KEY (slot_definition_name, notes), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_comments ( + slot_definition_name TEXT, + comments TEXT, + PRIMARY KEY (slot_definition_name, comments), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_see_also ( + slot_definition_name TEXT, + see_also TEXT, + PRIMARY KEY (slot_definition_name, see_also), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_aliases ( + slot_definition_name TEXT, + aliases TEXT, + PRIMARY KEY (slot_definition_name, aliases), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_mappings ( + slot_definition_name TEXT, + mappings TEXT, + PRIMARY KEY (slot_definition_name, mappings), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_exact_mappings ( + slot_definition_name TEXT, + exact_mappings TEXT, + PRIMARY KEY (slot_definition_name, exact_mappings), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_close_mappings ( + slot_definition_name TEXT, + close_mappings TEXT, + PRIMARY KEY (slot_definition_name, close_mappings), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_related_mappings ( + slot_definition_name TEXT, + related_mappings TEXT, + PRIMARY KEY (slot_definition_name, related_mappings), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_narrow_mappings ( + slot_definition_name TEXT, + narrow_mappings TEXT, + PRIMARY KEY (slot_definition_name, narrow_mappings), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE slot_definition_broad_mappings ( + slot_definition_name TEXT, + broad_mappings TEXT, + PRIMARY KEY (slot_definition_name, broad_mappings), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name) +); +CREATE TABLE pattern_expression_todos ( + pattern_expression_id TEXT, + todos TEXT, + PRIMARY KEY (pattern_expression_id, todos), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE pattern_expression_notes ( + pattern_expression_id TEXT, + notes TEXT, + PRIMARY KEY (pattern_expression_id, notes), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE pattern_expression_comments ( + pattern_expression_id TEXT, + comments TEXT, + PRIMARY KEY (pattern_expression_id, comments), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE pattern_expression_see_also ( + pattern_expression_id TEXT, + see_also TEXT, + PRIMARY KEY (pattern_expression_id, see_also), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE pattern_expression_aliases ( + pattern_expression_id TEXT, + aliases TEXT, + PRIMARY KEY (pattern_expression_id, aliases), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE pattern_expression_mappings ( + pattern_expression_id TEXT, + mappings TEXT, + PRIMARY KEY (pattern_expression_id, mappings), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE pattern_expression_exact_mappings ( + pattern_expression_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (pattern_expression_id, exact_mappings), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE pattern_expression_close_mappings ( + pattern_expression_id TEXT, + close_mappings TEXT, + PRIMARY KEY (pattern_expression_id, close_mappings), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE pattern_expression_related_mappings ( + pattern_expression_id TEXT, + related_mappings TEXT, + PRIMARY KEY (pattern_expression_id, related_mappings), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE pattern_expression_narrow_mappings ( + pattern_expression_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (pattern_expression_id, narrow_mappings), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE pattern_expression_broad_mappings ( + pattern_expression_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (pattern_expression_id, broad_mappings), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id) +); +CREATE TABLE import_expression_todos ( + import_expression_id TEXT, + todos TEXT, + PRIMARY KEY (import_expression_id, todos), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE import_expression_notes ( + import_expression_id TEXT, + notes TEXT, + PRIMARY KEY (import_expression_id, notes), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE import_expression_comments ( + import_expression_id TEXT, + comments TEXT, + PRIMARY KEY (import_expression_id, comments), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE import_expression_see_also ( + import_expression_id TEXT, + see_also TEXT, + PRIMARY KEY (import_expression_id, see_also), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE import_expression_aliases ( + import_expression_id TEXT, + aliases TEXT, + PRIMARY KEY (import_expression_id, aliases), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE import_expression_mappings ( + import_expression_id TEXT, + mappings TEXT, + PRIMARY KEY (import_expression_id, mappings), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE import_expression_exact_mappings ( + import_expression_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (import_expression_id, exact_mappings), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE import_expression_close_mappings ( + import_expression_id TEXT, + close_mappings TEXT, + PRIMARY KEY (import_expression_id, close_mappings), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE import_expression_related_mappings ( + import_expression_id TEXT, + related_mappings TEXT, + PRIMARY KEY (import_expression_id, related_mappings), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE import_expression_narrow_mappings ( + import_expression_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (import_expression_id, narrow_mappings), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE import_expression_broad_mappings ( + import_expression_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (import_expression_id, broad_mappings), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id) +); +CREATE TABLE anonymous_class_expression ( + id INTEGER, + is_a TEXT, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + class_definition_name TEXT, + PRIMARY KEY (id), + FOREIGN KEY(is_a) REFERENCES definition (name), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE local_name ( + local_name_source TEXT, + local_name_value TEXT NOT NULL, + element_name TEXT, + schema_definition_name TEXT, + type_definition_name TEXT, + subset_definition_name TEXT, + definition_name TEXT, + enum_definition_name TEXT, + slot_definition_name TEXT, + class_definition_name TEXT, + PRIMARY KEY (local_name_source, local_name_value, element_name, schema_definition_name, type_definition_name, subset_definition_name, definition_name, enum_definition_name, slot_definition_name, class_definition_name), + FOREIGN KEY(element_name) REFERENCES element (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name), + FOREIGN KEY(definition_name) REFERENCES definition (name), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE permissible_value ( + text TEXT, + description TEXT, + meaning TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + enum_definition_name TEXT, + PRIMARY KEY (text), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE unique_key ( + unique_key_name TEXT NOT NULL, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + class_definition_name TEXT, + PRIMARY KEY (unique_key_name, description, title, deprecated, from_schema, imported_from, source, in_language, deprecated_element_has_exact_replacement, deprecated_element_has_possible_replacement, rank, class_definition_name), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE common_metadata_in_subset ( + common_metadata_id TEXT, + in_subset TEXT, + PRIMARY KEY (common_metadata_id, in_subset), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE element_in_subset ( + element_name TEXT, + in_subset TEXT, + PRIMARY KEY (element_name, in_subset), + FOREIGN KEY(element_name) REFERENCES element (name), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE schema_definition_in_subset ( + schema_definition_name TEXT, + in_subset TEXT, + PRIMARY KEY (schema_definition_name, in_subset), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE type_expression_equals_string_in ( + type_expression_id TEXT, + equals_string_in TEXT, + PRIMARY KEY (type_expression_id, equals_string_in), + FOREIGN KEY(type_expression_id) REFERENCES type_expression (id) +); +CREATE TABLE type_expression_none_of ( + type_expression_id TEXT, + none_of_id TEXT, + PRIMARY KEY (type_expression_id, none_of_id), + FOREIGN KEY(type_expression_id) REFERENCES type_expression (id), + FOREIGN KEY(none_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE type_expression_exactly_one_of ( + type_expression_id TEXT, + exactly_one_of_id TEXT, + PRIMARY KEY (type_expression_id, exactly_one_of_id), + FOREIGN KEY(type_expression_id) REFERENCES type_expression (id), + FOREIGN KEY(exactly_one_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE type_expression_any_of ( + type_expression_id TEXT, + any_of_id TEXT, + PRIMARY KEY (type_expression_id, any_of_id), + FOREIGN KEY(type_expression_id) REFERENCES type_expression (id), + FOREIGN KEY(any_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE type_expression_all_of ( + type_expression_id TEXT, + all_of_id TEXT, + PRIMARY KEY (type_expression_id, all_of_id), + FOREIGN KEY(type_expression_id) REFERENCES type_expression (id), + FOREIGN KEY(all_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE anonymous_type_expression_equals_string_in ( + anonymous_type_expression_id TEXT, + equals_string_in TEXT, + PRIMARY KEY (anonymous_type_expression_id, equals_string_in), + FOREIGN KEY(anonymous_type_expression_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE anonymous_type_expression_none_of ( + anonymous_type_expression_id TEXT, + none_of_id TEXT, + PRIMARY KEY (anonymous_type_expression_id, none_of_id), + FOREIGN KEY(anonymous_type_expression_id) REFERENCES anonymous_type_expression (id), + FOREIGN KEY(none_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE anonymous_type_expression_exactly_one_of ( + anonymous_type_expression_id TEXT, + exactly_one_of_id TEXT, + PRIMARY KEY (anonymous_type_expression_id, exactly_one_of_id), + FOREIGN KEY(anonymous_type_expression_id) REFERENCES anonymous_type_expression (id), + FOREIGN KEY(exactly_one_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE anonymous_type_expression_any_of ( + anonymous_type_expression_id TEXT, + any_of_id TEXT, + PRIMARY KEY (anonymous_type_expression_id, any_of_id), + FOREIGN KEY(anonymous_type_expression_id) REFERENCES anonymous_type_expression (id), + FOREIGN KEY(any_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE anonymous_type_expression_all_of ( + anonymous_type_expression_id TEXT, + all_of_id TEXT, + PRIMARY KEY (anonymous_type_expression_id, all_of_id), + FOREIGN KEY(anonymous_type_expression_id) REFERENCES anonymous_type_expression (id), + FOREIGN KEY(all_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE type_definition_none_of ( + type_definition_name TEXT, + none_of_id TEXT, + PRIMARY KEY (type_definition_name, none_of_id), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(none_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE type_definition_exactly_one_of ( + type_definition_name TEXT, + exactly_one_of_id TEXT, + PRIMARY KEY (type_definition_name, exactly_one_of_id), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(exactly_one_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE type_definition_any_of ( + type_definition_name TEXT, + any_of_id TEXT, + PRIMARY KEY (type_definition_name, any_of_id), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(any_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE type_definition_all_of ( + type_definition_name TEXT, + all_of_id TEXT, + PRIMARY KEY (type_definition_name, all_of_id), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(all_of_id) REFERENCES anonymous_type_expression (id) +); +CREATE TABLE type_definition_in_subset ( + type_definition_name TEXT, + in_subset TEXT, + PRIMARY KEY (type_definition_name, in_subset), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_id_prefixes ( + subset_definition_name TEXT, + id_prefixes TEXT, + PRIMARY KEY (subset_definition_name, id_prefixes), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_todos ( + subset_definition_name TEXT, + todos TEXT, + PRIMARY KEY (subset_definition_name, todos), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_notes ( + subset_definition_name TEXT, + notes TEXT, + PRIMARY KEY (subset_definition_name, notes), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_comments ( + subset_definition_name TEXT, + comments TEXT, + PRIMARY KEY (subset_definition_name, comments), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_in_subset ( + subset_definition_name TEXT, + in_subset TEXT, + PRIMARY KEY (subset_definition_name, in_subset), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_see_also ( + subset_definition_name TEXT, + see_also TEXT, + PRIMARY KEY (subset_definition_name, see_also), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_aliases ( + subset_definition_name TEXT, + aliases TEXT, + PRIMARY KEY (subset_definition_name, aliases), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_mappings ( + subset_definition_name TEXT, + mappings TEXT, + PRIMARY KEY (subset_definition_name, mappings), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_exact_mappings ( + subset_definition_name TEXT, + exact_mappings TEXT, + PRIMARY KEY (subset_definition_name, exact_mappings), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_close_mappings ( + subset_definition_name TEXT, + close_mappings TEXT, + PRIMARY KEY (subset_definition_name, close_mappings), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_related_mappings ( + subset_definition_name TEXT, + related_mappings TEXT, + PRIMARY KEY (subset_definition_name, related_mappings), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_narrow_mappings ( + subset_definition_name TEXT, + narrow_mappings TEXT, + PRIMARY KEY (subset_definition_name, narrow_mappings), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE subset_definition_broad_mappings ( + subset_definition_name TEXT, + broad_mappings TEXT, + PRIMARY KEY (subset_definition_name, broad_mappings), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name) +); +CREATE TABLE definition_in_subset ( + definition_name TEXT, + in_subset TEXT, + PRIMARY KEY (definition_name, in_subset), + FOREIGN KEY(definition_name) REFERENCES definition (name), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE enum_definition_id_prefixes ( + enum_definition_name TEXT, + id_prefixes TEXT, + PRIMARY KEY (enum_definition_name, id_prefixes), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_todos ( + enum_definition_name TEXT, + todos TEXT, + PRIMARY KEY (enum_definition_name, todos), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_notes ( + enum_definition_name TEXT, + notes TEXT, + PRIMARY KEY (enum_definition_name, notes), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_comments ( + enum_definition_name TEXT, + comments TEXT, + PRIMARY KEY (enum_definition_name, comments), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_in_subset ( + enum_definition_name TEXT, + in_subset TEXT, + PRIMARY KEY (enum_definition_name, in_subset), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE enum_definition_see_also ( + enum_definition_name TEXT, + see_also TEXT, + PRIMARY KEY (enum_definition_name, see_also), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_aliases ( + enum_definition_name TEXT, + aliases TEXT, + PRIMARY KEY (enum_definition_name, aliases), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_mappings ( + enum_definition_name TEXT, + mappings TEXT, + PRIMARY KEY (enum_definition_name, mappings), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_exact_mappings ( + enum_definition_name TEXT, + exact_mappings TEXT, + PRIMARY KEY (enum_definition_name, exact_mappings), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_close_mappings ( + enum_definition_name TEXT, + close_mappings TEXT, + PRIMARY KEY (enum_definition_name, close_mappings), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_related_mappings ( + enum_definition_name TEXT, + related_mappings TEXT, + PRIMARY KEY (enum_definition_name, related_mappings), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_narrow_mappings ( + enum_definition_name TEXT, + narrow_mappings TEXT, + PRIMARY KEY (enum_definition_name, narrow_mappings), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE enum_definition_broad_mappings ( + enum_definition_name TEXT, + broad_mappings TEXT, + PRIMARY KEY (enum_definition_name, broad_mappings), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name) +); +CREATE TABLE anonymous_expression_in_subset ( + anonymous_expression_id TEXT, + in_subset TEXT, + PRIMARY KEY (anonymous_expression_id, in_subset), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE path_expression_in_subset ( + path_expression_id TEXT, + in_subset TEXT, + PRIMARY KEY (path_expression_id, in_subset), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE slot_definition_domain_of ( + slot_definition_name TEXT, + domain_of TEXT, + PRIMARY KEY (slot_definition_name, domain_of), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(domain_of) REFERENCES class_definition (name) +); +CREATE TABLE slot_definition_in_subset ( + slot_definition_name TEXT, + in_subset TEXT, + PRIMARY KEY (slot_definition_name, in_subset), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE class_definition_slots ( + class_definition_name TEXT, + slots TEXT, + PRIMARY KEY (class_definition_name, slots), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(slots) REFERENCES slot_definition (name) +); +CREATE TABLE class_definition_union_of ( + class_definition_name TEXT, + union_of TEXT, + PRIMARY KEY (class_definition_name, union_of), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(union_of) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_defining_slots ( + class_definition_name TEXT, + defining_slots TEXT, + PRIMARY KEY (class_definition_name, defining_slots), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(defining_slots) REFERENCES slot_definition (name) +); +CREATE TABLE class_definition_disjoint_with ( + class_definition_name TEXT, + disjoint_with TEXT, + PRIMARY KEY (class_definition_name, disjoint_with), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(disjoint_with) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_mixins ( + class_definition_name TEXT, + mixins TEXT, + PRIMARY KEY (class_definition_name, mixins), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(mixins) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_apply_to ( + class_definition_name TEXT, + apply_to TEXT, + PRIMARY KEY (class_definition_name, apply_to), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(apply_to) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_values_from ( + class_definition_name TEXT, + values_from TEXT, + PRIMARY KEY (class_definition_name, values_from), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_id_prefixes ( + class_definition_name TEXT, + id_prefixes TEXT, + PRIMARY KEY (class_definition_name, id_prefixes), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_todos ( + class_definition_name TEXT, + todos TEXT, + PRIMARY KEY (class_definition_name, todos), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_notes ( + class_definition_name TEXT, + notes TEXT, + PRIMARY KEY (class_definition_name, notes), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_comments ( + class_definition_name TEXT, + comments TEXT, + PRIMARY KEY (class_definition_name, comments), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_in_subset ( + class_definition_name TEXT, + in_subset TEXT, + PRIMARY KEY (class_definition_name, in_subset), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE class_definition_see_also ( + class_definition_name TEXT, + see_also TEXT, + PRIMARY KEY (class_definition_name, see_also), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_aliases ( + class_definition_name TEXT, + aliases TEXT, + PRIMARY KEY (class_definition_name, aliases), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_mappings ( + class_definition_name TEXT, + mappings TEXT, + PRIMARY KEY (class_definition_name, mappings), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_exact_mappings ( + class_definition_name TEXT, + exact_mappings TEXT, + PRIMARY KEY (class_definition_name, exact_mappings), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_close_mappings ( + class_definition_name TEXT, + close_mappings TEXT, + PRIMARY KEY (class_definition_name, close_mappings), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_related_mappings ( + class_definition_name TEXT, + related_mappings TEXT, + PRIMARY KEY (class_definition_name, related_mappings), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_narrow_mappings ( + class_definition_name TEXT, + narrow_mappings TEXT, + PRIMARY KEY (class_definition_name, narrow_mappings), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE class_definition_broad_mappings ( + class_definition_name TEXT, + broad_mappings TEXT, + PRIMARY KEY (class_definition_name, broad_mappings), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); +CREATE TABLE pattern_expression_in_subset ( + pattern_expression_id TEXT, + in_subset TEXT, + PRIMARY KEY (pattern_expression_id, in_subset), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE import_expression_in_subset ( + import_expression_id TEXT, + in_subset TEXT, + PRIMARY KEY (import_expression_id, in_subset), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE anonymous_slot_expression ( + id INTEGER, + range TEXT, + required BOOLEAN, + recommended BOOLEAN, + inlined BOOLEAN, + inlined_as_list BOOLEAN, + minimum_value INTEGER, + maximum_value INTEGER, + pattern TEXT, + implicit_prefix TEXT, + equals_string TEXT, + equals_number INTEGER, + equals_expression TEXT, + minimum_cardinality INTEGER, + maximum_cardinality INTEGER, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + range_expression_id TEXT, + structured_pattern_id TEXT, + has_member_id TEXT, + PRIMARY KEY (id), + FOREIGN KEY(range) REFERENCES element (name), + FOREIGN KEY(range_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(structured_pattern_id) REFERENCES pattern_expression (id), + FOREIGN KEY(has_member_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE class_rule ( + id INTEGER, + bidirectional BOOLEAN, + open_world BOOLEAN, + rank INTEGER, + deactivated BOOLEAN, + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + class_definition_name TEXT, + preconditions_id TEXT, + postconditions_id TEXT, + elseconditions_id TEXT, + PRIMARY KEY (id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(preconditions_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(postconditions_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(elseconditions_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE class_expression_any_of ( + class_expression_id TEXT, + any_of_id TEXT, + PRIMARY KEY (class_expression_id, any_of_id), + FOREIGN KEY(class_expression_id) REFERENCES class_expression (id), + FOREIGN KEY(any_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE class_expression_exactly_one_of ( + class_expression_id TEXT, + exactly_one_of_id TEXT, + PRIMARY KEY (class_expression_id, exactly_one_of_id), + FOREIGN KEY(class_expression_id) REFERENCES class_expression (id), + FOREIGN KEY(exactly_one_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE class_expression_none_of ( + class_expression_id TEXT, + none_of_id TEXT, + PRIMARY KEY (class_expression_id, none_of_id), + FOREIGN KEY(class_expression_id) REFERENCES class_expression (id), + FOREIGN KEY(none_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE class_expression_all_of ( + class_expression_id TEXT, + all_of_id TEXT, + PRIMARY KEY (class_expression_id, all_of_id), + FOREIGN KEY(class_expression_id) REFERENCES class_expression (id), + FOREIGN KEY(all_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_any_of ( + anonymous_class_expression_id TEXT, + any_of_id TEXT, + PRIMARY KEY (anonymous_class_expression_id, any_of_id), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(any_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_exactly_one_of ( + anonymous_class_expression_id TEXT, + exactly_one_of_id TEXT, + PRIMARY KEY (anonymous_class_expression_id, exactly_one_of_id), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(exactly_one_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_none_of ( + anonymous_class_expression_id TEXT, + none_of_id TEXT, + PRIMARY KEY (anonymous_class_expression_id, none_of_id), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(none_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_all_of ( + anonymous_class_expression_id TEXT, + all_of_id TEXT, + PRIMARY KEY (anonymous_class_expression_id, all_of_id), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(all_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_todos ( + anonymous_class_expression_id TEXT, + todos TEXT, + PRIMARY KEY (anonymous_class_expression_id, todos), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_notes ( + anonymous_class_expression_id TEXT, + notes TEXT, + PRIMARY KEY (anonymous_class_expression_id, notes), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_comments ( + anonymous_class_expression_id TEXT, + comments TEXT, + PRIMARY KEY (anonymous_class_expression_id, comments), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_in_subset ( + anonymous_class_expression_id TEXT, + in_subset TEXT, + PRIMARY KEY (anonymous_class_expression_id, in_subset), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE anonymous_class_expression_see_also ( + anonymous_class_expression_id TEXT, + see_also TEXT, + PRIMARY KEY (anonymous_class_expression_id, see_also), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_aliases ( + anonymous_class_expression_id TEXT, + aliases TEXT, + PRIMARY KEY (anonymous_class_expression_id, aliases), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_mappings ( + anonymous_class_expression_id TEXT, + mappings TEXT, + PRIMARY KEY (anonymous_class_expression_id, mappings), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_exact_mappings ( + anonymous_class_expression_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (anonymous_class_expression_id, exact_mappings), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_close_mappings ( + anonymous_class_expression_id TEXT, + close_mappings TEXT, + PRIMARY KEY (anonymous_class_expression_id, close_mappings), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_related_mappings ( + anonymous_class_expression_id TEXT, + related_mappings TEXT, + PRIMARY KEY (anonymous_class_expression_id, related_mappings), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_narrow_mappings ( + anonymous_class_expression_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (anonymous_class_expression_id, narrow_mappings), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE anonymous_class_expression_broad_mappings ( + anonymous_class_expression_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (anonymous_class_expression_id, broad_mappings), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE class_definition_any_of ( + class_definition_name TEXT, + any_of_id TEXT, + PRIMARY KEY (class_definition_name, any_of_id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(any_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE class_definition_exactly_one_of ( + class_definition_name TEXT, + exactly_one_of_id TEXT, + PRIMARY KEY (class_definition_name, exactly_one_of_id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(exactly_one_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE class_definition_none_of ( + class_definition_name TEXT, + none_of_id TEXT, + PRIMARY KEY (class_definition_name, none_of_id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(none_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE class_definition_all_of ( + class_definition_name TEXT, + all_of_id TEXT, + PRIMARY KEY (class_definition_name, all_of_id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(all_of_id) REFERENCES anonymous_class_expression (id) +); +CREATE TABLE permissible_value_todos ( + permissible_value_text TEXT, + todos TEXT, + PRIMARY KEY (permissible_value_text, todos), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE permissible_value_notes ( + permissible_value_text TEXT, + notes TEXT, + PRIMARY KEY (permissible_value_text, notes), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE permissible_value_comments ( + permissible_value_text TEXT, + comments TEXT, + PRIMARY KEY (permissible_value_text, comments), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE permissible_value_in_subset ( + permissible_value_text TEXT, + in_subset TEXT, + PRIMARY KEY (permissible_value_text, in_subset), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE permissible_value_see_also ( + permissible_value_text TEXT, + see_also TEXT, + PRIMARY KEY (permissible_value_text, see_also), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE permissible_value_aliases ( + permissible_value_text TEXT, + aliases TEXT, + PRIMARY KEY (permissible_value_text, aliases), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE permissible_value_mappings ( + permissible_value_text TEXT, + mappings TEXT, + PRIMARY KEY (permissible_value_text, mappings), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE permissible_value_exact_mappings ( + permissible_value_text TEXT, + exact_mappings TEXT, + PRIMARY KEY (permissible_value_text, exact_mappings), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE permissible_value_close_mappings ( + permissible_value_text TEXT, + close_mappings TEXT, + PRIMARY KEY (permissible_value_text, close_mappings), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE permissible_value_related_mappings ( + permissible_value_text TEXT, + related_mappings TEXT, + PRIMARY KEY (permissible_value_text, related_mappings), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE permissible_value_narrow_mappings ( + permissible_value_text TEXT, + narrow_mappings TEXT, + PRIMARY KEY (permissible_value_text, narrow_mappings), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE permissible_value_broad_mappings ( + permissible_value_text TEXT, + broad_mappings TEXT, + PRIMARY KEY (permissible_value_text, broad_mappings), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text) +); +CREATE TABLE unique_key_unique_key_slots ( + unique_key_unique_key_name TEXT, + unique_key_slots TEXT NOT NULL, + PRIMARY KEY (unique_key_unique_key_name, unique_key_slots), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name), + FOREIGN KEY(unique_key_slots) REFERENCES slot_definition (name) +); +CREATE TABLE unique_key_todos ( + unique_key_unique_key_name TEXT, + todos TEXT, + PRIMARY KEY (unique_key_unique_key_name, todos), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE unique_key_notes ( + unique_key_unique_key_name TEXT, + notes TEXT, + PRIMARY KEY (unique_key_unique_key_name, notes), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE unique_key_comments ( + unique_key_unique_key_name TEXT, + comments TEXT, + PRIMARY KEY (unique_key_unique_key_name, comments), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE unique_key_in_subset ( + unique_key_unique_key_name TEXT, + in_subset TEXT, + PRIMARY KEY (unique_key_unique_key_name, in_subset), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE unique_key_see_also ( + unique_key_unique_key_name TEXT, + see_also TEXT, + PRIMARY KEY (unique_key_unique_key_name, see_also), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE unique_key_aliases ( + unique_key_unique_key_name TEXT, + aliases TEXT, + PRIMARY KEY (unique_key_unique_key_name, aliases), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE unique_key_mappings ( + unique_key_unique_key_name TEXT, + mappings TEXT, + PRIMARY KEY (unique_key_unique_key_name, mappings), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE unique_key_exact_mappings ( + unique_key_unique_key_name TEXT, + exact_mappings TEXT, + PRIMARY KEY (unique_key_unique_key_name, exact_mappings), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE unique_key_close_mappings ( + unique_key_unique_key_name TEXT, + close_mappings TEXT, + PRIMARY KEY (unique_key_unique_key_name, close_mappings), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE unique_key_related_mappings ( + unique_key_unique_key_name TEXT, + related_mappings TEXT, + PRIMARY KEY (unique_key_unique_key_name, related_mappings), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE unique_key_narrow_mappings ( + unique_key_unique_key_name TEXT, + narrow_mappings TEXT, + PRIMARY KEY (unique_key_unique_key_name, narrow_mappings), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE unique_key_broad_mappings ( + unique_key_unique_key_name TEXT, + broad_mappings TEXT, + PRIMARY KEY (unique_key_unique_key_name, broad_mappings), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE structured_alias ( + id INTEGER, + literal_form TEXT NOT NULL, + predicate VARCHAR(15), + description TEXT, + title TEXT, + deprecated TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + rank INTEGER, + common_metadata_id TEXT, + element_name TEXT, + schema_definition_name TEXT, + type_definition_name TEXT, + subset_definition_name TEXT, + definition_name TEXT, + enum_definition_name TEXT, + structured_alias_id TEXT, + anonymous_expression_id TEXT, + path_expression_id TEXT, + anonymous_slot_expression_id TEXT, + slot_definition_name TEXT, + anonymous_class_expression_id TEXT, + class_definition_name TEXT, + class_rule_id TEXT, + pattern_expression_id TEXT, + import_expression_id TEXT, + permissible_value_text TEXT, + unique_key_unique_key_name TEXT, + PRIMARY KEY (id), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id), + FOREIGN KEY(element_name) REFERENCES element (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name), + FOREIGN KEY(definition_name) REFERENCES definition (name), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE slot_expression ( + id INTEGER, + range TEXT, + required BOOLEAN, + recommended BOOLEAN, + inlined BOOLEAN, + inlined_as_list BOOLEAN, + minimum_value INTEGER, + maximum_value INTEGER, + pattern TEXT, + implicit_prefix TEXT, + equals_string TEXT, + equals_number INTEGER, + equals_expression TEXT, + minimum_cardinality INTEGER, + maximum_cardinality INTEGER, + range_expression_id TEXT, + structured_pattern_id TEXT, + has_member_id TEXT, + PRIMARY KEY (id), + FOREIGN KEY(range) REFERENCES element (name), + FOREIGN KEY(range_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(structured_pattern_id) REFERENCES pattern_expression (id), + FOREIGN KEY(has_member_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_equals_string_in ( + anonymous_slot_expression_id TEXT, + equals_string_in TEXT, + PRIMARY KEY (anonymous_slot_expression_id, equals_string_in), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_none_of ( + anonymous_slot_expression_id TEXT, + none_of_id TEXT, + PRIMARY KEY (anonymous_slot_expression_id, none_of_id), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(none_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_exactly_one_of ( + anonymous_slot_expression_id TEXT, + exactly_one_of_id TEXT, + PRIMARY KEY (anonymous_slot_expression_id, exactly_one_of_id), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(exactly_one_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_any_of ( + anonymous_slot_expression_id TEXT, + any_of_id TEXT, + PRIMARY KEY (anonymous_slot_expression_id, any_of_id), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(any_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_all_of ( + anonymous_slot_expression_id TEXT, + all_of_id TEXT, + PRIMARY KEY (anonymous_slot_expression_id, all_of_id), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(all_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_todos ( + anonymous_slot_expression_id TEXT, + todos TEXT, + PRIMARY KEY (anonymous_slot_expression_id, todos), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_notes ( + anonymous_slot_expression_id TEXT, + notes TEXT, + PRIMARY KEY (anonymous_slot_expression_id, notes), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_comments ( + anonymous_slot_expression_id TEXT, + comments TEXT, + PRIMARY KEY (anonymous_slot_expression_id, comments), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_in_subset ( + anonymous_slot_expression_id TEXT, + in_subset TEXT, + PRIMARY KEY (anonymous_slot_expression_id, in_subset), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE anonymous_slot_expression_see_also ( + anonymous_slot_expression_id TEXT, + see_also TEXT, + PRIMARY KEY (anonymous_slot_expression_id, see_also), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_aliases ( + anonymous_slot_expression_id TEXT, + aliases TEXT, + PRIMARY KEY (anonymous_slot_expression_id, aliases), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_mappings ( + anonymous_slot_expression_id TEXT, + mappings TEXT, + PRIMARY KEY (anonymous_slot_expression_id, mappings), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_exact_mappings ( + anonymous_slot_expression_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (anonymous_slot_expression_id, exact_mappings), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_close_mappings ( + anonymous_slot_expression_id TEXT, + close_mappings TEXT, + PRIMARY KEY (anonymous_slot_expression_id, close_mappings), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_related_mappings ( + anonymous_slot_expression_id TEXT, + related_mappings TEXT, + PRIMARY KEY (anonymous_slot_expression_id, related_mappings), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_narrow_mappings ( + anonymous_slot_expression_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (anonymous_slot_expression_id, narrow_mappings), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE anonymous_slot_expression_broad_mappings ( + anonymous_slot_expression_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (anonymous_slot_expression_id, broad_mappings), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE slot_definition_none_of ( + slot_definition_name TEXT, + none_of_id TEXT, + PRIMARY KEY (slot_definition_name, none_of_id), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(none_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE slot_definition_exactly_one_of ( + slot_definition_name TEXT, + exactly_one_of_id TEXT, + PRIMARY KEY (slot_definition_name, exactly_one_of_id), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(exactly_one_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE slot_definition_any_of ( + slot_definition_name TEXT, + any_of_id TEXT, + PRIMARY KEY (slot_definition_name, any_of_id), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(any_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE slot_definition_all_of ( + slot_definition_name TEXT, + all_of_id TEXT, + PRIMARY KEY (slot_definition_name, all_of_id), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(all_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE class_rule_todos ( + class_rule_id TEXT, + todos TEXT, + PRIMARY KEY (class_rule_id, todos), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE class_rule_notes ( + class_rule_id TEXT, + notes TEXT, + PRIMARY KEY (class_rule_id, notes), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE class_rule_comments ( + class_rule_id TEXT, + comments TEXT, + PRIMARY KEY (class_rule_id, comments), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE class_rule_in_subset ( + class_rule_id TEXT, + in_subset TEXT, + PRIMARY KEY (class_rule_id, in_subset), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE class_rule_see_also ( + class_rule_id TEXT, + see_also TEXT, + PRIMARY KEY (class_rule_id, see_also), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE class_rule_aliases ( + class_rule_id TEXT, + aliases TEXT, + PRIMARY KEY (class_rule_id, aliases), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE class_rule_mappings ( + class_rule_id TEXT, + mappings TEXT, + PRIMARY KEY (class_rule_id, mappings), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE class_rule_exact_mappings ( + class_rule_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (class_rule_id, exact_mappings), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE class_rule_close_mappings ( + class_rule_id TEXT, + close_mappings TEXT, + PRIMARY KEY (class_rule_id, close_mappings), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE class_rule_related_mappings ( + class_rule_id TEXT, + related_mappings TEXT, + PRIMARY KEY (class_rule_id, related_mappings), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE class_rule_narrow_mappings ( + class_rule_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (class_rule_id, narrow_mappings), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE class_rule_broad_mappings ( + class_rule_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (class_rule_id, broad_mappings), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id) +); +CREATE TABLE example ( + id INTEGER, + value TEXT, + description TEXT, + common_metadata_id TEXT, + element_name TEXT, + schema_definition_name TEXT, + type_definition_name TEXT, + subset_definition_name TEXT, + definition_name TEXT, + enum_definition_name TEXT, + structured_alias_id TEXT, + anonymous_expression_id TEXT, + path_expression_id TEXT, + anonymous_slot_expression_id TEXT, + slot_definition_name TEXT, + anonymous_class_expression_id TEXT, + class_definition_name TEXT, + class_rule_id TEXT, + pattern_expression_id TEXT, + import_expression_id TEXT, + permissible_value_text TEXT, + unique_key_unique_key_name TEXT, + PRIMARY KEY (id), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id), + FOREIGN KEY(element_name) REFERENCES element (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name), + FOREIGN KEY(definition_name) REFERENCES definition (name), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE alt_description ( + source TEXT, + description TEXT NOT NULL, + common_metadata_id TEXT, + element_name TEXT, + schema_definition_name TEXT, + type_definition_name TEXT, + subset_definition_name TEXT, + definition_name TEXT, + enum_definition_name TEXT, + structured_alias_id TEXT, + anonymous_expression_id TEXT, + path_expression_id TEXT, + anonymous_slot_expression_id TEXT, + slot_definition_name TEXT, + anonymous_class_expression_id TEXT, + class_definition_name TEXT, + class_rule_id TEXT, + pattern_expression_id TEXT, + import_expression_id TEXT, + permissible_value_text TEXT, + unique_key_unique_key_name TEXT, + PRIMARY KEY (source, description, common_metadata_id, element_name, schema_definition_name, type_definition_name, subset_definition_name, definition_name, enum_definition_name, structured_alias_id, anonymous_expression_id, path_expression_id, anonymous_slot_expression_id, slot_definition_name, anonymous_class_expression_id, class_definition_name, class_rule_id, pattern_expression_id, import_expression_id, permissible_value_text, unique_key_unique_key_name), + FOREIGN KEY(common_metadata_id) REFERENCES common_metadata (id), + FOREIGN KEY(element_name) REFERENCES element (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name), + FOREIGN KEY(definition_name) REFERENCES definition (name), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name) +); +CREATE TABLE annotation ( + tag TEXT NOT NULL, + value TEXT NOT NULL, + element_name TEXT, + schema_definition_name TEXT, + type_definition_name TEXT, + subset_definition_name TEXT, + definition_name TEXT, + enum_definition_name TEXT, + structured_alias_id TEXT, + anonymous_expression_id TEXT, + path_expression_id TEXT, + anonymous_slot_expression_id TEXT, + slot_definition_name TEXT, + anonymous_class_expression_id TEXT, + class_definition_name TEXT, + class_rule_id TEXT, + pattern_expression_id TEXT, + import_expression_id TEXT, + permissible_value_text TEXT, + unique_key_unique_key_name TEXT, + annotatable_id TEXT, + annotation_tag TEXT, + PRIMARY KEY (tag, value, element_name, schema_definition_name, type_definition_name, subset_definition_name, definition_name, enum_definition_name, structured_alias_id, anonymous_expression_id, path_expression_id, anonymous_slot_expression_id, slot_definition_name, anonymous_class_expression_id, class_definition_name, class_rule_id, pattern_expression_id, import_expression_id, permissible_value_text, unique_key_unique_key_name, annotatable_id, annotation_tag), + FOREIGN KEY(element_name) REFERENCES element (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name), + FOREIGN KEY(definition_name) REFERENCES definition (name), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name), + FOREIGN KEY(annotatable_id) REFERENCES annotatable (id), + FOREIGN KEY(annotation_tag) REFERENCES annotation (tag) +); +CREATE TABLE structured_alias_category ( + structured_alias_id TEXT, + category TEXT, + PRIMARY KEY (structured_alias_id, category), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_todos ( + structured_alias_id TEXT, + todos TEXT, + PRIMARY KEY (structured_alias_id, todos), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_notes ( + structured_alias_id TEXT, + notes TEXT, + PRIMARY KEY (structured_alias_id, notes), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_comments ( + structured_alias_id TEXT, + comments TEXT, + PRIMARY KEY (structured_alias_id, comments), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_in_subset ( + structured_alias_id TEXT, + in_subset TEXT, + PRIMARY KEY (structured_alias_id, in_subset), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id), + FOREIGN KEY(in_subset) REFERENCES subset_definition (name) +); +CREATE TABLE structured_alias_see_also ( + structured_alias_id TEXT, + see_also TEXT, + PRIMARY KEY (structured_alias_id, see_also), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_aliases ( + structured_alias_id TEXT, + aliases TEXT, + PRIMARY KEY (structured_alias_id, aliases), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_mappings ( + structured_alias_id TEXT, + mappings TEXT, + PRIMARY KEY (structured_alias_id, mappings), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_exact_mappings ( + structured_alias_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (structured_alias_id, exact_mappings), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_close_mappings ( + structured_alias_id TEXT, + close_mappings TEXT, + PRIMARY KEY (structured_alias_id, close_mappings), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_related_mappings ( + structured_alias_id TEXT, + related_mappings TEXT, + PRIMARY KEY (structured_alias_id, related_mappings), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_narrow_mappings ( + structured_alias_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (structured_alias_id, narrow_mappings), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE structured_alias_broad_mappings ( + structured_alias_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (structured_alias_id, broad_mappings), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id) +); +CREATE TABLE slot_expression_equals_string_in ( + slot_expression_id TEXT, + equals_string_in TEXT, + PRIMARY KEY (slot_expression_id, equals_string_in), + FOREIGN KEY(slot_expression_id) REFERENCES slot_expression (id) +); +CREATE TABLE slot_expression_none_of ( + slot_expression_id TEXT, + none_of_id TEXT, + PRIMARY KEY (slot_expression_id, none_of_id), + FOREIGN KEY(slot_expression_id) REFERENCES slot_expression (id), + FOREIGN KEY(none_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE slot_expression_exactly_one_of ( + slot_expression_id TEXT, + exactly_one_of_id TEXT, + PRIMARY KEY (slot_expression_id, exactly_one_of_id), + FOREIGN KEY(slot_expression_id) REFERENCES slot_expression (id), + FOREIGN KEY(exactly_one_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE slot_expression_any_of ( + slot_expression_id TEXT, + any_of_id TEXT, + PRIMARY KEY (slot_expression_id, any_of_id), + FOREIGN KEY(slot_expression_id) REFERENCES slot_expression (id), + FOREIGN KEY(any_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE slot_expression_all_of ( + slot_expression_id TEXT, + all_of_id TEXT, + PRIMARY KEY (slot_expression_id, all_of_id), + FOREIGN KEY(slot_expression_id) REFERENCES slot_expression (id), + FOREIGN KEY(all_of_id) REFERENCES anonymous_slot_expression (id) +); +CREATE TABLE extension ( + tag TEXT NOT NULL, + value TEXT NOT NULL, + element_name TEXT, + schema_definition_name TEXT, + type_definition_name TEXT, + subset_definition_name TEXT, + definition_name TEXT, + enum_definition_name TEXT, + structured_alias_id TEXT, + anonymous_expression_id TEXT, + path_expression_id TEXT, + anonymous_slot_expression_id TEXT, + slot_definition_name TEXT, + anonymous_class_expression_id TEXT, + class_definition_name TEXT, + class_rule_id TEXT, + pattern_expression_id TEXT, + import_expression_id TEXT, + permissible_value_text TEXT, + unique_key_unique_key_name TEXT, + annotation_tag TEXT, + extension_tag TEXT, + extensible_id TEXT, + PRIMARY KEY (tag, value, element_name, schema_definition_name, type_definition_name, subset_definition_name, definition_name, enum_definition_name, structured_alias_id, anonymous_expression_id, path_expression_id, anonymous_slot_expression_id, slot_definition_name, anonymous_class_expression_id, class_definition_name, class_rule_id, pattern_expression_id, import_expression_id, permissible_value_text, unique_key_unique_key_name, annotation_tag, extension_tag, extensible_id), + FOREIGN KEY(element_name) REFERENCES element (name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (id), + FOREIGN KEY(type_definition_name) REFERENCES type_definition (name), + FOREIGN KEY(subset_definition_name) REFERENCES subset_definition (name), + FOREIGN KEY(definition_name) REFERENCES definition (name), + FOREIGN KEY(enum_definition_name) REFERENCES enum_definition (name), + FOREIGN KEY(structured_alias_id) REFERENCES structured_alias (id), + FOREIGN KEY(anonymous_expression_id) REFERENCES anonymous_expression (id), + FOREIGN KEY(path_expression_id) REFERENCES path_expression (id), + FOREIGN KEY(anonymous_slot_expression_id) REFERENCES anonymous_slot_expression (id), + FOREIGN KEY(slot_definition_name) REFERENCES slot_definition (name), + FOREIGN KEY(anonymous_class_expression_id) REFERENCES anonymous_class_expression (id), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name), + FOREIGN KEY(class_rule_id) REFERENCES class_rule (id), + FOREIGN KEY(pattern_expression_id) REFERENCES pattern_expression (id), + FOREIGN KEY(import_expression_id) REFERENCES import_expression (id), + FOREIGN KEY(permissible_value_text) REFERENCES permissible_value (text), + FOREIGN KEY(unique_key_unique_key_name) REFERENCES unique_key (unique_key_name), + FOREIGN KEY(annotation_tag) REFERENCES annotation (tag), + FOREIGN KEY(extension_tag) REFERENCES extension (tag), + FOREIGN KEY(extensible_id) REFERENCES extensible (id) +); diff --git a/linkml_runtime/linkml_model/sqlschema/meta.sql b/linkml_runtime/linkml_model/sqlschema/meta.sql new file mode 100644 index 00000000..66e3dfac --- /dev/null +++ b/linkml_runtime/linkml_model/sqlschema/meta.sql @@ -0,0 +1,1439 @@ + + +CREATE TABLE alt_description ( + source TEXT NOT NULL, + description TEXT NOT NULL, + PRIMARY KEY (source, description) +); + +CREATE TABLE annotation ( + tag TEXT NOT NULL, + value TEXT NOT NULL, + extensions TEXT, + annotations TEXT, + PRIMARY KEY (tag, value, extensions, annotations) +); + +CREATE TABLE anonymous_class_expression ( + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + todos TEXT, + notes TEXT, + comments TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + see_also TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + aliases TEXT, + structured_aliases TEXT, + mappings TEXT, + exact_mappings TEXT, + close_mappings TEXT, + related_mappings TEXT, + narrow_mappings TEXT, + broad_mappings TEXT, + rank INTEGER, + is_a TEXT, + any_of TEXT, + exactly_one_of TEXT, + none_of TEXT, + all_of TEXT, + slot_conditions TEXT, + PRIMARY KEY (extensions, annotations, description, alt_descriptions, title, deprecated, todos, notes, comments, examples, in_subset, from_schema, imported_from, source, in_language, see_also, deprecated_element_has_exact_replacement, deprecated_element_has_possible_replacement, aliases, structured_aliases, mappings, exact_mappings, close_mappings, related_mappings, narrow_mappings, broad_mappings, rank, is_a, any_of, exactly_one_of, none_of, all_of, slot_conditions) +); + +CREATE TABLE anonymous_enum_expression ( + code_set TEXT, + code_set_tag TEXT, + code_set_version TEXT, + pv_formula VARCHAR(11), + permissible_values TEXT, + include TEXT, + minus TEXT, + inherits TEXT, + reachable_from TEXT, + matches TEXT, + concepts TEXT, + PRIMARY KEY (code_set, code_set_tag, code_set_version, pv_formula, permissible_values, include, minus, inherits, reachable_from, matches, concepts) +); + +CREATE TABLE anonymous_slot_expression ( + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + todos TEXT, + notes TEXT, + comments TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + see_also TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + aliases TEXT, + structured_aliases TEXT, + mappings TEXT, + exact_mappings TEXT, + close_mappings TEXT, + related_mappings TEXT, + narrow_mappings TEXT, + broad_mappings TEXT, + rank INTEGER, + range TEXT, + range_expression TEXT, + enum_range TEXT, + required BOOLEAN, + recommended BOOLEAN, + inlined BOOLEAN, + inlined_as_list BOOLEAN, + minimum_value INTEGER, + maximum_value INTEGER, + pattern TEXT, + structured_pattern TEXT, + unit TEXT, + implicit_prefix TEXT, + value_presence VARCHAR(11), + equals_string TEXT, + equals_string_in TEXT, + equals_number INTEGER, + equals_expression TEXT, + minimum_cardinality INTEGER, + maximum_cardinality INTEGER, + has_member TEXT, + all_members TEXT, + none_of TEXT, + exactly_one_of TEXT, + any_of TEXT, + all_of TEXT, + PRIMARY KEY (extensions, annotations, description, alt_descriptions, title, deprecated, todos, notes, comments, examples, in_subset, from_schema, imported_from, source, in_language, see_also, deprecated_element_has_exact_replacement, deprecated_element_has_possible_replacement, aliases, structured_aliases, mappings, exact_mappings, close_mappings, related_mappings, narrow_mappings, broad_mappings, rank, range, range_expression, enum_range, required, recommended, inlined, inlined_as_list, minimum_value, maximum_value, pattern, structured_pattern, unit, implicit_prefix, value_presence, equals_string, equals_string_in, equals_number, equals_expression, minimum_cardinality, maximum_cardinality, has_member, all_members, none_of, exactly_one_of, any_of, all_of) +); + +CREATE TABLE anonymous_type_expression ( + pattern TEXT, + structured_pattern TEXT, + unit TEXT, + implicit_prefix TEXT, + equals_string TEXT, + equals_string_in TEXT, + equals_number INTEGER, + minimum_value INTEGER, + maximum_value INTEGER, + none_of TEXT, + exactly_one_of TEXT, + any_of TEXT, + all_of TEXT, + PRIMARY KEY (pattern, structured_pattern, unit, implicit_prefix, equals_string, equals_string_in, equals_number, minimum_value, maximum_value, none_of, exactly_one_of, any_of, all_of) +); + +CREATE TABLE class_definition ( + name TEXT NOT NULL, + definition_uri TEXT, + local_names TEXT, + conforms_to TEXT, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + structured_aliases TEXT, + rank INTEGER, + abstract BOOLEAN, + mixin BOOLEAN, + created_by TEXT, + created_on DATETIME, + last_updated_on DATETIME, + modified_by TEXT, + status TEXT, + string_serialization TEXT, + slots TEXT, + slot_usage TEXT, + attributes TEXT, + class_uri TEXT, + subclass_of TEXT, + union_of TEXT, + defining_slots TEXT, + tree_root BOOLEAN, + classification_rules TEXT, + slot_names_unique BOOLEAN, + represents_relationship BOOLEAN, + disjoint_with TEXT, + children_are_mutually_disjoint BOOLEAN, + is_a TEXT, + mixins TEXT, + apply_to TEXT, + any_of TEXT, + exactly_one_of TEXT, + none_of TEXT, + all_of TEXT, + slot_conditions TEXT, + PRIMARY KEY (name), + FOREIGN KEY(is_a) REFERENCES class_definition (name) +); + +CREATE TABLE enum_definition ( + name TEXT NOT NULL, + definition_uri TEXT, + local_names TEXT, + conforms_to TEXT, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + structured_aliases TEXT, + rank INTEGER, + is_a TEXT, + abstract BOOLEAN, + mixin BOOLEAN, + created_by TEXT, + created_on DATETIME, + last_updated_on DATETIME, + modified_by TEXT, + status TEXT, + string_serialization TEXT, + enum_uri TEXT, + code_set TEXT, + code_set_tag TEXT, + code_set_version TEXT, + pv_formula VARCHAR(11), + permissible_values TEXT, + include TEXT, + minus TEXT, + inherits TEXT, + reachable_from TEXT, + matches TEXT, + PRIMARY KEY (name) +); + +CREATE TABLE enum_expression ( + code_set TEXT, + code_set_tag TEXT, + code_set_version TEXT, + pv_formula VARCHAR(11), + permissible_values TEXT, + include TEXT, + minus TEXT, + inherits TEXT, + reachable_from TEXT, + matches TEXT, + concepts TEXT, + PRIMARY KEY (code_set, code_set_tag, code_set_version, pv_formula, permissible_values, include, minus, inherits, reachable_from, matches, concepts) +); + +CREATE TABLE example ( + value TEXT, + description TEXT, + PRIMARY KEY (value, description) +); + +CREATE TABLE extension ( + tag TEXT NOT NULL, + value TEXT NOT NULL, + extensions TEXT, + PRIMARY KEY (tag, value, extensions) +); + +CREATE TABLE import_expression ( + import_from TEXT NOT NULL, + import_as TEXT, + import_map TEXT, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + todos TEXT, + notes TEXT, + comments TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + see_also TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + aliases TEXT, + structured_aliases TEXT, + mappings TEXT, + exact_mappings TEXT, + close_mappings TEXT, + related_mappings TEXT, + narrow_mappings TEXT, + broad_mappings TEXT, + rank INTEGER, + PRIMARY KEY (import_from, import_as, import_map, extensions, annotations, description, alt_descriptions, title, deprecated, todos, notes, comments, examples, in_subset, from_schema, imported_from, source, in_language, see_also, deprecated_element_has_exact_replacement, deprecated_element_has_possible_replacement, aliases, structured_aliases, mappings, exact_mappings, close_mappings, related_mappings, narrow_mappings, broad_mappings, rank) +); + +CREATE TABLE local_name ( + local_name_source TEXT NOT NULL, + local_name_value TEXT NOT NULL, + PRIMARY KEY (local_name_source, local_name_value) +); + +CREATE TABLE match_query ( + identifier_pattern TEXT, + source_ontology TEXT, + PRIMARY KEY (identifier_pattern, source_ontology) +); + +CREATE TABLE pattern_expression ( + syntax TEXT, + interpolated BOOLEAN, + partial_match BOOLEAN, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + todos TEXT, + notes TEXT, + comments TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + see_also TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + aliases TEXT, + structured_aliases TEXT, + mappings TEXT, + exact_mappings TEXT, + close_mappings TEXT, + related_mappings TEXT, + narrow_mappings TEXT, + broad_mappings TEXT, + rank INTEGER, + PRIMARY KEY (syntax, interpolated, partial_match, extensions, annotations, description, alt_descriptions, title, deprecated, todos, notes, comments, examples, in_subset, from_schema, imported_from, source, in_language, see_also, deprecated_element_has_exact_replacement, deprecated_element_has_possible_replacement, aliases, structured_aliases, mappings, exact_mappings, close_mappings, related_mappings, narrow_mappings, broad_mappings, rank) +); + +CREATE TABLE permissible_value ( + text TEXT NOT NULL, + description TEXT, + meaning TEXT, + unit TEXT, + is_a TEXT, + mixins TEXT, + extensions TEXT, + annotations TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + structured_aliases TEXT, + rank INTEGER, + PRIMARY KEY (text), + FOREIGN KEY(is_a) REFERENCES permissible_value (text) +); + +CREATE TABLE reachability_query ( + source_ontology TEXT, + source_nodes TEXT, + relationship_types TEXT, + is_direct BOOLEAN, + include_self BOOLEAN, + traverse_up BOOLEAN, + PRIMARY KEY (source_ontology, source_nodes, relationship_types, is_direct, include_self, traverse_up) +); + +CREATE TABLE setting ( + setting_key TEXT NOT NULL, + setting_value TEXT NOT NULL, + PRIMARY KEY (setting_key, setting_value) +); + +CREATE TABLE structured_alias ( + literal_form TEXT NOT NULL, + predicate VARCHAR(15), + categories TEXT, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + todos TEXT, + notes TEXT, + comments TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + see_also TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + aliases TEXT, + structured_aliases TEXT, + mappings TEXT, + exact_mappings TEXT, + close_mappings TEXT, + related_mappings TEXT, + narrow_mappings TEXT, + broad_mappings TEXT, + rank INTEGER, + PRIMARY KEY (literal_form, predicate, categories, extensions, annotations, description, alt_descriptions, title, deprecated, todos, notes, comments, examples, in_subset, from_schema, imported_from, source, in_language, see_also, deprecated_element_has_exact_replacement, deprecated_element_has_possible_replacement, aliases, structured_aliases, mappings, exact_mappings, close_mappings, related_mappings, narrow_mappings, broad_mappings, rank) +); + +CREATE TABLE subset_definition ( + name TEXT NOT NULL, + definition_uri TEXT, + local_names TEXT, + conforms_to TEXT, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + structured_aliases TEXT, + rank INTEGER, + PRIMARY KEY (name) +); + +CREATE TABLE type_definition ( + name TEXT NOT NULL, + definition_uri TEXT, + local_names TEXT, + conforms_to TEXT, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + structured_aliases TEXT, + rank INTEGER, + typeof TEXT, + base TEXT, + uri TEXT, + repr TEXT, + union_of TEXT, + pattern TEXT, + structured_pattern TEXT, + unit TEXT, + implicit_prefix TEXT, + equals_string TEXT, + equals_number INTEGER, + minimum_value INTEGER, + maximum_value INTEGER, + none_of TEXT, + exactly_one_of TEXT, + any_of TEXT, + all_of TEXT, + PRIMARY KEY (name), + FOREIGN KEY(typeof) REFERENCES type_definition (name) +); + +CREATE TABLE "UnitOfMeasure" ( + symbol TEXT, + exact_mappings TEXT, + ucum_code TEXT, + derivation TEXT, + has_quantity_kind TEXT, + iec61360code TEXT, + PRIMARY KEY (symbol, exact_mappings, ucum_code, derivation, has_quantity_kind, iec61360code) +); + +CREATE TABLE class_rule ( + preconditions TEXT, + postconditions TEXT, + elseconditions TEXT, + bidirectional BOOLEAN, + open_world BOOLEAN, + rank INTEGER, + deactivated BOOLEAN, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + todos TEXT, + notes TEXT, + comments TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + see_also TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + aliases TEXT, + structured_aliases TEXT, + mappings TEXT, + exact_mappings TEXT, + close_mappings TEXT, + related_mappings TEXT, + narrow_mappings TEXT, + broad_mappings TEXT, + class_definition_name TEXT, + PRIMARY KEY (preconditions, postconditions, elseconditions, bidirectional, open_world, rank, deactivated, extensions, annotations, description, alt_descriptions, title, deprecated, todos, notes, comments, examples, in_subset, from_schema, imported_from, source, in_language, see_also, deprecated_element_has_exact_replacement, deprecated_element_has_possible_replacement, aliases, structured_aliases, mappings, exact_mappings, close_mappings, related_mappings, narrow_mappings, broad_mappings, class_definition_name), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); + +CREATE TABLE schema_definition ( + definition_uri TEXT, + local_names TEXT, + conforms_to TEXT, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + structured_aliases TEXT, + rank INTEGER, + id TEXT NOT NULL, + version TEXT, + license TEXT, + default_prefix TEXT, + default_range TEXT, + subsets TEXT, + types TEXT, + enums TEXT, + slots TEXT, + classes TEXT, + metamodel_version TEXT, + source_file TEXT, + source_file_date DATETIME, + source_file_size INTEGER, + generation_date DATETIME, + slot_names_unique BOOLEAN, + settings TEXT, + name TEXT NOT NULL, + PRIMARY KEY (name), + FOREIGN KEY(default_range) REFERENCES type_definition (name) +); + +CREATE TABLE slot_definition ( + name TEXT NOT NULL, + definition_uri TEXT, + local_names TEXT, + conforms_to TEXT, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + structured_aliases TEXT, + rank INTEGER, + abstract BOOLEAN, + mixin BOOLEAN, + created_by TEXT, + created_on DATETIME, + last_updated_on DATETIME, + modified_by TEXT, + status TEXT, + string_serialization TEXT, + singular_name TEXT, + domain TEXT, + slot_uri TEXT, + multivalued BOOLEAN, + inherited BOOLEAN, + readonly TEXT, + ifabsent TEXT, + list_elements_unique BOOLEAN, + list_elements_ordered BOOLEAN, + shared BOOLEAN, + "key" BOOLEAN, + identifier BOOLEAN, + designates_type BOOLEAN, + alias TEXT, + owner TEXT, + domain_of TEXT, + subproperty_of TEXT, + symmetric BOOLEAN, + reflexive BOOLEAN, + locally_reflexive BOOLEAN, + irreflexive BOOLEAN, + asymmetric BOOLEAN, + transitive BOOLEAN, + inverse TEXT, + is_class_field BOOLEAN, + transitive_form_of TEXT, + reflexive_transitive_form_of TEXT, + role TEXT, + is_usage_slot BOOLEAN, + usage_slot_name TEXT, + relational_role VARCHAR(10), + slot_group TEXT, + is_grouping_slot BOOLEAN, + path_rule TEXT, + disjoint_with TEXT, + children_are_mutually_disjoint BOOLEAN, + union_of TEXT, + is_a TEXT, + mixins TEXT, + apply_to TEXT, + range TEXT, + range_expression TEXT, + enum_range TEXT, + required BOOLEAN, + recommended BOOLEAN, + inlined BOOLEAN, + inlined_as_list BOOLEAN, + minimum_value INTEGER, + maximum_value INTEGER, + pattern TEXT, + structured_pattern TEXT, + unit TEXT, + implicit_prefix TEXT, + value_presence VARCHAR(11), + equals_string TEXT, + equals_number INTEGER, + equals_expression TEXT, + minimum_cardinality INTEGER, + maximum_cardinality INTEGER, + has_member TEXT, + all_members TEXT, + none_of TEXT, + exactly_one_of TEXT, + any_of TEXT, + all_of TEXT, + PRIMARY KEY (name), + FOREIGN KEY(domain) REFERENCES class_definition (name), + FOREIGN KEY(subproperty_of) REFERENCES slot_definition (name), + FOREIGN KEY(inverse) REFERENCES slot_definition (name), + FOREIGN KEY(transitive_form_of) REFERENCES slot_definition (name), + FOREIGN KEY(reflexive_transitive_form_of) REFERENCES slot_definition (name), + FOREIGN KEY(slot_group) REFERENCES slot_definition (name), + FOREIGN KEY(is_a) REFERENCES slot_definition (name) +); + +CREATE TABLE unique_key ( + unique_key_name TEXT NOT NULL, + unique_key_slots TEXT NOT NULL, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + todos TEXT, + notes TEXT, + comments TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + see_also TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + aliases TEXT, + structured_aliases TEXT, + mappings TEXT, + exact_mappings TEXT, + close_mappings TEXT, + related_mappings TEXT, + narrow_mappings TEXT, + broad_mappings TEXT, + rank INTEGER, + class_definition_name TEXT, + PRIMARY KEY (unique_key_name, unique_key_slots, extensions, annotations, description, alt_descriptions, title, deprecated, todos, notes, comments, examples, in_subset, from_schema, imported_from, source, in_language, see_also, deprecated_element_has_exact_replacement, deprecated_element_has_possible_replacement, aliases, structured_aliases, mappings, exact_mappings, close_mappings, related_mappings, narrow_mappings, broad_mappings, rank, class_definition_name), + FOREIGN KEY(class_definition_name) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_id_prefixes ( + backref_id TEXT, + id_prefixes TEXT, + PRIMARY KEY (backref_id, id_prefixes), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_todos ( + backref_id TEXT, + todos TEXT, + PRIMARY KEY (backref_id, todos), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_notes ( + backref_id TEXT, + notes TEXT, + PRIMARY KEY (backref_id, notes), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_comments ( + backref_id TEXT, + comments TEXT, + PRIMARY KEY (backref_id, comments), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_see_also ( + backref_id TEXT, + see_also TEXT, + PRIMARY KEY (backref_id, see_also), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_aliases ( + backref_id TEXT, + aliases TEXT, + PRIMARY KEY (backref_id, aliases), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_mappings ( + backref_id TEXT, + mappings TEXT, + PRIMARY KEY (backref_id, mappings), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_exact_mappings ( + backref_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (backref_id, exact_mappings), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_close_mappings ( + backref_id TEXT, + close_mappings TEXT, + PRIMARY KEY (backref_id, close_mappings), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_related_mappings ( + backref_id TEXT, + related_mappings TEXT, + PRIMARY KEY (backref_id, related_mappings), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_narrow_mappings ( + backref_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (backref_id, narrow_mappings), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_broad_mappings ( + backref_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (backref_id, broad_mappings), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE class_definition_values_from ( + backref_id TEXT, + values_from TEXT, + PRIMARY KEY (backref_id, values_from), + FOREIGN KEY(backref_id) REFERENCES class_definition (name) +); + +CREATE TABLE enum_definition_id_prefixes ( + backref_id TEXT, + id_prefixes TEXT, + PRIMARY KEY (backref_id, id_prefixes), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_todos ( + backref_id TEXT, + todos TEXT, + PRIMARY KEY (backref_id, todos), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_notes ( + backref_id TEXT, + notes TEXT, + PRIMARY KEY (backref_id, notes), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_comments ( + backref_id TEXT, + comments TEXT, + PRIMARY KEY (backref_id, comments), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_see_also ( + backref_id TEXT, + see_also TEXT, + PRIMARY KEY (backref_id, see_also), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_aliases ( + backref_id TEXT, + aliases TEXT, + PRIMARY KEY (backref_id, aliases), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_mappings ( + backref_id TEXT, + mappings TEXT, + PRIMARY KEY (backref_id, mappings), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_exact_mappings ( + backref_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (backref_id, exact_mappings), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_close_mappings ( + backref_id TEXT, + close_mappings TEXT, + PRIMARY KEY (backref_id, close_mappings), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_related_mappings ( + backref_id TEXT, + related_mappings TEXT, + PRIMARY KEY (backref_id, related_mappings), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_narrow_mappings ( + backref_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (backref_id, narrow_mappings), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_broad_mappings ( + backref_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (backref_id, broad_mappings), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_mixins ( + backref_id TEXT, + mixins TEXT, + PRIMARY KEY (backref_id, mixins), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_apply_to ( + backref_id TEXT, + apply_to TEXT, + PRIMARY KEY (backref_id, apply_to), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_values_from ( + backref_id TEXT, + values_from TEXT, + PRIMARY KEY (backref_id, values_from), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE enum_definition_concepts ( + backref_id TEXT, + concepts TEXT, + PRIMARY KEY (backref_id, concepts), + FOREIGN KEY(backref_id) REFERENCES enum_definition (name) +); + +CREATE TABLE permissible_value_todos ( + backref_id TEXT, + todos TEXT, + PRIMARY KEY (backref_id, todos), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE permissible_value_notes ( + backref_id TEXT, + notes TEXT, + PRIMARY KEY (backref_id, notes), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE permissible_value_comments ( + backref_id TEXT, + comments TEXT, + PRIMARY KEY (backref_id, comments), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE permissible_value_see_also ( + backref_id TEXT, + see_also TEXT, + PRIMARY KEY (backref_id, see_also), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE permissible_value_aliases ( + backref_id TEXT, + aliases TEXT, + PRIMARY KEY (backref_id, aliases), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE permissible_value_mappings ( + backref_id TEXT, + mappings TEXT, + PRIMARY KEY (backref_id, mappings), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE permissible_value_exact_mappings ( + backref_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (backref_id, exact_mappings), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE permissible_value_close_mappings ( + backref_id TEXT, + close_mappings TEXT, + PRIMARY KEY (backref_id, close_mappings), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE permissible_value_related_mappings ( + backref_id TEXT, + related_mappings TEXT, + PRIMARY KEY (backref_id, related_mappings), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE permissible_value_narrow_mappings ( + backref_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (backref_id, narrow_mappings), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE permissible_value_broad_mappings ( + backref_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (backref_id, broad_mappings), + FOREIGN KEY(backref_id) REFERENCES permissible_value (text) +); + +CREATE TABLE subset_definition_id_prefixes ( + backref_id TEXT, + id_prefixes TEXT, + PRIMARY KEY (backref_id, id_prefixes), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_todos ( + backref_id TEXT, + todos TEXT, + PRIMARY KEY (backref_id, todos), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_notes ( + backref_id TEXT, + notes TEXT, + PRIMARY KEY (backref_id, notes), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_comments ( + backref_id TEXT, + comments TEXT, + PRIMARY KEY (backref_id, comments), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_see_also ( + backref_id TEXT, + see_also TEXT, + PRIMARY KEY (backref_id, see_also), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_aliases ( + backref_id TEXT, + aliases TEXT, + PRIMARY KEY (backref_id, aliases), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_mappings ( + backref_id TEXT, + mappings TEXT, + PRIMARY KEY (backref_id, mappings), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_exact_mappings ( + backref_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (backref_id, exact_mappings), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_close_mappings ( + backref_id TEXT, + close_mappings TEXT, + PRIMARY KEY (backref_id, close_mappings), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_related_mappings ( + backref_id TEXT, + related_mappings TEXT, + PRIMARY KEY (backref_id, related_mappings), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_narrow_mappings ( + backref_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (backref_id, narrow_mappings), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE subset_definition_broad_mappings ( + backref_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (backref_id, broad_mappings), + FOREIGN KEY(backref_id) REFERENCES subset_definition (name) +); + +CREATE TABLE type_definition_id_prefixes ( + backref_id TEXT, + id_prefixes TEXT, + PRIMARY KEY (backref_id, id_prefixes), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_todos ( + backref_id TEXT, + todos TEXT, + PRIMARY KEY (backref_id, todos), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_notes ( + backref_id TEXT, + notes TEXT, + PRIMARY KEY (backref_id, notes), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_comments ( + backref_id TEXT, + comments TEXT, + PRIMARY KEY (backref_id, comments), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_see_also ( + backref_id TEXT, + see_also TEXT, + PRIMARY KEY (backref_id, see_also), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_aliases ( + backref_id TEXT, + aliases TEXT, + PRIMARY KEY (backref_id, aliases), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_mappings ( + backref_id TEXT, + mappings TEXT, + PRIMARY KEY (backref_id, mappings), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_exact_mappings ( + backref_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (backref_id, exact_mappings), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_close_mappings ( + backref_id TEXT, + close_mappings TEXT, + PRIMARY KEY (backref_id, close_mappings), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_related_mappings ( + backref_id TEXT, + related_mappings TEXT, + PRIMARY KEY (backref_id, related_mappings), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_narrow_mappings ( + backref_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (backref_id, narrow_mappings), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_broad_mappings ( + backref_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (backref_id, broad_mappings), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE type_definition_equals_string_in ( + backref_id TEXT, + equals_string_in TEXT, + PRIMARY KEY (backref_id, equals_string_in), + FOREIGN KEY(backref_id) REFERENCES type_definition (name) +); + +CREATE TABLE path_expression ( + followed_by TEXT, + none_of TEXT, + any_of TEXT, + all_of TEXT, + exactly_one_of TEXT, + reversed BOOLEAN, + traverse TEXT, + range_expression TEXT, + extensions TEXT, + annotations TEXT, + description TEXT, + alt_descriptions TEXT, + title TEXT, + deprecated TEXT, + todos TEXT, + notes TEXT, + comments TEXT, + examples TEXT, + in_subset TEXT, + from_schema TEXT, + imported_from TEXT, + source TEXT, + in_language TEXT, + see_also TEXT, + deprecated_element_has_exact_replacement TEXT, + deprecated_element_has_possible_replacement TEXT, + aliases TEXT, + structured_aliases TEXT, + mappings TEXT, + exact_mappings TEXT, + close_mappings TEXT, + related_mappings TEXT, + narrow_mappings TEXT, + broad_mappings TEXT, + rank INTEGER, + PRIMARY KEY (followed_by, none_of, any_of, all_of, exactly_one_of, reversed, traverse, range_expression, extensions, annotations, description, alt_descriptions, title, deprecated, todos, notes, comments, examples, in_subset, from_schema, imported_from, source, in_language, see_also, deprecated_element_has_exact_replacement, deprecated_element_has_possible_replacement, aliases, structured_aliases, mappings, exact_mappings, close_mappings, related_mappings, narrow_mappings, broad_mappings, rank), + FOREIGN KEY(traverse) REFERENCES slot_definition (name) +); + +CREATE TABLE prefix ( + prefix_prefix TEXT NOT NULL, + prefix_reference TEXT NOT NULL, + schema_definition_name TEXT, + PRIMARY KEY (prefix_prefix, prefix_reference, schema_definition_name), + FOREIGN KEY(schema_definition_name) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_id_prefixes ( + backref_id TEXT, + id_prefixes TEXT, + PRIMARY KEY (backref_id, id_prefixes), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_todos ( + backref_id TEXT, + todos TEXT, + PRIMARY KEY (backref_id, todos), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_notes ( + backref_id TEXT, + notes TEXT, + PRIMARY KEY (backref_id, notes), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_comments ( + backref_id TEXT, + comments TEXT, + PRIMARY KEY (backref_id, comments), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_see_also ( + backref_id TEXT, + see_also TEXT, + PRIMARY KEY (backref_id, see_also), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_aliases ( + backref_id TEXT, + aliases TEXT, + PRIMARY KEY (backref_id, aliases), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_mappings ( + backref_id TEXT, + mappings TEXT, + PRIMARY KEY (backref_id, mappings), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_exact_mappings ( + backref_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (backref_id, exact_mappings), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_close_mappings ( + backref_id TEXT, + close_mappings TEXT, + PRIMARY KEY (backref_id, close_mappings), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_related_mappings ( + backref_id TEXT, + related_mappings TEXT, + PRIMARY KEY (backref_id, related_mappings), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_narrow_mappings ( + backref_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (backref_id, narrow_mappings), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_broad_mappings ( + backref_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (backref_id, broad_mappings), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_imports ( + backref_id TEXT, + imports TEXT, + PRIMARY KEY (backref_id, imports), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_emit_prefixes ( + backref_id TEXT, + emit_prefixes TEXT, + PRIMARY KEY (backref_id, emit_prefixes), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_default_curi_maps ( + backref_id TEXT, + default_curi_maps TEXT, + PRIMARY KEY (backref_id, default_curi_maps), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_categories ( + backref_id TEXT, + categories TEXT, + PRIMARY KEY (backref_id, categories), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE schema_definition_keywords ( + backref_id TEXT, + keywords TEXT, + PRIMARY KEY (backref_id, keywords), + FOREIGN KEY(backref_id) REFERENCES schema_definition (name) +); + +CREATE TABLE slot_definition_id_prefixes ( + backref_id TEXT, + id_prefixes TEXT, + PRIMARY KEY (backref_id, id_prefixes), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_todos ( + backref_id TEXT, + todos TEXT, + PRIMARY KEY (backref_id, todos), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_notes ( + backref_id TEXT, + notes TEXT, + PRIMARY KEY (backref_id, notes), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_comments ( + backref_id TEXT, + comments TEXT, + PRIMARY KEY (backref_id, comments), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_see_also ( + backref_id TEXT, + see_also TEXT, + PRIMARY KEY (backref_id, see_also), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_aliases ( + backref_id TEXT, + aliases TEXT, + PRIMARY KEY (backref_id, aliases), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_mappings ( + backref_id TEXT, + mappings TEXT, + PRIMARY KEY (backref_id, mappings), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_exact_mappings ( + backref_id TEXT, + exact_mappings TEXT, + PRIMARY KEY (backref_id, exact_mappings), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_close_mappings ( + backref_id TEXT, + close_mappings TEXT, + PRIMARY KEY (backref_id, close_mappings), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_related_mappings ( + backref_id TEXT, + related_mappings TEXT, + PRIMARY KEY (backref_id, related_mappings), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_narrow_mappings ( + backref_id TEXT, + narrow_mappings TEXT, + PRIMARY KEY (backref_id, narrow_mappings), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_broad_mappings ( + backref_id TEXT, + broad_mappings TEXT, + PRIMARY KEY (backref_id, broad_mappings), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_values_from ( + backref_id TEXT, + values_from TEXT, + PRIMARY KEY (backref_id, values_from), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +); + +CREATE TABLE slot_definition_equals_string_in ( + backref_id TEXT, + equals_string_in TEXT, + PRIMARY KEY (backref_id, equals_string_in), + FOREIGN KEY(backref_id) REFERENCES slot_definition (name) +);