# Auto generated from heritage_custodian.yaml by pythongen.py version: 0.0.1 # Generation date: 2025-11-11T23:16:09 # Schema: heritage-custodian # # id: https://w3id.org/heritage/custodian # description: A comprehensive LinkML schema for modeling heritage institutions (GLAM - Galleries, Libraries, Archives, Museums) worldwide. This schema integrates multiple standards including TOOI (Dutch organizational ontology), Schema.org, CPOC (Core Public Organization Vocabulary), ISIL (International Standard Identifier for Libraries), and domain-specific vocabularies (RiC-O, BIBFRAME, LIDO, CIDOC-CRM). # license: https://creativecommons.org/publicdomain/zero/1.0/ import dataclasses import re from dataclasses import dataclass from datetime import ( date, datetime, time ) from typing import ( Any, ClassVar, Dict, List, Optional, Union ) from jsonasobj2 import ( JsonObj, as_dict ) from linkml_runtime.linkml_model.meta import ( EnumDefinition, PermissibleValue, PvFormulaOptions ) from linkml_runtime.utils.curienamespace import CurieNamespace from linkml_runtime.utils.enumerations import EnumDefinitionImpl from linkml_runtime.utils.formatutils import ( camelcase, sfx, underscore ) from linkml_runtime.utils.metamodelcore import ( bnode, empty_dict, empty_list ) from linkml_runtime.utils.slot import Slot from linkml_runtime.utils.yamlutils import ( YAMLRoot, extended_float, extended_int, extended_str ) from rdflib import ( Namespace, URIRef ) from linkml_runtime.linkml_model.types import Boolean, Date, Datetime, Float, Integer, String, Uri, Uriorcurie from linkml_runtime.utils.metamodelcore import Bool, URI, URIorCURIE, XSDDate, XSDDateTime metamodel_version = "1.7.0" version = "0.2.2" # Namespaces ADMS = CurieNamespace('adms', 'http://www.w3.org/ns/adms#') BF = CurieNamespace('bf', 'http://id.loc.gov/ontologies/bibframe/') BIBO = CurieNamespace('bibo', 'http://purl.org/ontology/bibo/') BIRO = CurieNamespace('biro', 'http://purl.org/spar/biro/') CITO = CurieNamespace('cito', 'http://purl.org/spar/cito/') CPOV = CurieNamespace('cpov', 'http://data.europa.eu/m8g/') CRM = CurieNamespace('crm', 'http://www.cidoc-crm.org/cidoc-crm/') DATACITE = CurieNamespace('datacite', 'http://purl.org/spar/datacite/') DCTERMS = CurieNamespace('dcterms', 'http://purl.org/dc/terms/') DOCO = CurieNamespace('doco', 'http://purl.org/spar/doco/') EDM = CurieNamespace('edm', 'http://www.europeana.eu/schemas/edm/') FABIO = CurieNamespace('fabio', 'http://purl.org/spar/fabio/') FOAF = CurieNamespace('foaf', 'http://xmlns.com/foaf/0.1/') FRBR = CurieNamespace('frbr', 'http://purl.org/vocab/frbr/core#') GEONAMES = CurieNamespace('geonames', 'http://www.geonames.org/ontology#') HERITAGE = CurieNamespace('heritage', 'https://w3id.org/heritage/custodian/') LINKML = CurieNamespace('linkml', 'https://w3id.org/linkml/') ORE = CurieNamespace('ore', 'http://www.openarchives.org/ore/terms/') ORG = CurieNamespace('org', 'http://www.w3.org/ns/org#') OWL = CurieNamespace('owl', 'http://www.w3.org/2002/07/owl#') PRISM = CurieNamespace('prism', 'http://prismstandard.org/namespaces/basic/3.0/') PRO = CurieNamespace('pro', 'http://purl.org/spar/pro/') PROV = CurieNamespace('prov', 'http://www.w3.org/ns/prov#') PSO = CurieNamespace('pso', 'http://purl.org/spar/pso/') RDF = CurieNamespace('rdf', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#') RDFS = CurieNamespace('rdfs', 'http://www.w3.org/2000/01/rdf-schema#') RICO = CurieNamespace('rico', 'https://www.ica.org/standards/RiC/ontology#') SCHEMA = CurieNamespace('schema', 'http://schema.org/') SKOS = CurieNamespace('skos', 'http://www.w3.org/2004/02/skos/core#') TOOI = CurieNamespace('tooi', 'http://standaarden.overheid.nl/tooi/def/') TOOIONT = CurieNamespace('tooiont', 'https://identifier.overheid.nl/tooi/def/ont/') VIAF = CurieNamespace('viaf', 'http://viaf.org/viaf/') WIKIDATA = CurieNamespace('wikidata', 'http://www.wikidata.org/entity/') XSD = CurieNamespace('xsd', 'http://www.w3.org/2001/XMLSchema#') DEFAULT_ = HERITAGE # Types # Class references class HeritageCustodianId(URIorCURIE): pass class OrganizationalUnitUnitId(URIorCURIE): pass class ChangeEventEventId(URIorCURIE): pass class DutchHeritageCustodianId(HeritageCustodianId): pass class ScholarlyWorkWorkId(URIorCURIE): pass class PublicationPublicationId(URIorCURIE): pass class JournalJournalId(URIorCURIE): pass class ConferenceConferenceId(URIorCURIE): pass class PersonPersonId(URIorCURIE): pass class OrganizationOrganizationId(URIorCURIE): pass class CitationCitationId(URIorCURIE): pass class DocumentSectionSectionId(URIorCURIE): pass class SchemaContactPoint(YAMLRoot): """ Local proxy for schema:ContactPoint. Represents contact information (phone, email, etc.) for an organization. Used as mixin for ContactInfo. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = SCHEMA["ContactPoint"] class_class_curie: ClassVar[str] = "schema:ContactPoint" class_name: ClassVar[str] = "SchemaContactPoint" class_model_uri: ClassVar[URIRef] = HERITAGE.SchemaContactPoint @dataclass(repr=False) class HeritageCustodian(YAMLRoot): """ A heritage custodian organization (GLAM institution) responsible for preserving, managing, and providing access to cultural heritage collections. Integrates W3C Org Ontology, PROV-O provenance tracking, and TOOI temporal patterns. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = ORG["Organization"] class_class_curie: ClassVar[str] = "org:Organization" class_name: ClassVar[str] = "HeritageCustodian" class_model_uri: ClassVar[URIRef] = HERITAGE.HeritageCustodian id: Union[str, HeritageCustodianId] = None name: str = None institution_type: Union[str, "InstitutionTypeEnum"] = None provenance: Union[dict, "Provenance"] = None record_id: Optional[str] = None ghcid_uuid: Optional[str] = None ghcid_uuid_sha256: Optional[str] = None ghcid_numeric: Optional[int] = None ghcid_current: Optional[str] = None ghcid_original: Optional[str] = None ghcid_history: Optional[Union[Union[dict, "GHCIDHistoryEntry"], list[Union[dict, "GHCIDHistoryEntry"]]]] = empty_list() alternative_names: Optional[Union[str, list[str]]] = empty_list() official_name: Optional[str] = None sorting_name: Optional[str] = None abbreviation: Optional[str] = None organization_status: Optional[Union[str, "OrganizationStatusEnum"]] = None description: Optional[str] = None parent_organization: Optional[Union[str, HeritageCustodianId]] = None parent_organization_name: Optional[str] = None sub_organizations: Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]] = empty_list() founded_date: Optional[Union[str, XSDDate]] = None closed_date: Optional[Union[str, XSDDate]] = None prov_generated_at: Optional[Union[str, XSDDateTime]] = None prov_invalidated_at: Optional[Union[str, XSDDateTime]] = None change_history: Optional[Union[dict[Union[str, ChangeEventEventId], Union[dict, "ChangeEvent"]], list[Union[dict, "ChangeEvent"]]]] = empty_dict() homepage: Optional[Union[str, URI]] = None contact_info: Optional[Union[dict, "ContactInfo"]] = None locations: Optional[Union[Union[dict, "Location"], list[Union[dict, "Location"]]]] = empty_list() identifiers: Optional[Union[Union[dict, "Identifier"], list[Union[dict, "Identifier"]]]] = empty_list() chamber_of_commerce_number: Optional[str] = None municipality_identifier: Optional[str] = None collections: Optional[Union[Union[dict, "Collection"], list[Union[dict, "Collection"]]]] = empty_list() digital_platforms: Optional[Union[Union[dict, "DigitalPlatform"], list[Union[dict, "DigitalPlatform"]]]] = empty_list() metadata_standards: Optional[Union[Union[str, "MetadataStandardEnum"], list[Union[str, "MetadataStandardEnum"]]]] = empty_list() partnerships: Optional[Union[Union[dict, "Partnership"], list[Union[dict, "Partnership"]]]] = empty_list() publications: Optional[Union[dict[Union[str, PublicationPublicationId], Union[dict, "Publication"]], list[Union[dict, "Publication"]]]] = empty_dict() def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.id): self.MissingRequiredField("id") if not isinstance(self.id, HeritageCustodianId): self.id = HeritageCustodianId(self.id) if self._is_empty(self.name): self.MissingRequiredField("name") if not isinstance(self.name, str): self.name = str(self.name) if self._is_empty(self.institution_type): self.MissingRequiredField("institution_type") if not isinstance(self.institution_type, InstitutionTypeEnum): self.institution_type = InstitutionTypeEnum(self.institution_type) if self._is_empty(self.provenance): self.MissingRequiredField("provenance") if not isinstance(self.provenance, Provenance): self.provenance = Provenance(**as_dict(self.provenance)) if self.record_id is not None and not isinstance(self.record_id, str): self.record_id = str(self.record_id) if self.ghcid_uuid is not None and not isinstance(self.ghcid_uuid, str): self.ghcid_uuid = str(self.ghcid_uuid) if self.ghcid_uuid_sha256 is not None and not isinstance(self.ghcid_uuid_sha256, str): self.ghcid_uuid_sha256 = str(self.ghcid_uuid_sha256) if self.ghcid_numeric is not None and not isinstance(self.ghcid_numeric, int): self.ghcid_numeric = int(self.ghcid_numeric) if self.ghcid_current is not None and not isinstance(self.ghcid_current, str): self.ghcid_current = str(self.ghcid_current) if self.ghcid_original is not None and not isinstance(self.ghcid_original, str): self.ghcid_original = str(self.ghcid_original) if not isinstance(self.ghcid_history, list): self.ghcid_history = [self.ghcid_history] if self.ghcid_history is not None else [] self.ghcid_history = [v if isinstance(v, GHCIDHistoryEntry) else GHCIDHistoryEntry(**as_dict(v)) for v in self.ghcid_history] if not isinstance(self.alternative_names, list): self.alternative_names = [self.alternative_names] if self.alternative_names is not None else [] self.alternative_names = [v if isinstance(v, str) else str(v) for v in self.alternative_names] if self.official_name is not None and not isinstance(self.official_name, str): self.official_name = str(self.official_name) if self.sorting_name is not None and not isinstance(self.sorting_name, str): self.sorting_name = str(self.sorting_name) if self.abbreviation is not None and not isinstance(self.abbreviation, str): self.abbreviation = str(self.abbreviation) if self.organization_status is not None and not isinstance(self.organization_status, OrganizationStatusEnum): self.organization_status = OrganizationStatusEnum(self.organization_status) if self.description is not None and not isinstance(self.description, str): self.description = str(self.description) if self.parent_organization is not None and not isinstance(self.parent_organization, HeritageCustodianId): self.parent_organization = HeritageCustodianId(self.parent_organization) if self.parent_organization_name is not None and not isinstance(self.parent_organization_name, str): self.parent_organization_name = str(self.parent_organization_name) if not isinstance(self.sub_organizations, list): self.sub_organizations = [self.sub_organizations] if self.sub_organizations is not None else [] self.sub_organizations = [v if isinstance(v, HeritageCustodianId) else HeritageCustodianId(v) for v in self.sub_organizations] if self.founded_date is not None and not isinstance(self.founded_date, XSDDate): self.founded_date = XSDDate(self.founded_date) if self.closed_date is not None and not isinstance(self.closed_date, XSDDate): self.closed_date = XSDDate(self.closed_date) if self.prov_generated_at is not None and not isinstance(self.prov_generated_at, XSDDateTime): self.prov_generated_at = XSDDateTime(self.prov_generated_at) if self.prov_invalidated_at is not None and not isinstance(self.prov_invalidated_at, XSDDateTime): self.prov_invalidated_at = XSDDateTime(self.prov_invalidated_at) self._normalize_inlined_as_list(slot_name="change_history", slot_type=ChangeEvent, key_name="event_id", keyed=True) if self.homepage is not None and not isinstance(self.homepage, URI): self.homepage = URI(self.homepage) if self.contact_info is not None and not isinstance(self.contact_info, ContactInfo): self.contact_info = ContactInfo(**as_dict(self.contact_info)) if not isinstance(self.locations, list): self.locations = [self.locations] if self.locations is not None else [] self.locations = [v if isinstance(v, Location) else Location(**as_dict(v)) for v in self.locations] if not isinstance(self.identifiers, list): self.identifiers = [self.identifiers] if self.identifiers is not None else [] self.identifiers = [v if isinstance(v, Identifier) else Identifier(**as_dict(v)) for v in self.identifiers] if self.chamber_of_commerce_number is not None and not isinstance(self.chamber_of_commerce_number, str): self.chamber_of_commerce_number = str(self.chamber_of_commerce_number) if self.municipality_identifier is not None and not isinstance(self.municipality_identifier, str): self.municipality_identifier = str(self.municipality_identifier) if not isinstance(self.collections, list): self.collections = [self.collections] if self.collections is not None else [] self.collections = [v if isinstance(v, Collection) else Collection(**as_dict(v)) for v in self.collections] if not isinstance(self.digital_platforms, list): self.digital_platforms = [self.digital_platforms] if self.digital_platforms is not None else [] self.digital_platforms = [v if isinstance(v, DigitalPlatform) else DigitalPlatform(**as_dict(v)) for v in self.digital_platforms] if not isinstance(self.metadata_standards, list): self.metadata_standards = [self.metadata_standards] if self.metadata_standards is not None else [] self.metadata_standards = [v if isinstance(v, MetadataStandardEnum) else MetadataStandardEnum(v) for v in self.metadata_standards] if not isinstance(self.partnerships, list): self.partnerships = [self.partnerships] if self.partnerships is not None else [] self.partnerships = [v if isinstance(v, Partnership) else Partnership(**as_dict(v)) for v in self.partnerships] self._normalize_inlined_as_list(slot_name="publications", slot_type=Publication, key_name="publication_id", keyed=True) super().__post_init__(**kwargs) @dataclass(repr=False) class Location(YAMLRoot): """ Physical or virtual location associated with an organization """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = SCHEMA["Place"] class_class_curie: ClassVar[str] = "schema:Place" class_name: ClassVar[str] = "Location" class_model_uri: ClassVar[URIRef] = HERITAGE.Location location_type: Optional[str] = None street_address: Optional[str] = None city: Optional[str] = None postal_code: Optional[str] = None region: Optional[str] = None country: Optional[str] = None latitude: Optional[float] = None longitude: Optional[float] = None geonames_id: Optional[str] = None is_primary: Optional[Union[bool, Bool]] = None def __post_init__(self, *_: str, **kwargs: Any): if self.location_type is not None and not isinstance(self.location_type, str): self.location_type = str(self.location_type) if self.street_address is not None and not isinstance(self.street_address, str): self.street_address = str(self.street_address) if self.city is not None and not isinstance(self.city, str): self.city = str(self.city) if self.postal_code is not None and not isinstance(self.postal_code, str): self.postal_code = str(self.postal_code) if self.region is not None and not isinstance(self.region, str): self.region = str(self.region) if self.country is not None and not isinstance(self.country, str): self.country = str(self.country) if self.latitude is not None and not isinstance(self.latitude, float): self.latitude = float(self.latitude) if self.longitude is not None and not isinstance(self.longitude, float): self.longitude = float(self.longitude) if self.geonames_id is not None and not isinstance(self.geonames_id, str): self.geonames_id = str(self.geonames_id) if self.is_primary is not None and not isinstance(self.is_primary, Bool): self.is_primary = Bool(self.is_primary) super().__post_init__(**kwargs) @dataclass(repr=False) class ContactInfo(YAMLRoot): """ Contact information for the organization. Maps to both Schema.org ContactPoint and EU CPOV ContactPoint. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = CPOV["ContactPoint"] class_class_curie: ClassVar[str] = "cpov:ContactPoint" class_name: ClassVar[str] = "ContactInfo" class_model_uri: ClassVar[URIRef] = HERITAGE.ContactInfo email: Optional[str] = None phone: Optional[str] = None fax: Optional[str] = None contact_type: Optional[str] = None def __post_init__(self, *_: str, **kwargs: Any): if self.email is not None and not isinstance(self.email, str): self.email = str(self.email) if self.phone is not None and not isinstance(self.phone, str): self.phone = str(self.phone) if self.fax is not None and not isinstance(self.fax, str): self.fax = str(self.fax) if self.contact_type is not None and not isinstance(self.contact_type, str): self.contact_type = str(self.contact_type) super().__post_init__(**kwargs) @dataclass(repr=False) class Identifier(YAMLRoot): """ External identifier for the organization """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = DCTERMS["identifier"] class_class_curie: ClassVar[str] = "dcterms:identifier" class_name: ClassVar[str] = "Identifier" class_model_uri: ClassVar[URIRef] = HERITAGE.Identifier identifier_scheme: str = None identifier_value: str = None identifier_url: Optional[Union[str, URI]] = None assigned_date: Optional[Union[str, XSDDate]] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.identifier_scheme): self.MissingRequiredField("identifier_scheme") if not isinstance(self.identifier_scheme, str): self.identifier_scheme = str(self.identifier_scheme) if self._is_empty(self.identifier_value): self.MissingRequiredField("identifier_value") if not isinstance(self.identifier_value, str): self.identifier_value = str(self.identifier_value) if self.identifier_url is not None and not isinstance(self.identifier_url, URI): self.identifier_url = URI(self.identifier_url) if self.assigned_date is not None and not isinstance(self.assigned_date, XSDDate): self.assigned_date = XSDDate(self.assigned_date) super().__post_init__(**kwargs) @dataclass(repr=False) class OrganizationalUnit(YAMLRoot): """ A sub-unit, department, or division within a heritage institution. Examples: Conservation department, Special Collections, Reading Room. Uses W3C Org Ontology patterns for organizational structure. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = ORG["OrganizationalUnit"] class_class_curie: ClassVar[str] = "org:OrganizationalUnit" class_name: ClassVar[str] = "OrganizationalUnit" class_model_uri: ClassVar[URIRef] = HERITAGE.OrganizationalUnit unit_id: Union[str, OrganizationalUnitUnitId] = None unit_name: str = None unit_type: Optional[str] = None parent_unit: Optional[Union[str, OrganizationalUnitUnitId]] = None description: Optional[str] = None contact_info: Optional[Union[dict, ContactInfo]] = None homepage: Optional[Union[str, URI]] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.unit_id): self.MissingRequiredField("unit_id") if not isinstance(self.unit_id, OrganizationalUnitUnitId): self.unit_id = OrganizationalUnitUnitId(self.unit_id) if self._is_empty(self.unit_name): self.MissingRequiredField("unit_name") if not isinstance(self.unit_name, str): self.unit_name = str(self.unit_name) if self.unit_type is not None and not isinstance(self.unit_type, str): self.unit_type = str(self.unit_type) if self.parent_unit is not None and not isinstance(self.parent_unit, OrganizationalUnitUnitId): self.parent_unit = OrganizationalUnitUnitId(self.parent_unit) if self.description is not None and not isinstance(self.description, str): self.description = str(self.description) if self.contact_info is not None and not isinstance(self.contact_info, ContactInfo): self.contact_info = ContactInfo(**as_dict(self.contact_info)) if self.homepage is not None and not isinstance(self.homepage, URI): self.homepage = URI(self.homepage) super().__post_init__(**kwargs) class ProvenanceEntity(YAMLRoot): """ Local proxy for prov:Entity. Represents a physical, digital, conceptual, or other kind of thing with fixed aspects. Used as mixin for classes that need PROV-O alignment (e.g., HeritageCustodian). """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = PROV["Entity"] class_class_curie: ClassVar[str] = "prov:Entity" class_name: ClassVar[str] = "ProvenanceEntity" class_model_uri: ClassVar[URIRef] = HERITAGE.ProvenanceEntity class ProvenanceActivity(YAMLRoot): """ Local proxy for prov:Activity. Represents something that occurs over a period of time and acts upon or with entities. Used as base for ChangeEvent. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = PROV["Activity"] class_class_curie: ClassVar[str] = "prov:Activity" class_name: ClassVar[str] = "ProvenanceActivity" class_model_uri: ClassVar[URIRef] = HERITAGE.ProvenanceActivity class TOOIWijzigingsgebeurtenis(YAMLRoot): """ Local proxy for tooi:Wijzigingsgebeurtenis (Change Event in TOOI ontology). Represents organizational change events in Dutch government organizations. Used as mixin for ChangeEvent to align with TOOI patterns. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = TOOIONT["Wijzigingsgebeurtenis"] class_class_curie: ClassVar[str] = "tooi:Wijzigingsgebeurtenis" class_name: ClassVar[str] = "TOOIWijzigingsgebeurtenis" class_model_uri: ClassVar[URIRef] = HERITAGE.TOOIWijzigingsgebeurtenis @dataclass(repr=False) class Provenance(YAMLRoot): """ Provenance information for data quality tracking """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = HERITAGE["Provenance"] class_class_curie: ClassVar[str] = "heritage:Provenance" class_name: ClassVar[str] = "Provenance" class_model_uri: ClassVar[URIRef] = HERITAGE.Provenance data_source: Union[str, "DataSourceEnum"] = None data_tier: Union[str, "DataTierEnum"] = None extraction_date: Union[str, XSDDateTime] = None extraction_method: Optional[str] = None confidence_score: Optional[float] = None conversation_id: Optional[str] = None source_url: Optional[Union[str, URI]] = None verified_date: Optional[Union[str, XSDDateTime]] = None verified_by: Optional[str] = None enrichment_history: Optional[Union[Union[dict, "EnrichmentHistoryEntry"], list[Union[dict, "EnrichmentHistoryEntry"]]]] = empty_list() provenance_notes: Optional[str] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.data_source): self.MissingRequiredField("data_source") if not isinstance(self.data_source, DataSourceEnum): self.data_source = DataSourceEnum(self.data_source) if self._is_empty(self.data_tier): self.MissingRequiredField("data_tier") if not isinstance(self.data_tier, DataTierEnum): self.data_tier = DataTierEnum(self.data_tier) if self._is_empty(self.extraction_date): self.MissingRequiredField("extraction_date") if not isinstance(self.extraction_date, XSDDateTime): self.extraction_date = XSDDateTime(self.extraction_date) if self.extraction_method is not None and not isinstance(self.extraction_method, str): self.extraction_method = str(self.extraction_method) if self.confidence_score is not None and not isinstance(self.confidence_score, float): self.confidence_score = float(self.confidence_score) if self.conversation_id is not None and not isinstance(self.conversation_id, str): self.conversation_id = str(self.conversation_id) if self.source_url is not None and not isinstance(self.source_url, URI): self.source_url = URI(self.source_url) if self.verified_date is not None and not isinstance(self.verified_date, XSDDateTime): self.verified_date = XSDDateTime(self.verified_date) if self.verified_by is not None and not isinstance(self.verified_by, str): self.verified_by = str(self.verified_by) if not isinstance(self.enrichment_history, list): self.enrichment_history = [self.enrichment_history] if self.enrichment_history is not None else [] self.enrichment_history = [v if isinstance(v, EnrichmentHistoryEntry) else EnrichmentHistoryEntry(**as_dict(v)) for v in self.enrichment_history] if self.provenance_notes is not None and not isinstance(self.provenance_notes, str): self.provenance_notes = str(self.provenance_notes) super().__post_init__(**kwargs) @dataclass(repr=False) class EnrichmentHistoryEntry(YAMLRoot): """ Record of a data enrichment activity (e.g., Wikidata lookup, geocoding, identifier resolution). Tracks what was enriched, when, how, and with what quality metrics. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = HERITAGE["EnrichmentHistoryEntry"] class_class_curie: ClassVar[str] = "heritage:EnrichmentHistoryEntry" class_name: ClassVar[str] = "EnrichmentHistoryEntry" class_model_uri: ClassVar[URIRef] = HERITAGE.EnrichmentHistoryEntry enrichment_date: Union[str, XSDDateTime] = None enrichment_method: str = None enrichment_type: Union[str, "EnrichmentTypeEnum"] = None verified: Union[bool, Bool] = None match_score: Optional[float] = None enrichment_source: Optional[Union[str, URI]] = None enrichment_notes: Optional[str] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.enrichment_date): self.MissingRequiredField("enrichment_date") if not isinstance(self.enrichment_date, XSDDateTime): self.enrichment_date = XSDDateTime(self.enrichment_date) if self._is_empty(self.enrichment_method): self.MissingRequiredField("enrichment_method") if not isinstance(self.enrichment_method, str): self.enrichment_method = str(self.enrichment_method) if self._is_empty(self.enrichment_type): self.MissingRequiredField("enrichment_type") if not isinstance(self.enrichment_type, EnrichmentTypeEnum): self.enrichment_type = EnrichmentTypeEnum(self.enrichment_type) if self._is_empty(self.verified): self.MissingRequiredField("verified") if not isinstance(self.verified, Bool): self.verified = Bool(self.verified) if self.match_score is not None and not isinstance(self.match_score, float): self.match_score = float(self.match_score) if self.enrichment_source is not None and not isinstance(self.enrichment_source, URI): self.enrichment_source = URI(self.enrichment_source) if self.enrichment_notes is not None and not isinstance(self.enrichment_notes, str): self.enrichment_notes = str(self.enrichment_notes) super().__post_init__(**kwargs) @dataclass(repr=False) class GHCIDHistoryEntry(YAMLRoot): """ Historical record tracking GHCID changes over time. Each entry represents a period when a specific GHCID was valid for this institution. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = HERITAGE["GHCIDHistoryEntry"] class_class_curie: ClassVar[str] = "heritage:GHCIDHistoryEntry" class_name: ClassVar[str] = "GHCIDHistoryEntry" class_model_uri: ClassVar[URIRef] = HERITAGE.GHCIDHistoryEntry ghcid: str = None ghcid_numeric: int = None valid_from: Union[str, XSDDateTime] = None reason: str = None institution_name: str = None location_city: str = None location_country: str = None valid_to: Optional[Union[str, XSDDateTime]] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.ghcid): self.MissingRequiredField("ghcid") if not isinstance(self.ghcid, str): self.ghcid = str(self.ghcid) if self._is_empty(self.ghcid_numeric): self.MissingRequiredField("ghcid_numeric") if not isinstance(self.ghcid_numeric, int): self.ghcid_numeric = int(self.ghcid_numeric) if self._is_empty(self.valid_from): self.MissingRequiredField("valid_from") if not isinstance(self.valid_from, XSDDateTime): self.valid_from = XSDDateTime(self.valid_from) if self._is_empty(self.reason): self.MissingRequiredField("reason") if not isinstance(self.reason, str): self.reason = str(self.reason) if self._is_empty(self.institution_name): self.MissingRequiredField("institution_name") if not isinstance(self.institution_name, str): self.institution_name = str(self.institution_name) if self._is_empty(self.location_city): self.MissingRequiredField("location_city") if not isinstance(self.location_city, str): self.location_city = str(self.location_city) if self._is_empty(self.location_country): self.MissingRequiredField("location_country") if not isinstance(self.location_country, str): self.location_country = str(self.location_country) if self.valid_to is not None and not isinstance(self.valid_to, XSDDateTime): self.valid_to = XSDDateTime(self.valid_to) super().__post_init__(**kwargs) @dataclass(repr=False) class ChangeEvent(ProvenanceActivity): """ A significant organizational change event in an institution's lifecycle. Based on TOOI Wijzigingsgebeurtenis and W3C PROV-O Activity patterns. Tracks mergers, name changes, relocations, and other structural changes. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = HERITAGE["ChangeEvent"] class_class_curie: ClassVar[str] = "heritage:ChangeEvent" class_name: ClassVar[str] = "ChangeEvent" class_model_uri: ClassVar[URIRef] = HERITAGE.ChangeEvent event_id: Union[str, ChangeEventEventId] = None change_type: Union[str, "ChangeTypeEnum"] = None event_date: Union[str, XSDDate] = None event_description: Optional[str] = None affected_organization: Optional[Union[str, HeritageCustodianId]] = None resulting_organization: Optional[Union[str, HeritageCustodianId]] = None related_organizations: Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]] = empty_list() source_documentation: Optional[Union[str, URI]] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.event_id): self.MissingRequiredField("event_id") if not isinstance(self.event_id, ChangeEventEventId): self.event_id = ChangeEventEventId(self.event_id) if self._is_empty(self.change_type): self.MissingRequiredField("change_type") if not isinstance(self.change_type, ChangeTypeEnum): self.change_type = ChangeTypeEnum(self.change_type) if self._is_empty(self.event_date): self.MissingRequiredField("event_date") if not isinstance(self.event_date, XSDDate): self.event_date = XSDDate(self.event_date) if self.event_description is not None and not isinstance(self.event_description, str): self.event_description = str(self.event_description) if self.affected_organization is not None and not isinstance(self.affected_organization, HeritageCustodianId): self.affected_organization = HeritageCustodianId(self.affected_organization) if self.resulting_organization is not None and not isinstance(self.resulting_organization, HeritageCustodianId): self.resulting_organization = HeritageCustodianId(self.resulting_organization) if not isinstance(self.related_organizations, list): self.related_organizations = [self.related_organizations] if self.related_organizations is not None else [] self.related_organizations = [v if isinstance(v, HeritageCustodianId) else HeritageCustodianId(v) for v in self.related_organizations] if self.source_documentation is not None and not isinstance(self.source_documentation, URI): self.source_documentation = URI(self.source_documentation) super().__post_init__(**kwargs) class RiCRecordSet(YAMLRoot): """ Local proxy for rico:RecordSet. Represents an aggregation of archival records with a common provenance or assembled for a specific purpose. Used as mixin for Collection class to align with RiC-O archival description standards. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = RICO["RecordSet"] class_class_curie: ClassVar[str] = "rico:RecordSet" class_name: ClassVar[str] = "RiCRecordSet" class_model_uri: ClassVar[URIRef] = HERITAGE.RiCRecordSet @dataclass(repr=False) class Collection(YAMLRoot): """ A collection held by the heritage custodian. Maps to RiC-O RecordSet for archives, BIBFRAME Collection for libraries, and Schema.org Collection for general use. Implements rico:hasOrHadHolder to link back to custodial organization. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = SCHEMA["Collection"] class_class_curie: ClassVar[str] = "schema:Collection" class_name: ClassVar[str] = "Collection" class_model_uri: ClassVar[URIRef] = HERITAGE.Collection collection_id: Optional[str] = None collection_name: Optional[str] = None collection_description: Optional[str] = None collection_type: Optional[str] = None item_count: Optional[str] = None subjects: Optional[Union[str, list[str]]] = empty_list() time_period_start: Optional[Union[str, XSDDate]] = None time_period_end: Optional[Union[str, XSDDate]] = None temporal_coverage: Optional[str] = None access_rights: Optional[str] = None catalog_url: Optional[Union[str, URI]] = None custodian: Optional[Union[str, HeritageCustodianId]] = None def __post_init__(self, *_: str, **kwargs: Any): if self.collection_id is not None and not isinstance(self.collection_id, str): self.collection_id = str(self.collection_id) if self.collection_name is not None and not isinstance(self.collection_name, str): self.collection_name = str(self.collection_name) if self.collection_description is not None and not isinstance(self.collection_description, str): self.collection_description = str(self.collection_description) if self.collection_type is not None and not isinstance(self.collection_type, str): self.collection_type = str(self.collection_type) if self.item_count is not None and not isinstance(self.item_count, str): self.item_count = str(self.item_count) if not isinstance(self.subjects, list): self.subjects = [self.subjects] if self.subjects is not None else [] self.subjects = [v if isinstance(v, str) else str(v) for v in self.subjects] if self.time_period_start is not None and not isinstance(self.time_period_start, XSDDate): self.time_period_start = XSDDate(self.time_period_start) if self.time_period_end is not None and not isinstance(self.time_period_end, XSDDate): self.time_period_end = XSDDate(self.time_period_end) if self.temporal_coverage is not None and not isinstance(self.temporal_coverage, str): self.temporal_coverage = str(self.temporal_coverage) if self.access_rights is not None and not isinstance(self.access_rights, str): self.access_rights = str(self.access_rights) if self.catalog_url is not None and not isinstance(self.catalog_url, URI): self.catalog_url = URI(self.catalog_url) if self.custodian is not None and not isinstance(self.custodian, HeritageCustodianId): self.custodian = HeritageCustodianId(self.custodian) super().__post_init__(**kwargs) @dataclass(repr=False) class DigitalPlatform(YAMLRoot): """ Digital platform or system used by the institution """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = SCHEMA["SoftwareApplication"] class_class_curie: ClassVar[str] = "schema:SoftwareApplication" class_name: ClassVar[str] = "DigitalPlatform" class_model_uri: ClassVar[URIRef] = HERITAGE.DigitalPlatform platform_name: Optional[str] = None platform_type: Optional[Union[str, "DigitalPlatformTypeEnum"]] = None platform_url: Optional[Union[str, URI]] = None platform_description: Optional[str] = None vendor: Optional[str] = None integration_method: Optional[str] = None implemented_standards: Optional[Union[Union[str, "MetadataStandardEnum"], list[Union[str, "MetadataStandardEnum"]]]] = empty_list() def __post_init__(self, *_: str, **kwargs: Any): if self.platform_name is not None and not isinstance(self.platform_name, str): self.platform_name = str(self.platform_name) if self.platform_type is not None and not isinstance(self.platform_type, DigitalPlatformTypeEnum): self.platform_type = DigitalPlatformTypeEnum(self.platform_type) if self.platform_url is not None and not isinstance(self.platform_url, URI): self.platform_url = URI(self.platform_url) if self.platform_description is not None and not isinstance(self.platform_description, str): self.platform_description = str(self.platform_description) if self.vendor is not None and not isinstance(self.vendor, str): self.vendor = str(self.vendor) if self.integration_method is not None and not isinstance(self.integration_method, str): self.integration_method = str(self.integration_method) if not isinstance(self.implemented_standards, list): self.implemented_standards = [self.implemented_standards] if self.implemented_standards is not None else [] self.implemented_standards = [v if isinstance(v, MetadataStandardEnum) else MetadataStandardEnum(v) for v in self.implemented_standards] super().__post_init__(**kwargs) @dataclass(repr=False) class Partnership(YAMLRoot): """ Partnership or network membership """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = ORG["Membership"] class_class_curie: ClassVar[str] = "org:Membership" class_name: ClassVar[str] = "Partnership" class_model_uri: ClassVar[URIRef] = HERITAGE.Partnership partner_name: Optional[str] = None partner_id: Optional[Union[str, URIorCURIE]] = None partnership_type: Optional[str] = None start_date: Optional[Union[str, XSDDate]] = None end_date: Optional[Union[str, XSDDate]] = None description: Optional[str] = None def __post_init__(self, *_: str, **kwargs: Any): if self.partner_name is not None and not isinstance(self.partner_name, str): self.partner_name = str(self.partner_name) if self.partner_id is not None and not isinstance(self.partner_id, URIorCURIE): self.partner_id = URIorCURIE(self.partner_id) if self.partnership_type is not None and not isinstance(self.partnership_type, str): self.partnership_type = str(self.partnership_type) if self.start_date is not None and not isinstance(self.start_date, XSDDate): self.start_date = XSDDate(self.start_date) if self.end_date is not None and not isinstance(self.end_date, XSDDate): self.end_date = XSDDate(self.end_date) if self.description is not None and not isinstance(self.description, str): self.description = str(self.description) super().__post_init__(**kwargs) class TOOIOverheidsorganisatie(YAMLRoot): """ Local proxy for tooi:Overheidsorganisatie (Government Organization in TOOI ontology). Represents Dutch public sector organizations with government affiliation. Used as mixin for DutchHeritageCustodian to align with TOOI patterns. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = TOOIONT["Overheidsorganisatie"] class_class_curie: ClassVar[str] = "tooi:Overheidsorganisatie" class_name: ClassVar[str] = "TOOIOverheidsorganisatie" class_model_uri: ClassVar[URIRef] = HERITAGE.TOOIOverheidsorganisatie @dataclass(repr=False) class DutchHeritageCustodian(HeritageCustodian): """ A heritage custodian organization based in the Netherlands, with additional Dutch-specific identification and organizational metadata. Integrates with TOOI (Thesaurus Overheidsorganisaties) for public sector organizations. Network memberships and thematic partnerships are represented using the universal Partnership class (not Dutch-specific boolean flags). """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = HERITAGE["DutchHeritageCustodian"] class_class_curie: ClassVar[str] = "heritage:DutchHeritageCustodian" class_name: ClassVar[str] = "DutchHeritageCustodian" class_model_uri: ClassVar[URIRef] = HERITAGE.DutchHeritageCustodian id: Union[str, DutchHeritageCustodianId] = None name: str = None institution_type: Union[str, "InstitutionTypeEnum"] = None provenance: Union[dict, Provenance] = None kvk_number: Optional[str] = None gemeente_code: Optional[str] = None identifiers: Optional[Union[Union[dict, Identifier], list[Union[dict, Identifier]]]] = empty_list() partnerships: Optional[Union[Union[dict, Partnership], list[Union[dict, Partnership]]]] = empty_list() locations: Optional[Union[Union[dict, Location], list[Union[dict, Location]]]] = empty_list() def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.id): self.MissingRequiredField("id") if not isinstance(self.id, DutchHeritageCustodianId): self.id = DutchHeritageCustodianId(self.id) if self.kvk_number is not None and not isinstance(self.kvk_number, str): self.kvk_number = str(self.kvk_number) if self.gemeente_code is not None and not isinstance(self.gemeente_code, str): self.gemeente_code = str(self.gemeente_code) if not isinstance(self.identifiers, list): self.identifiers = [self.identifiers] if self.identifiers is not None else [] self.identifiers = [v if isinstance(v, Identifier) else Identifier(**as_dict(v)) for v in self.identifiers] if not isinstance(self.partnerships, list): self.partnerships = [self.partnerships] if self.partnerships is not None else [] self.partnerships = [v if isinstance(v, Partnership) else Partnership(**as_dict(v)) for v in self.partnerships] if not isinstance(self.locations, list): self.locations = [self.locations] if self.locations is not None else [] self.locations = [v if isinstance(v, Location) else Location(**as_dict(v)) for v in self.locations] super().__post_init__(**kwargs) class FRBRWork(YAMLRoot): """ Local proxy for frbr:Work (FRBR Work entity). Represents the abstract intellectual essence of a work, independent of any specific expression, manifestation, or item. Used as mixin for ScholarlyWork. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = FRBR["Work"] class_class_curie: ClassVar[str] = "frbr:Work" class_name: ClassVar[str] = "FRBRWork" class_model_uri: ClassVar[URIRef] = HERITAGE.FRBRWork class FRBRExpression(YAMLRoot): """ Local proxy for frbr:Expression (FRBR Expression entity). Represents a specific intellectual or artistic realization of a work (e.g., the English translation, the revised edition). Used as mixin for Publication. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = FRBR["Expression"] class_class_curie: ClassVar[str] = "frbr:Expression" class_name: ClassVar[str] = "FRBRExpression" class_model_uri: ClassVar[URIRef] = HERITAGE.FRBRExpression class BiBOJournal(YAMLRoot): """ Local proxy for bibo:Journal (Bibliographic Ontology Journal class). Represents a scholarly journal or periodical publication. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = BIBO["Journal"] class_class_curie: ClassVar[str] = "bibo:Journal" class_name: ClassVar[str] = "BiBOJournal" class_model_uri: ClassVar[URIRef] = HERITAGE.BiBOJournal class BiBOConference(YAMLRoot): """ Local proxy for bibo:Conference (Bibliographic Ontology Conference class). Represents an academic conference or symposium. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = BIBO["Conference"] class_class_curie: ClassVar[str] = "bibo:Conference" class_name: ClassVar[str] = "BiBOConference" class_model_uri: ClassVar[URIRef] = HERITAGE.BiBOConference class BiBOBibliographicReference(YAMLRoot): """ Local proxy for biro:BibliographicReference (BiRO bibliographic reference). Represents a bibliographic reference or citation. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = BIRO["BibliographicReference"] class_class_curie: ClassVar[str] = "biro:BibliographicReference" class_name: ClassVar[str] = "BiBOBibliographicReference" class_model_uri: ClassVar[URIRef] = HERITAGE.BiBOBibliographicReference @dataclass(repr=False) class ScholarlyWork(YAMLRoot): """ Abstract intellectual creation representing a scholarly work (FRBR Work level). FaBiO concept for the conceptual essence of a publication, independent of its specific expressions or manifestations. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = FABIO["Work"] class_class_curie: ClassVar[str] = "fabio:Work" class_name: ClassVar[str] = "ScholarlyWork" class_model_uri: ClassVar[URIRef] = HERITAGE.ScholarlyWork work_id: Union[str, ScholarlyWorkWorkId] = None provenance: Union[dict, Provenance] = None work_title: Optional[str] = None work_subject: Optional[Union[str, list[str]]] = empty_list() work_keywords: Optional[Union[str, list[str]]] = empty_list() abstract: Optional[str] = None discipline: Optional[Union[str, list[str]]] = empty_list() research_field: Optional[Union[str, list[str]]] = empty_list() has_expression: Optional[Union[Union[str, PublicationPublicationId], list[Union[str, PublicationPublicationId]]]] = empty_list() related_institutions: Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]] = empty_list() def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.work_id): self.MissingRequiredField("work_id") if not isinstance(self.work_id, ScholarlyWorkWorkId): self.work_id = ScholarlyWorkWorkId(self.work_id) if self._is_empty(self.provenance): self.MissingRequiredField("provenance") if not isinstance(self.provenance, Provenance): self.provenance = Provenance(**as_dict(self.provenance)) if self.work_title is not None and not isinstance(self.work_title, str): self.work_title = str(self.work_title) if not isinstance(self.work_subject, list): self.work_subject = [self.work_subject] if self.work_subject is not None else [] self.work_subject = [v if isinstance(v, str) else str(v) for v in self.work_subject] if not isinstance(self.work_keywords, list): self.work_keywords = [self.work_keywords] if self.work_keywords is not None else [] self.work_keywords = [v if isinstance(v, str) else str(v) for v in self.work_keywords] if self.abstract is not None and not isinstance(self.abstract, str): self.abstract = str(self.abstract) if not isinstance(self.discipline, list): self.discipline = [self.discipline] if self.discipline is not None else [] self.discipline = [v if isinstance(v, str) else str(v) for v in self.discipline] if not isinstance(self.research_field, list): self.research_field = [self.research_field] if self.research_field is not None else [] self.research_field = [v if isinstance(v, str) else str(v) for v in self.research_field] if not isinstance(self.has_expression, list): self.has_expression = [self.has_expression] if self.has_expression is not None else [] self.has_expression = [v if isinstance(v, PublicationPublicationId) else PublicationPublicationId(v) for v in self.has_expression] if not isinstance(self.related_institutions, list): self.related_institutions = [self.related_institutions] if self.related_institutions is not None else [] self.related_institutions = [v if isinstance(v, HeritageCustodianId) else HeritageCustodianId(v) for v in self.related_institutions] super().__post_init__(**kwargs) @dataclass(repr=False) class Publication(YAMLRoot): """ Concrete realization of a scholarly work (FRBR Expression level). Represents a specific version or edition of a work with authors, publication date, and citation metadata. FaBiO Expression pattern. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = FABIO["Expression"] class_class_curie: ClassVar[str] = "fabio:Expression" class_name: ClassVar[str] = "Publication" class_model_uri: ClassVar[URIRef] = HERITAGE.Publication publication_id: Union[str, PublicationPublicationId] = None title: str = None publication_type: Union[str, "PublicationTypeEnum"] = None provenance: Union[dict, Provenance] = None alternative_titles: Optional[Union[str, list[str]]] = empty_list() authors: Optional[Union[dict[Union[str, PersonPersonId], Union[dict, "Person"]], list[Union[dict, "Person"]]]] = empty_dict() editors: Optional[Union[dict[Union[str, PersonPersonId], Union[dict, "Person"]], list[Union[dict, "Person"]]]] = empty_dict() contributors: Optional[Union[dict[Union[str, PersonPersonId], Union[dict, "Person"]], list[Union[dict, "Person"]]]] = empty_dict() publication_date: Optional[Union[str, XSDDate]] = None publication_year: Optional[int] = None abstract: Optional[str] = None keywords: Optional[Union[str, list[str]]] = empty_list() language: Optional[str] = None doi: Optional[str] = None url: Optional[Union[str, URI]] = None published_in: Optional[Union[str, JournalJournalId]] = None volume: Optional[str] = None issue: Optional[str] = None page_range: Optional[str] = None article_number: Optional[str] = None publisher: Optional[Union[dict, "Organization"]] = None place_of_publication: Optional[str] = None isbn: Optional[str] = None issn: Optional[str] = None citations: Optional[Union[dict[Union[str, CitationCitationId], Union[dict, "Citation"]], list[Union[dict, "Citation"]]]] = empty_dict() cited_by: Optional[Union[Union[str, CitationCitationId], list[Union[str, CitationCitationId]]]] = empty_list() related_works: Optional[Union[Union[str, PublicationPublicationId], list[Union[str, PublicationPublicationId]]]] = empty_list() document_sections: Optional[Union[dict[Union[str, DocumentSectionSectionId], Union[dict, "DocumentSection"]], list[Union[dict, "DocumentSection"]]]] = empty_dict() open_access_status: Optional[Union[str, "OpenAccessStatusEnum"]] = None publishing_status: Optional[Union[str, "PublishingStatusEnum"]] = None peer_reviewed: Optional[Union[bool, Bool]] = None license: Optional[str] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.publication_id): self.MissingRequiredField("publication_id") if not isinstance(self.publication_id, PublicationPublicationId): self.publication_id = PublicationPublicationId(self.publication_id) if self._is_empty(self.title): self.MissingRequiredField("title") if not isinstance(self.title, str): self.title = str(self.title) if self._is_empty(self.publication_type): self.MissingRequiredField("publication_type") if not isinstance(self.publication_type, PublicationTypeEnum): self.publication_type = PublicationTypeEnum(self.publication_type) if self._is_empty(self.provenance): self.MissingRequiredField("provenance") if not isinstance(self.provenance, Provenance): self.provenance = Provenance(**as_dict(self.provenance)) if not isinstance(self.alternative_titles, list): self.alternative_titles = [self.alternative_titles] if self.alternative_titles is not None else [] self.alternative_titles = [v if isinstance(v, str) else str(v) for v in self.alternative_titles] self._normalize_inlined_as_list(slot_name="authors", slot_type=Person, key_name="person_id", keyed=True) self._normalize_inlined_as_list(slot_name="editors", slot_type=Person, key_name="person_id", keyed=True) self._normalize_inlined_as_list(slot_name="contributors", slot_type=Person, key_name="person_id", keyed=True) if self.publication_date is not None and not isinstance(self.publication_date, XSDDate): self.publication_date = XSDDate(self.publication_date) if self.publication_year is not None and not isinstance(self.publication_year, int): self.publication_year = int(self.publication_year) if self.abstract is not None and not isinstance(self.abstract, str): self.abstract = str(self.abstract) 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.language is not None and not isinstance(self.language, str): self.language = str(self.language) if self.doi is not None and not isinstance(self.doi, str): self.doi = str(self.doi) if self.url is not None and not isinstance(self.url, URI): self.url = URI(self.url) if self.published_in is not None and not isinstance(self.published_in, JournalJournalId): self.published_in = JournalJournalId(self.published_in) if self.volume is not None and not isinstance(self.volume, str): self.volume = str(self.volume) if self.issue is not None and not isinstance(self.issue, str): self.issue = str(self.issue) if self.page_range is not None and not isinstance(self.page_range, str): self.page_range = str(self.page_range) if self.article_number is not None and not isinstance(self.article_number, str): self.article_number = str(self.article_number) if self.publisher is not None and not isinstance(self.publisher, Organization): self.publisher = Organization(**as_dict(self.publisher)) if self.place_of_publication is not None and not isinstance(self.place_of_publication, str): self.place_of_publication = str(self.place_of_publication) if self.isbn is not None and not isinstance(self.isbn, str): self.isbn = str(self.isbn) if self.issn is not None and not isinstance(self.issn, str): self.issn = str(self.issn) self._normalize_inlined_as_list(slot_name="citations", slot_type=Citation, key_name="citation_id", keyed=True) if not isinstance(self.cited_by, list): self.cited_by = [self.cited_by] if self.cited_by is not None else [] self.cited_by = [v if isinstance(v, CitationCitationId) else CitationCitationId(v) for v in self.cited_by] if not isinstance(self.related_works, list): self.related_works = [self.related_works] if self.related_works is not None else [] self.related_works = [v if isinstance(v, PublicationPublicationId) else PublicationPublicationId(v) for v in self.related_works] self._normalize_inlined_as_list(slot_name="document_sections", slot_type=DocumentSection, key_name="section_id", keyed=True) if self.open_access_status is not None and not isinstance(self.open_access_status, OpenAccessStatusEnum): self.open_access_status = OpenAccessStatusEnum(self.open_access_status) if self.publishing_status is not None and not isinstance(self.publishing_status, PublishingStatusEnum): self.publishing_status = PublishingStatusEnum(self.publishing_status) if self.peer_reviewed is not None and not isinstance(self.peer_reviewed, Bool): self.peer_reviewed = Bool(self.peer_reviewed) if self.license is not None and not isinstance(self.license, str): self.license = str(self.license) super().__post_init__(**kwargs) @dataclass(repr=False) class Journal(YAMLRoot): """ Academic journal or periodical publication. FaBiO Journal class representing a continuing resource published in serial fashion. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = FABIO["Journal"] class_class_curie: ClassVar[str] = "fabio:Journal" class_name: ClassVar[str] = "Journal" class_model_uri: ClassVar[URIRef] = HERITAGE.Journal journal_id: Union[str, JournalJournalId] = None journal_title: str = None provenance: Union[dict, Provenance] = None alternative_journal_titles: Optional[Union[str, list[str]]] = empty_list() issn: Optional[str] = None eissn: Optional[str] = None publisher: Optional[Union[dict, "Organization"]] = None journal_url: Optional[Union[str, URI]] = None impact_factor: Optional[float] = None cite_score: Optional[float] = None subject_areas: Optional[Union[str, list[str]]] = empty_list() open_access_status: Optional[Union[str, "OpenAccessStatusEnum"]] = None indexing_services: Optional[Union[str, list[str]]] = empty_list() def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.journal_id): self.MissingRequiredField("journal_id") if not isinstance(self.journal_id, JournalJournalId): self.journal_id = JournalJournalId(self.journal_id) if self._is_empty(self.journal_title): self.MissingRequiredField("journal_title") if not isinstance(self.journal_title, str): self.journal_title = str(self.journal_title) if self._is_empty(self.provenance): self.MissingRequiredField("provenance") if not isinstance(self.provenance, Provenance): self.provenance = Provenance(**as_dict(self.provenance)) if not isinstance(self.alternative_journal_titles, list): self.alternative_journal_titles = [self.alternative_journal_titles] if self.alternative_journal_titles is not None else [] self.alternative_journal_titles = [v if isinstance(v, str) else str(v) for v in self.alternative_journal_titles] if self.issn is not None and not isinstance(self.issn, str): self.issn = str(self.issn) if self.eissn is not None and not isinstance(self.eissn, str): self.eissn = str(self.eissn) if self.publisher is not None and not isinstance(self.publisher, Organization): self.publisher = Organization(**as_dict(self.publisher)) if self.journal_url is not None and not isinstance(self.journal_url, URI): self.journal_url = URI(self.journal_url) if self.impact_factor is not None and not isinstance(self.impact_factor, float): self.impact_factor = float(self.impact_factor) if self.cite_score is not None and not isinstance(self.cite_score, float): self.cite_score = float(self.cite_score) if not isinstance(self.subject_areas, list): self.subject_areas = [self.subject_areas] if self.subject_areas is not None else [] self.subject_areas = [v if isinstance(v, str) else str(v) for v in self.subject_areas] if self.open_access_status is not None and not isinstance(self.open_access_status, OpenAccessStatusEnum): self.open_access_status = OpenAccessStatusEnum(self.open_access_status) if not isinstance(self.indexing_services, list): self.indexing_services = [self.indexing_services] if self.indexing_services is not None else [] self.indexing_services = [v if isinstance(v, str) else str(v) for v in self.indexing_services] super().__post_init__(**kwargs) @dataclass(repr=False) class Conference(YAMLRoot): """ Academic conference or symposium. FaBiO AcademicProceedings representing a collection of conference papers. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = FABIO["AcademicProceedings"] class_class_curie: ClassVar[str] = "fabio:AcademicProceedings" class_name: ClassVar[str] = "Conference" class_model_uri: ClassVar[URIRef] = HERITAGE.Conference conference_id: Union[str, ConferenceConferenceId] = None conference_name: str = None provenance: Union[dict, Provenance] = None conference_acronym: Optional[str] = None conference_date: Optional[str] = None conference_location: Optional[str] = None conference_url: Optional[Union[str, URI]] = None proceedings_title: Optional[str] = None proceedings_isbn: Optional[str] = None proceedings_publisher: Optional[Union[dict, "Organization"]] = None editors: Optional[Union[dict[Union[str, PersonPersonId], Union[dict, "Person"]], list[Union[dict, "Person"]]]] = empty_dict() def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.conference_id): self.MissingRequiredField("conference_id") if not isinstance(self.conference_id, ConferenceConferenceId): self.conference_id = ConferenceConferenceId(self.conference_id) if self._is_empty(self.conference_name): self.MissingRequiredField("conference_name") if not isinstance(self.conference_name, str): self.conference_name = str(self.conference_name) if self._is_empty(self.provenance): self.MissingRequiredField("provenance") if not isinstance(self.provenance, Provenance): self.provenance = Provenance(**as_dict(self.provenance)) if self.conference_acronym is not None and not isinstance(self.conference_acronym, str): self.conference_acronym = str(self.conference_acronym) if self.conference_date is not None and not isinstance(self.conference_date, str): self.conference_date = str(self.conference_date) if self.conference_location is not None and not isinstance(self.conference_location, str): self.conference_location = str(self.conference_location) if self.conference_url is not None and not isinstance(self.conference_url, URI): self.conference_url = URI(self.conference_url) if self.proceedings_title is not None and not isinstance(self.proceedings_title, str): self.proceedings_title = str(self.proceedings_title) if self.proceedings_isbn is not None and not isinstance(self.proceedings_isbn, str): self.proceedings_isbn = str(self.proceedings_isbn) if self.proceedings_publisher is not None and not isinstance(self.proceedings_publisher, Organization): self.proceedings_publisher = Organization(**as_dict(self.proceedings_publisher)) self._normalize_inlined_as_list(slot_name="editors", slot_type=Person, key_name="person_id", keyed=True) super().__post_init__(**kwargs) @dataclass(repr=False) class Person(YAMLRoot): """ Person involved in scholarly publishing (author, editor, reviewer). FOAF Person with PRO publishing roles. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = FOAF["Person"] class_class_curie: ClassVar[str] = "foaf:Person" class_name: ClassVar[str] = "Person" class_model_uri: ClassVar[URIRef] = HERITAGE.Person person_id: Union[str, PersonPersonId] = None person_name: str = None given_name: Optional[str] = None family_name: Optional[str] = None orcid: Optional[str] = None email: Optional[str] = None affiliation: Optional[Union[dict, "Organization"]] = None roles: Optional[Union[Union[dict, "PublishingRole"], list[Union[dict, "PublishingRole"]]]] = empty_list() def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.person_id): self.MissingRequiredField("person_id") if not isinstance(self.person_id, PersonPersonId): self.person_id = PersonPersonId(self.person_id) if self._is_empty(self.person_name): self.MissingRequiredField("person_name") if not isinstance(self.person_name, str): self.person_name = str(self.person_name) if self.given_name is not None and not isinstance(self.given_name, str): self.given_name = str(self.given_name) if self.family_name is not None and not isinstance(self.family_name, str): self.family_name = str(self.family_name) if self.orcid is not None and not isinstance(self.orcid, str): self.orcid = str(self.orcid) if self.email is not None and not isinstance(self.email, str): self.email = str(self.email) if self.affiliation is not None and not isinstance(self.affiliation, Organization): self.affiliation = Organization(**as_dict(self.affiliation)) if not isinstance(self.roles, list): self.roles = [self.roles] if self.roles is not None else [] self.roles = [v if isinstance(v, PublishingRole) else PublishingRole(**as_dict(v)) for v in self.roles] super().__post_init__(**kwargs) @dataclass(repr=False) class Organization(YAMLRoot): """ Organization involved in publishing (publisher, institutional affiliation). Schema.org Organization for bibliographic contexts. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = SCHEMA["Organization"] class_class_curie: ClassVar[str] = "schema:Organization" class_name: ClassVar[str] = "Organization" class_model_uri: ClassVar[URIRef] = HERITAGE.Organization organization_id: Union[str, OrganizationOrganizationId] = None organization_name: str = None organization_type: Optional[str] = None location: Optional[str] = None homepage: Optional[Union[str, URI]] = None ror_id: Optional[str] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.organization_id): self.MissingRequiredField("organization_id") if not isinstance(self.organization_id, OrganizationOrganizationId): self.organization_id = OrganizationOrganizationId(self.organization_id) if self._is_empty(self.organization_name): self.MissingRequiredField("organization_name") if not isinstance(self.organization_name, str): self.organization_name = str(self.organization_name) if self.organization_type is not None and not isinstance(self.organization_type, str): self.organization_type = str(self.organization_type) if self.location is not None and not isinstance(self.location, str): self.location = str(self.location) if self.homepage is not None and not isinstance(self.homepage, URI): self.homepage = URI(self.homepage) if self.ror_id is not None and not isinstance(self.ror_id, str): self.ror_id = str(self.ror_id) super().__post_init__(**kwargs) @dataclass(repr=False) class Citation(YAMLRoot): """ Citation relationship between two publications. CiTO Citation characterizing how one work cites another. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = CITO["Citation"] class_class_curie: ClassVar[str] = "cito:Citation" class_name: ClassVar[str] = "Citation" class_model_uri: ClassVar[URIRef] = HERITAGE.Citation citation_id: Union[str, CitationCitationId] = None citing_work: Union[str, PublicationPublicationId] = None cited_work: Union[str, PublicationPublicationId] = None citation_type: Union[str, "CitationTypeEnum"] = None citation_intent: Optional[str] = None citation_context: Optional[str] = None page_number: Optional[str] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.citation_id): self.MissingRequiredField("citation_id") if not isinstance(self.citation_id, CitationCitationId): self.citation_id = CitationCitationId(self.citation_id) if self._is_empty(self.citing_work): self.MissingRequiredField("citing_work") if not isinstance(self.citing_work, PublicationPublicationId): self.citing_work = PublicationPublicationId(self.citing_work) if self._is_empty(self.cited_work): self.MissingRequiredField("cited_work") if not isinstance(self.cited_work, PublicationPublicationId): self.cited_work = PublicationPublicationId(self.cited_work) if self._is_empty(self.citation_type): self.MissingRequiredField("citation_type") if not isinstance(self.citation_type, CitationTypeEnum): self.citation_type = CitationTypeEnum(self.citation_type) if self.citation_intent is not None and not isinstance(self.citation_intent, str): self.citation_intent = str(self.citation_intent) if self.citation_context is not None and not isinstance(self.citation_context, str): self.citation_context = str(self.citation_context) if self.page_number is not None and not isinstance(self.page_number, str): self.page_number = str(self.page_number) super().__post_init__(**kwargs) @dataclass(repr=False) class DocumentSection(YAMLRoot): """ Structural section or component of a document. DoCO Document Component representing abstract, introduction, methods, etc. """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = DOCO["Section"] class_class_curie: ClassVar[str] = "doco:Section" class_name: ClassVar[str] = "DocumentSection" class_model_uri: ClassVar[URIRef] = HERITAGE.DocumentSection section_id: Union[str, DocumentSectionSectionId] = None section_title: Optional[str] = None section_type: Optional[Union[str, "DocumentSectionTypeEnum"]] = None section_content: Optional[str] = None section_order: Optional[int] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.section_id): self.MissingRequiredField("section_id") if not isinstance(self.section_id, DocumentSectionSectionId): self.section_id = DocumentSectionSectionId(self.section_id) if self.section_title is not None and not isinstance(self.section_title, str): self.section_title = str(self.section_title) if self.section_type is not None and not isinstance(self.section_type, DocumentSectionTypeEnum): self.section_type = DocumentSectionTypeEnum(self.section_type) if self.section_content is not None and not isinstance(self.section_content, str): self.section_content = str(self.section_content) if self.section_order is not None and not isinstance(self.section_order, int): self.section_order = int(self.section_order) super().__post_init__(**kwargs) @dataclass(repr=False) class PublishingRole(YAMLRoot): """ Role of a person or organization in the publishing process. PRO Publishing Role (author, editor, reviewer, publisher). """ _inherited_slots: ClassVar[list[str]] = [] class_class_uri: ClassVar[URIRef] = PRO["PublishingRole"] class_class_curie: ClassVar[str] = "pro:PublishingRole" class_name: ClassVar[str] = "PublishingRole" class_model_uri: ClassVar[URIRef] = HERITAGE.PublishingRole role_type: Union[str, "PublishingRoleTypeEnum"] = None role_holder: Union[str, PersonPersonId] = None role_context: Optional[str] = None def __post_init__(self, *_: str, **kwargs: Any): if self._is_empty(self.role_type): self.MissingRequiredField("role_type") if not isinstance(self.role_type, PublishingRoleTypeEnum): self.role_type = PublishingRoleTypeEnum(self.role_type) if self._is_empty(self.role_holder): self.MissingRequiredField("role_holder") if not isinstance(self.role_holder, PersonPersonId): self.role_holder = PersonPersonId(self.role_holder) if self.role_context is not None and not isinstance(self.role_context, str): self.role_context = str(self.role_context) super().__post_init__(**kwargs) # Enumerations class InstitutionTypeEnum(EnumDefinitionImpl): """ Types of heritage institutions (GLAMORCUBESFIXPHDNT taxonomy). Uses single-letter codes for GHCID generation: G(allery), L(ibrary), A(rchive), M(useum), O(fficial), R(esearch), C(orporation), U(nknown), B(otanical/Zoo), E(ducation), S(ociety), F(eatures), I(ntangible), X(miXed), P(ersonal), H(oly sites), D(igital), N(GO). """ GALLERY = PermissibleValue( text="GALLERY", description="Art gallery or exhibition space", meaning=SCHEMA["ArtGallery"]) LIBRARY = PermissibleValue( text="LIBRARY", description="Library (public, academic, specialized)", meaning=SCHEMA["Library"]) ARCHIVE = PermissibleValue( text="ARCHIVE", description="Archive (government, corporate, personal, community)", meaning=SCHEMA["ArchiveOrganization"]) MUSEUM = PermissibleValue( text="MUSEUM", description="Museum (art, history, science, natural history, etc.)", meaning=SCHEMA["Museum"]) OFFICIAL_INSTITUTION = PermissibleValue( text="OFFICIAL_INSTITUTION", description="Official government institutions managing cultural heritage", meaning=CPOV["PublicOrganisation"]) RESEARCH_CENTER = PermissibleValue( text="RESEARCH_CENTER", description="Research centers and institutes focused on cultural/heritage research", meaning=SCHEMA["ResearchOrganization"]) CORPORATION = PermissibleValue( text="CORPORATION", description="Corporate collections and heritage institutions", meaning=SCHEMA["Corporation"]) UNKNOWN = PermissibleValue( text="UNKNOWN", description="Unknown or uncategorized heritage custodian") BOTANICAL_ZOO = PermissibleValue( text="BOTANICAL_ZOO", description="Botanical gardens, zoos, aquariums, and natural heritage sites", meaning=SCHEMA["Zoo"]) EDUCATION_PROVIDER = PermissibleValue( text="EDUCATION_PROVIDER", description="Educational institutions with heritage collections (universities, schools)", meaning=SCHEMA["EducationalOrganization"]) PERSONAL_COLLECTION = PermissibleValue( text="PERSONAL_COLLECTION", description="Personal or private collections", meaning=SCHEMA["Collection"]) COLLECTING_SOCIETY = PermissibleValue( text="COLLECTING_SOCIETY", description="""Collecting societies (numismatics, philately, ephemera, local history/heemkundige kring, memorabilia, vintage, philographic)""", meaning=SCHEMA["Organization"]) MIXED = PermissibleValue( text="MIXED", description="""Multi-type institution (e.g., library + archive + museum). Use primary type for GHCID; document mixed nature in description.""") HOLY_SITES = PermissibleValue( text="HOLY_SITES", description="""Religious and sacred heritage sites (churches, temples, mosques, synagogues, shrines, monasteries, cathedrals) with historical, architectural, or cultural significance.""", meaning=SCHEMA["PlaceOfWorship"]) FEATURES = PermissibleValue( text="FEATURES", description="""Physical landscape features with heritage significance (monuments, sculptures, statues, memorials, landmarks, cemeteries as physical features). Distinct from institutions that maintain collections.""", meaning=SCHEMA["Monument"]) _defn = EnumDefinition( name="InstitutionTypeEnum", description="""Types of heritage institutions (GLAMORCUBESFIXPHDNT taxonomy). Uses single-letter codes for GHCID generation: G(allery), L(ibrary), A(rchive), M(useum), O(fficial), R(esearch), C(orporation), U(nknown), B(otanical/Zoo), E(ducation), S(ociety), F(eatures), I(ntangible), X(miXed), P(ersonal), H(oly sites), D(igital), N(GO), T(aste/smell).""", ) class OrganizationStatusEnum(EnumDefinitionImpl): """ Operational status of the organization """ ACTIVE = PermissibleValue( text="ACTIVE", description="Currently operational") INACTIVE = PermissibleValue( text="INACTIVE", description="No longer operational") MERGED = PermissibleValue( text="MERGED", description="Merged with another organization") SUSPENDED = PermissibleValue( text="SUSPENDED", description="Temporarily suspended operations") PLANNED = PermissibleValue( text="PLANNED", description="Planned but not yet operational") UNKNOWN = PermissibleValue( text="UNKNOWN", description="Status unknown") _defn = EnumDefinition( name="OrganizationStatusEnum", description="Operational status of the organization", ) class DataSourceEnum(EnumDefinitionImpl): """ Source of the data (for provenance tracking) """ ISIL_REGISTRY = PermissibleValue( text="ISIL_REGISTRY", description="Official ISIL code registry") DUTCH_ORG_CSV = PermissibleValue( text="DUTCH_ORG_CSV", description="Dutch heritage organizations CSV (totaallijst_nederland)") CONVERSATION_NLP = PermissibleValue( text="CONVERSATION_NLP", description="Extracted from Claude conversation via NLP") WEB_CRAWL = PermissibleValue( text="WEB_CRAWL", description="Extracted from institutional website via crawl4ai") WIKIDATA = PermissibleValue( text="WIKIDATA", description="Sourced from Wikidata SPARQL query") MANUAL_ENTRY = PermissibleValue( text="MANUAL_ENTRY", description="Manually entered or curated") INFERRED = PermissibleValue( text="INFERRED", description="Inferred from other data points") CSV_REGISTRY = PermissibleValue( text="CSV_REGISTRY", description="General CSV registry or dataset") _defn = EnumDefinition( name="DataSourceEnum", description="Source of the data (for provenance tracking)", ) class DataTierEnum(EnumDefinitionImpl): """ Data quality/authority tier (from 04-data-standardization.md) """ TIER_1_AUTHORITATIVE = PermissibleValue( text="TIER_1_AUTHORITATIVE", description="Official registries (ISIL, national registers)") TIER_2_VERIFIED = PermissibleValue( text="TIER_2_VERIFIED", description="Verified institutional data (website, official publications)") TIER_3_CROWD_SOURCED = PermissibleValue( text="TIER_3_CROWD_SOURCED", description="Community-sourced data (Wikidata, OpenStreetMap)") TIER_4_INFERRED = PermissibleValue( text="TIER_4_INFERRED", description="NLP-extracted or inferred data") _defn = EnumDefinition( name="DataTierEnum", description="Data quality/authority tier (from 04-data-standardization.md)", ) class MetadataStandardEnum(EnumDefinitionImpl): """ Metadata standards used by the institution """ DUBLIN_CORE = PermissibleValue( text="DUBLIN_CORE", description="Dublin Core Metadata Initiative", meaning=DCTERMS["title"]) MARC21 = PermissibleValue( text="MARC21", description="MARC 21 bibliographic format") EAD = PermissibleValue( text="EAD", description="Encoded Archival Description") BIBFRAME = PermissibleValue( text="BIBFRAME", description="BIBFRAME bibliographic framework") LIDO = PermissibleValue( text="LIDO", description="Lightweight Information Describing Objects (museum objects)") CIDOC_CRM = PermissibleValue( text="CIDOC_CRM", description="CIDOC Conceptual Reference Model", meaning=CRM["E1_CRM_Entity"]) SCHEMA_ORG = PermissibleValue( text="SCHEMA_ORG", description="Schema.org vocabulary", meaning=SCHEMA["Thing"]) RIC_O = PermissibleValue( text="RIC_O", description="Records in Contexts Ontology", meaning=RICO["Record"]) MODS = PermissibleValue( text="MODS", description="Metadata Object Description Schema") PREMIS = PermissibleValue( text="PREMIS", description="PREservation Metadata Implementation Strategies") SPECTRUM = PermissibleValue( text="SPECTRUM", description="UK museum collections management standard") DACS = PermissibleValue( text="DACS", description="Describing Archives - A Content Standard") _defn = EnumDefinition( name="MetadataStandardEnum", description="Metadata standards used by the institution", ) class DigitalPlatformTypeEnum(EnumDefinitionImpl): """ Types of digital platforms used """ COLLECTION_MANAGEMENT = PermissibleValue( text="COLLECTION_MANAGEMENT", description="""Collection management system (CMS) or integrated library system (ILS). Examples: Koha, Alma, Symphony (libraries); Atlantis, MAIS, CollectiveAccess, TMS (museums/archives)""") DIGITAL_REPOSITORY = PermissibleValue( text="DIGITAL_REPOSITORY", description="Digital repository (DSpace, EPrints)") DISCOVERY_PORTAL = PermissibleValue( text="DISCOVERY_PORTAL", description="Discovery/search portal") LINKED_DATA_ENDPOINT = PermissibleValue( text="LINKED_DATA_ENDPOINT", description="Linked Data/SPARQL endpoint") API = PermissibleValue( text="API", description="Public API for data access") AGGREGATOR = PermissibleValue( text="AGGREGATOR", description="Aggregation platform (Europeana, DPLA)") WEBSITE = PermissibleValue( text="WEBSITE", description="Institutional website") LEARNING_MANAGEMENT = PermissibleValue( text="LEARNING_MANAGEMENT", description="""Learning management systems for heritage education (Moodle, Google Classroom, Blackboard, Canvas)""", meaning=SCHEMA["LearningResource"]) IDENTIFIER_SERVICE = PermissibleValue( text="IDENTIFIER_SERVICE", description="Persistent identifier assignment service (URN, DOI, Handle, ARK)", meaning=SCHEMA["Service"]) GENERIC = PermissibleValue( text="GENERIC", description="""General-purpose software not specific to heritage sector. Examples: FileMaker, Microsoft Access, custom databases.""") _defn = EnumDefinition( name="DigitalPlatformTypeEnum", description="Types of digital platforms used", ) class ChangeTypeEnum(EnumDefinitionImpl): """ Types of organizational changes, based on TOOI Wijzigingsgebeurtenis patterns. Tracks major events in an organization's lifecycle. """ FOUNDING = PermissibleValue( text="FOUNDING", description="Organization was founded or established", meaning=TOOIONT["Oprichting"]) CLOSURE = PermissibleValue( text="CLOSURE", description="Organization ceased operations or was dissolved", meaning=TOOIONT["Opheffing"]) MERGER = PermissibleValue( text="MERGER", description="Organization merged with one or more other organizations", meaning=TOOIONT["Fusie"]) SPLIT = PermissibleValue( text="SPLIT", description="Organization split into multiple separate entities", meaning=TOOIONT["Afsplitsing"]) ACQUISITION = PermissibleValue( text="ACQUISITION", description="Organization acquired another organization") RELOCATION = PermissibleValue( text="RELOCATION", description="Organization moved to a new geographic location") NAME_CHANGE = PermissibleValue( text="NAME_CHANGE", description="Organization changed its official name") TYPE_CHANGE = PermissibleValue( text="TYPE_CHANGE", description="Institution type changed (e.g., archive became museum)") STATUS_CHANGE = PermissibleValue( text="STATUS_CHANGE", description="Operational status changed") RESTRUCTURING = PermissibleValue( text="RESTRUCTURING", description="Internal reorganization or structural change") LEGAL_CHANGE = PermissibleValue( text="LEGAL_CHANGE", description="Change in legal status or governance") OTHER = PermissibleValue( text="OTHER", description="Other type of organizational change") _defn = EnumDefinition( name="ChangeTypeEnum", description="""Types of organizational changes, based on TOOI Wijzigingsgebeurtenis patterns. Tracks major events in an organization's lifecycle.""", ) class EnrichmentTypeEnum(EnumDefinitionImpl): """ Types of data enrichment activities performed on heritage custodian records. Tracks what kind of data was added or modified during enrichment processes. """ WIKIDATA_IDENTIFIER = PermissibleValue( text="WIKIDATA_IDENTIFIER", description="Wikidata Q-number identifier added via SPARQL query or API lookup", meaning=PROV["Entity"]) GEOCODING = PermissibleValue( text="GEOCODING", description="Latitude/longitude coordinates added via geocoding service (Nominatim, GeoNames)", meaning=PROV["Location"]) VIAF_IDENTIFIER = PermissibleValue( text="VIAF_IDENTIFIER", description="Virtual International Authority File (VIAF) identifier added", meaning=PROV["Entity"]) ISIL_CODE = PermissibleValue( text="ISIL_CODE", description="International Standard Identifier for Libraries (ISIL) code assigned", meaning=PROV["Entity"]) GHCID_GENERATION = PermissibleValue( text="GHCID_GENERATION", description="Global Heritage Custodian Identifier (GHCID) generated from institution metadata", meaning=PROV["Entity"]) FALSE_POSITIVE_REMOVAL = PermissibleValue( text="FALSE_POSITIVE_REMOVAL", description="Incorrect or false positive enrichment data removed after verification", meaning=PROV["Invalidation"]) NAME_NORMALIZATION = PermissibleValue( text="NAME_NORMALIZATION", description="Institution name normalized or standardized for consistency", meaning=PROV["Revision"]) IDENTIFIER_VERIFICATION = PermissibleValue( text="IDENTIFIER_VERIFICATION", description="Existing identifier verified against authoritative source", meaning=PROV["Validation"]) INSTITUTION_TYPE_CLASSIFICATION = PermissibleValue( text="INSTITUTION_TYPE_CLASSIFICATION", description="Institution type classified or corrected (GLAMORCUBESFIXPHDNT taxonomy)", meaning=PROV["Revision"]) ADDRESS_STANDARDIZATION = PermissibleValue( text="ADDRESS_STANDARDIZATION", description="Physical address standardized or corrected using postal service data", meaning=PROV["Revision"]) WEBSITE_URL_VALIDATION = PermissibleValue( text="WEBSITE_URL_VALIDATION", description="Institution website URL validated and updated", meaning=PROV["Validation"]) COLLECTION_METADATA = PermissibleValue( text="COLLECTION_METADATA", description="Collection-level metadata added (extent, temporal coverage, subject areas)", meaning=PROV["Entity"]) ORGANIZATIONAL_RELATIONSHIP = PermissibleValue( text="ORGANIZATIONAL_RELATIONSHIP", description="Relationship to parent/child organizations or networks identified", meaning=PROV["Association"]) DIGITAL_PLATFORM_DETECTION = PermissibleValue( text="DIGITAL_PLATFORM_DETECTION", description="Digital platforms or systems used by institution identified", meaning=PROV["Entity"]) OTHER = PermissibleValue( text="OTHER", description="Other type of enrichment activity not covered by standard types", meaning=PROV["Activity"]) _defn = EnumDefinition( name="EnrichmentTypeEnum", description="""Types of data enrichment activities performed on heritage custodian records. Tracks what kind of data was added or modified during enrichment processes.""", ) class PublicationTypeEnum(EnumDefinitionImpl): """ Types of scholarly publications """ JOURNAL_ARTICLE = PermissibleValue( text="JOURNAL_ARTICLE", description="Article published in an academic journal", meaning=FABIO["JournalArticle"]) CONFERENCE_PAPER = PermissibleValue( text="CONFERENCE_PAPER", description="Paper presented at a conference", meaning=FABIO["ConferencePaper"]) BOOK = PermissibleValue( text="BOOK", description="Scholarly book or monograph", meaning=FABIO["Book"]) BOOK_CHAPTER = PermissibleValue( text="BOOK_CHAPTER", description="Chapter in an edited book", meaning=FABIO["BookChapter"]) THESIS = PermissibleValue( text="THESIS", description="Thesis or dissertation", meaning=FABIO["Thesis"]) TECHNICAL_REPORT = PermissibleValue( text="TECHNICAL_REPORT", description="Technical report or white paper", meaning=FABIO["TechnicalReport"]) REVIEW_ARTICLE = PermissibleValue( text="REVIEW_ARTICLE", description="Review or survey article", meaning=FABIO["ReviewArticle"]) EDITORIAL = PermissibleValue( text="EDITORIAL", description="Editorial or opinion piece", meaning=FABIO["Editorial"]) PREPRINT = PermissibleValue( text="PREPRINT", description="Preprint or working paper", meaning=FABIO["Preprint"]) DATASET = PermissibleValue( text="DATASET", description="Research dataset", meaning=FABIO["Dataset"]) SOFTWARE = PermissibleValue( text="SOFTWARE", description="Software or code", meaning=SCHEMA["SoftwareApplication"]) POSTER = PermissibleValue( text="POSTER", description="Conference poster", meaning=FABIO["Poster"]) PRESENTATION = PermissibleValue( text="PRESENTATION", description="Presentation slides", meaning=FABIO["Presentation"]) _defn = EnumDefinition( name="PublicationTypeEnum", description="Types of scholarly publications", ) class CitationTypeEnum(EnumDefinitionImpl): """ Types of citation relationships (CiTO) """ CITES = PermissibleValue( text="CITES", description="Generic citation", meaning=CITO["cites"]) CITES_AS_AUTHORITY = PermissibleValue( text="CITES_AS_AUTHORITY", description="Cites as authoritative source", meaning=CITO["citesAsAuthority"]) CITES_AS_EVIDENCE = PermissibleValue( text="CITES_AS_EVIDENCE", description="Cites as evidence", meaning=CITO["citesAsEvidence"]) CITES_AS_METADATA = PermissibleValue( text="CITES_AS_METADATA", description="Cites for metadata or provenance", meaning=CITO["citesAsMetadataDocument"]) DISCUSSES = PermissibleValue( text="DISCUSSES", description="Discusses the cited work", meaning=CITO["discusses"]) EXTENDS = PermissibleValue( text="EXTENDS", description="Extends the cited work", meaning=CITO["extends"]) SUPPORTS = PermissibleValue( text="SUPPORTS", description="Provides support for claims in cited work", meaning=CITO["supports"]) REFUTES = PermissibleValue( text="REFUTES", description="Refutes or disputes cited work", meaning=CITO["disputes"]) CRITIQUES = PermissibleValue( text="CRITIQUES", description="Critiques cited work", meaning=CITO["critiques"]) AGREES_WITH = PermissibleValue( text="AGREES_WITH", description="Agrees with cited work", meaning=CITO["agreesWith"]) DISAGREES_WITH = PermissibleValue( text="DISAGREES_WITH", description="Disagrees with cited work", meaning=CITO["disagreesWith"]) REVIEWS = PermissibleValue( text="REVIEWS", description="Reviews the cited work", meaning=CITO["reviews"]) USES_METHOD_IN = PermissibleValue( text="USES_METHOD_IN", description="Uses methodology from cited work", meaning=CITO["usesMethodIn"]) USES_DATA_FROM = PermissibleValue( text="USES_DATA_FROM", description="Uses data from cited work", meaning=CITO["usesDataFrom"]) _defn = EnumDefinition( name="CitationTypeEnum", description="Types of citation relationships (CiTO)", ) class OpenAccessStatusEnum(EnumDefinitionImpl): """ Open access availability status """ FULLY_OPEN_ACCESS = PermissibleValue( text="FULLY_OPEN_ACCESS", description="Freely available to all readers", meaning=FABIO["OpenAccess"]) OPEN_ACCESS_REPOSITORY = PermissibleValue( text="OPEN_ACCESS_REPOSITORY", description="Available via institutional or subject repository", meaning=FABIO["GreenOpenAccess"]) HYBRID_OPEN_ACCESS = PermissibleValue( text="HYBRID_OPEN_ACCESS", description="Published in subscription journal with OA option", meaning=FABIO["HybridOpenAccess"]) CLOSED_ACCESS = PermissibleValue( text="CLOSED_ACCESS", description="Subscription or paywall access only", meaning=FABIO["ClosedAccess"]) EMBARGOED = PermissibleValue( text="EMBARGOED", description="Will become open access after embargo period", meaning=FABIO["EmbargoedAccess"]) BRONZE_OPEN_ACCESS = PermissibleValue( text="BRONZE_OPEN_ACCESS", description="Free to read but without clear license", meaning=FABIO["BronzeOpenAccess"]) _defn = EnumDefinition( name="OpenAccessStatusEnum", description="Open access availability status", ) class PublishingStatusEnum(EnumDefinitionImpl): """ Status in the publishing workflow (PSO) """ SUBMITTED = PermissibleValue( text="SUBMITTED", description="Submitted to journal/conference", meaning=PSO["submitted"]) UNDER_REVIEW = PermissibleValue( text="UNDER_REVIEW", description="Under peer review", meaning=PSO["under-review"]) ACCEPTED = PermissibleValue( text="ACCEPTED", description="Accepted for publication", meaning=PSO["accepted"]) IN_PRESS = PermissibleValue( text="IN_PRESS", description="In press, awaiting publication", meaning=PSO["in-press"]) PUBLISHED = PermissibleValue( text="PUBLISHED", description="Published and available", meaning=PSO["published"]) REJECTED = PermissibleValue( text="REJECTED", description="Rejected by publisher", meaning=PSO["rejected"]) WITHDRAWN = PermissibleValue( text="WITHDRAWN", description="Withdrawn by author(s)", meaning=PSO["withdrawn"]) RETRACTED = PermissibleValue( text="RETRACTED", description="Retracted by publisher", meaning=PSO["retracted"]) _defn = EnumDefinition( name="PublishingStatusEnum", description="Status in the publishing workflow (PSO)", ) class DocumentSectionTypeEnum(EnumDefinitionImpl): """ Types of document sections (DoCO) """ ABSTRACT = PermissibleValue( text="ABSTRACT", description="Abstract or summary", meaning=DOCO["Abstract"]) INTRODUCTION = PermissibleValue( text="INTRODUCTION", description="Introduction section", meaning=DOCO["Introduction"]) METHODS = PermissibleValue( text="METHODS", description="Methods or methodology section", meaning=DOCO["Methods"]) RESULTS = PermissibleValue( text="RESULTS", description="Results section", meaning=DOCO["Results"]) DISCUSSION = PermissibleValue( text="DISCUSSION", description="Discussion section", meaning=DOCO["Discussion"]) CONCLUSION = PermissibleValue( text="CONCLUSION", description="Conclusion section", meaning=DOCO["Conclusion"]) ACKNOWLEDGMENTS = PermissibleValue( text="ACKNOWLEDGMENTS", description="Acknowledgments section", meaning=DOCO["Acknowledgments"]) BIBLIOGRAPHY = PermissibleValue( text="BIBLIOGRAPHY", description="Bibliography or references", meaning=DOCO["Bibliography"]) APPENDIX = PermissibleValue( text="APPENDIX", description="Appendix or supplementary material", meaning=DOCO["Appendix"]) _defn = EnumDefinition( name="DocumentSectionTypeEnum", description="Types of document sections (DoCO)", ) class PublishingRoleTypeEnum(EnumDefinitionImpl): """ Roles in the publishing process (PRO) """ AUTHOR = PermissibleValue( text="AUTHOR", description="Author of the work", meaning=PRO["author"]) EDITOR = PermissibleValue( text="EDITOR", description="Editor", meaning=PRO["editor"]) REVIEWER = PermissibleValue( text="REVIEWER", description="Peer reviewer", meaning=PRO["reviewer"]) TRANSLATOR = PermissibleValue( text="TRANSLATOR", description="Translator", meaning=PRO["translator"]) ILLUSTRATOR = PermissibleValue( text="ILLUSTRATOR", description="Illustrator", meaning=PRO["illustrator"]) CONTRIBUTOR = PermissibleValue( text="CONTRIBUTOR", description="General contributor", meaning=DCTERMS["contributor"]) CORRESPONDING_AUTHOR = PermissibleValue( text="CORRESPONDING_AUTHOR", description="Corresponding author", meaning=PRO["corresponding-author"]) PUBLISHER = PermissibleValue( text="PUBLISHER", description="Publisher", meaning=PRO["publisher"]) SERIES_EDITOR = PermissibleValue( text="SERIES_EDITOR", description="Series editor", meaning=PRO["series-editor"]) _defn = EnumDefinition( name="PublishingRoleTypeEnum", description="Roles in the publishing process (PRO)", ) # Slots class slots: pass slots.id = Slot(uri=DCTERMS.identifier, name="id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.id, domain=None, range=URIRef) slots.ghcid_numeric = Slot(uri=DCTERMS.identifier, name="ghcid_numeric", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.ghcid_numeric, domain=None, range=Optional[int]) slots.ghcid_current = Slot(uri=DCTERMS.identifier, name="ghcid_current", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.ghcid_current, domain=None, range=Optional[str], pattern=re.compile(r'^[A-Z]{2}-[A-Z0-9]{1,3}-[A-Z]{3}-[A-Z]-[A-Z0-9]{1,10}(-Q[0-9]+)?$')) slots.ghcid_original = Slot(uri=DCTERMS.identifier, name="ghcid_original", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.ghcid_original, domain=None, range=Optional[str], pattern=re.compile(r'^[A-Z]{2}-[A-Z0-9]{1,3}-[A-Z]{3}-[A-Z]-[A-Z0-9]{1,10}(-Q[0-9]+)?$')) slots.ghcid_history = Slot(uri=DCTERMS.provenance, name="ghcid_history", curie=DCTERMS.curie('provenance'), model_uri=HERITAGE.ghcid_history, domain=None, range=Optional[Union[Union[dict, GHCIDHistoryEntry], list[Union[dict, GHCIDHistoryEntry]]]]) slots.record_id = Slot(uri=DCTERMS.identifier, name="record_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.record_id, domain=None, range=Optional[str], pattern=re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$')) slots.ghcid_uuid = Slot(uri=DCTERMS.identifier, name="ghcid_uuid", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.ghcid_uuid, domain=None, range=Optional[str], pattern=re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$')) slots.ghcid_uuid_sha256 = Slot(uri=DCTERMS.identifier, name="ghcid_uuid_sha256", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.ghcid_uuid_sha256, domain=None, range=Optional[str], pattern=re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-8[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$')) slots.name = Slot(uri=SCHEMA.name, name="name", curie=SCHEMA.curie('name'), model_uri=HERITAGE.name, domain=None, range=str) slots.alternative_names = Slot(uri=SCHEMA.alternateName, name="alternative_names", curie=SCHEMA.curie('alternateName'), model_uri=HERITAGE.alternative_names, domain=None, range=Optional[Union[str, list[str]]]) slots.official_name = Slot(uri=TOOIONT.officieleNaamInclSoort, name="official_name", curie=TOOIONT.curie('officieleNaamInclSoort'), model_uri=HERITAGE.official_name, domain=None, range=Optional[str]) slots.sorting_name = Slot(uri=TOOIONT.officieleNaamSorteer, name="sorting_name", curie=TOOIONT.curie('officieleNaamSorteer'), model_uri=HERITAGE.sorting_name, domain=None, range=Optional[str]) slots.abbreviation = Slot(uri=TOOIONT.afkorting, name="abbreviation", curie=TOOIONT.curie('afkorting'), model_uri=HERITAGE.abbreviation, domain=None, range=Optional[str]) slots.institution_type = Slot(uri=DCTERMS.type, name="institution_type", curie=DCTERMS.curie('type'), model_uri=HERITAGE.institution_type, domain=None, range=Optional[Union[str, "InstitutionTypeEnum"]]) slots.organization_status = Slot(uri=ORG.organizationStatus, name="organization_status", curie=ORG.curie('organizationStatus'), model_uri=HERITAGE.organization_status, domain=None, range=Optional[Union[str, "OrganizationStatusEnum"]]) slots.description = Slot(uri=DCTERMS.description, name="description", curie=DCTERMS.curie('description'), model_uri=HERITAGE.description, domain=None, range=Optional[str]) slots.parent_organization = Slot(uri=ORG.subOrganizationOf, name="parent_organization", curie=ORG.curie('subOrganizationOf'), model_uri=HERITAGE.parent_organization, domain=None, range=Optional[Union[str, HeritageCustodianId]]) slots.sub_organizations = Slot(uri=ORG.hasSubOrganization, name="sub_organizations", curie=ORG.curie('hasSubOrganization'), model_uri=HERITAGE.sub_organizations, domain=None, range=Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]]) slots.founded_date = Slot(uri=SCHEMA.foundingDate, name="founded_date", curie=SCHEMA.curie('foundingDate'), model_uri=HERITAGE.founded_date, domain=None, range=Optional[Union[str, XSDDate]]) slots.closed_date = Slot(uri=SCHEMA.dissolutionDate, name="closed_date", curie=SCHEMA.curie('dissolutionDate'), model_uri=HERITAGE.closed_date, domain=None, range=Optional[Union[str, XSDDate]]) slots.prov_generated_at = Slot(uri=PROV.generatedAtTime, name="prov_generated_at", curie=PROV.curie('generatedAtTime'), model_uri=HERITAGE.prov_generated_at, domain=None, range=Optional[Union[str, XSDDateTime]]) slots.prov_invalidated_at = Slot(uri=PROV.invalidatedAtTime, name="prov_invalidated_at", curie=PROV.curie('invalidatedAtTime'), model_uri=HERITAGE.prov_invalidated_at, domain=None, range=Optional[Union[str, XSDDateTime]]) slots.change_history = Slot(uri=PROV.wasInfluencedBy, name="change_history", curie=PROV.curie('wasInfluencedBy'), model_uri=HERITAGE.change_history, domain=None, range=Optional[Union[dict[Union[str, ChangeEventEventId], Union[dict, ChangeEvent]], list[Union[dict, ChangeEvent]]]]) slots.homepage = Slot(uri=FOAF.homepage, name="homepage", curie=FOAF.curie('homepage'), model_uri=HERITAGE.homepage, domain=None, range=Optional[Union[str, URI]]) slots.contact_info = Slot(uri=HERITAGE.contact_info, name="contact_info", curie=HERITAGE.curie('contact_info'), model_uri=HERITAGE.contact_info, domain=None, range=Optional[Union[dict, ContactInfo]]) slots.locations = Slot(uri=HERITAGE.locations, name="locations", curie=HERITAGE.curie('locations'), model_uri=HERITAGE.locations, domain=None, range=Optional[Union[Union[dict, Location], list[Union[dict, Location]]]]) slots.identifiers = Slot(uri=HERITAGE.identifiers, name="identifiers", curie=HERITAGE.curie('identifiers'), model_uri=HERITAGE.identifiers, domain=None, range=Optional[Union[Union[dict, Identifier], list[Union[dict, Identifier]]]]) slots.collections = Slot(uri=HERITAGE.collections, name="collections", curie=HERITAGE.curie('collections'), model_uri=HERITAGE.collections, domain=None, range=Optional[Union[Union[dict, Collection], list[Union[dict, Collection]]]]) slots.digital_platforms = Slot(uri=HERITAGE.digital_platforms, name="digital_platforms", curie=HERITAGE.curie('digital_platforms'), model_uri=HERITAGE.digital_platforms, domain=None, range=Optional[Union[Union[dict, DigitalPlatform], list[Union[dict, DigitalPlatform]]]]) slots.metadata_standards = Slot(uri=HERITAGE.metadata_standards, name="metadata_standards", curie=HERITAGE.curie('metadata_standards'), model_uri=HERITAGE.metadata_standards, domain=None, range=Optional[Union[Union[str, "MetadataStandardEnum"], list[Union[str, "MetadataStandardEnum"]]]]) slots.partnerships = Slot(uri=HERITAGE.partnerships, name="partnerships", curie=HERITAGE.curie('partnerships'), model_uri=HERITAGE.partnerships, domain=None, range=Optional[Union[Union[dict, Partnership], list[Union[dict, Partnership]]]]) slots.publications = Slot(uri=DCTERMS.bibliographicCitation, name="publications", curie=DCTERMS.curie('bibliographicCitation'), model_uri=HERITAGE.publications, domain=None, range=Optional[Union[dict[Union[str, PublicationPublicationId], Union[dict, Publication]], list[Union[dict, Publication]]]]) slots.provenance = Slot(uri=HERITAGE.provenance, name="provenance", curie=HERITAGE.curie('provenance'), model_uri=HERITAGE.provenance, domain=None, range=Union[dict, Provenance]) slots.location_type = Slot(uri=HERITAGE.location_type, name="location_type", curie=HERITAGE.curie('location_type'), model_uri=HERITAGE.location_type, domain=None, range=Optional[str]) slots.street_address = Slot(uri=SCHEMA.streetAddress, name="street_address", curie=SCHEMA.curie('streetAddress'), model_uri=HERITAGE.street_address, domain=None, range=Optional[str]) slots.city = Slot(uri=SCHEMA.addressLocality, name="city", curie=SCHEMA.curie('addressLocality'), model_uri=HERITAGE.city, domain=None, range=Optional[str]) slots.postal_code = Slot(uri=SCHEMA.postalCode, name="postal_code", curie=SCHEMA.curie('postalCode'), model_uri=HERITAGE.postal_code, domain=None, range=Optional[str]) slots.region = Slot(uri=SCHEMA.addressRegion, name="region", curie=SCHEMA.curie('addressRegion'), model_uri=HERITAGE.region, domain=None, range=Optional[str]) slots.country = Slot(uri=SCHEMA.addressCountry, name="country", curie=SCHEMA.curie('addressCountry'), model_uri=HERITAGE.country, domain=None, range=Optional[str], pattern=re.compile(r'^[A-Z]{2}$')) slots.latitude = Slot(uri=SCHEMA.latitude, name="latitude", curie=SCHEMA.curie('latitude'), model_uri=HERITAGE.latitude, domain=None, range=Optional[float]) slots.longitude = Slot(uri=SCHEMA.longitude, name="longitude", curie=SCHEMA.curie('longitude'), model_uri=HERITAGE.longitude, domain=None, range=Optional[float]) slots.geonames_id = Slot(uri=HERITAGE.geonames_id, name="geonames_id", curie=HERITAGE.curie('geonames_id'), model_uri=HERITAGE.geonames_id, domain=None, range=Optional[str]) slots.is_primary = Slot(uri=HERITAGE.is_primary, name="is_primary", curie=HERITAGE.curie('is_primary'), model_uri=HERITAGE.is_primary, domain=None, range=Optional[Union[bool, Bool]]) slots.email = Slot(uri=SCHEMA.email, name="email", curie=SCHEMA.curie('email'), model_uri=HERITAGE.email, domain=None, range=Optional[str], pattern=re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')) slots.phone = Slot(uri=SCHEMA.telephone, name="phone", curie=SCHEMA.curie('telephone'), model_uri=HERITAGE.phone, domain=None, range=Optional[str]) slots.fax = Slot(uri=SCHEMA.faxNumber, name="fax", curie=SCHEMA.curie('faxNumber'), model_uri=HERITAGE.fax, domain=None, range=Optional[str]) slots.contact_type = Slot(uri=HERITAGE.contact_type, name="contact_type", curie=HERITAGE.curie('contact_type'), model_uri=HERITAGE.contact_type, domain=None, range=Optional[str]) slots.identifier_scheme = Slot(uri=HERITAGE.identifier_scheme, name="identifier_scheme", curie=HERITAGE.curie('identifier_scheme'), model_uri=HERITAGE.identifier_scheme, domain=None, range=Optional[str]) slots.identifier_value = Slot(uri=HERITAGE.identifier_value, name="identifier_value", curie=HERITAGE.curie('identifier_value'), model_uri=HERITAGE.identifier_value, domain=None, range=Optional[str]) slots.identifier_url = Slot(uri=HERITAGE.identifier_url, name="identifier_url", curie=HERITAGE.curie('identifier_url'), model_uri=HERITAGE.identifier_url, domain=None, range=Optional[Union[str, URI]]) slots.assigned_date = Slot(uri=HERITAGE.assigned_date, name="assigned_date", curie=HERITAGE.curie('assigned_date'), model_uri=HERITAGE.assigned_date, domain=None, range=Optional[Union[str, XSDDate]]) slots.chamber_of_commerce_number = Slot(uri=DCTERMS.identifier, name="chamber_of_commerce_number", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.chamber_of_commerce_number, domain=None, range=Optional[str]) slots.municipality_identifier = Slot(uri=SCHEMA.addressLocality, name="municipality_identifier", curie=SCHEMA.curie('addressLocality'), model_uri=HERITAGE.municipality_identifier, domain=None, range=Optional[str]) slots.parent_organization_name = Slot(uri=ORG.subOrganizationOf, name="parent_organization_name", curie=ORG.curie('subOrganizationOf'), model_uri=HERITAGE.parent_organization_name, domain=None, range=Optional[str]) slots.unit_id = Slot(uri=DCTERMS.identifier, name="unit_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.unit_id, domain=None, range=URIRef) slots.unit_name = Slot(uri=ORG.unitName, name="unit_name", curie=ORG.curie('unitName'), model_uri=HERITAGE.unit_name, domain=None, range=str) slots.unit_type = Slot(uri=ORG.classification, name="unit_type", curie=ORG.curie('classification'), model_uri=HERITAGE.unit_type, domain=None, range=Optional[str]) slots.parent_unit = Slot(uri=ORG.unitOf, name="parent_unit", curie=ORG.curie('unitOf'), model_uri=HERITAGE.parent_unit, domain=None, range=Optional[Union[str, OrganizationalUnitUnitId]]) slots.data_source = Slot(uri=HERITAGE.data_source, name="data_source", curie=HERITAGE.curie('data_source'), model_uri=HERITAGE.data_source, domain=None, range=Union[str, "DataSourceEnum"]) slots.data_tier = Slot(uri=HERITAGE.data_tier, name="data_tier", curie=HERITAGE.curie('data_tier'), model_uri=HERITAGE.data_tier, domain=None, range=Union[str, "DataTierEnum"]) slots.extraction_date = Slot(uri=HERITAGE.extraction_date, name="extraction_date", curie=HERITAGE.curie('extraction_date'), model_uri=HERITAGE.extraction_date, domain=None, range=Union[str, XSDDateTime]) slots.extraction_method = Slot(uri=HERITAGE.extraction_method, name="extraction_method", curie=HERITAGE.curie('extraction_method'), model_uri=HERITAGE.extraction_method, domain=None, range=Optional[str]) slots.confidence_score = Slot(uri=HERITAGE.confidence_score, name="confidence_score", curie=HERITAGE.curie('confidence_score'), model_uri=HERITAGE.confidence_score, domain=None, range=Optional[float]) slots.conversation_id = Slot(uri=HERITAGE.conversation_id, name="conversation_id", curie=HERITAGE.curie('conversation_id'), model_uri=HERITAGE.conversation_id, domain=None, range=Optional[str]) slots.source_url = Slot(uri=HERITAGE.source_url, name="source_url", curie=HERITAGE.curie('source_url'), model_uri=HERITAGE.source_url, domain=None, range=Optional[Union[str, URI]]) slots.verified_date = Slot(uri=HERITAGE.verified_date, name="verified_date", curie=HERITAGE.curie('verified_date'), model_uri=HERITAGE.verified_date, domain=None, range=Optional[Union[str, XSDDateTime]]) slots.verified_by = Slot(uri=HERITAGE.verified_by, name="verified_by", curie=HERITAGE.curie('verified_by'), model_uri=HERITAGE.verified_by, domain=None, range=Optional[str]) slots.provenance_notes = Slot(uri=RDFS.comment, name="provenance_notes", curie=RDFS.curie('comment'), model_uri=HERITAGE.provenance_notes, domain=None, range=Optional[str]) slots.ghcid = Slot(uri=HERITAGE.ghcid, name="ghcid", curie=HERITAGE.curie('ghcid'), model_uri=HERITAGE.ghcid, domain=None, range=Optional[str], pattern=re.compile(r'^[A-Z]{2}-[A-Z0-9]{1,3}-[A-Z]{3}-[A-Z]-[A-Z0-9]{1,10}(-Q[0-9]+)?$')) slots.valid_from = Slot(uri=HERITAGE.valid_from, name="valid_from", curie=HERITAGE.curie('valid_from'), model_uri=HERITAGE.valid_from, domain=None, range=Optional[Union[str, XSDDateTime]]) slots.valid_to = Slot(uri=HERITAGE.valid_to, name="valid_to", curie=HERITAGE.curie('valid_to'), model_uri=HERITAGE.valid_to, domain=None, range=Optional[Union[str, XSDDateTime]]) slots.reason = Slot(uri=HERITAGE.reason, name="reason", curie=HERITAGE.curie('reason'), model_uri=HERITAGE.reason, domain=None, range=Optional[str]) slots.institution_name = Slot(uri=HERITAGE.institution_name, name="institution_name", curie=HERITAGE.curie('institution_name'), model_uri=HERITAGE.institution_name, domain=None, range=Optional[str]) slots.location_city = Slot(uri=HERITAGE.location_city, name="location_city", curie=HERITAGE.curie('location_city'), model_uri=HERITAGE.location_city, domain=None, range=Optional[str]) slots.location_country = Slot(uri=HERITAGE.location_country, name="location_country", curie=HERITAGE.curie('location_country'), model_uri=HERITAGE.location_country, domain=None, range=Optional[str]) slots.event_id = Slot(uri=DCTERMS.identifier, name="event_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.event_id, domain=None, range=URIRef) slots.change_type = Slot(uri=RDF.type, name="change_type", curie=RDF.curie('type'), model_uri=HERITAGE.change_type, domain=None, range=Union[str, "ChangeTypeEnum"]) slots.event_date = Slot(uri=PROV.atTime, name="event_date", curie=PROV.curie('atTime'), model_uri=HERITAGE.event_date, domain=None, range=Union[str, XSDDate]) slots.event_description = Slot(uri=DCTERMS.description, name="event_description", curie=DCTERMS.curie('description'), model_uri=HERITAGE.event_description, domain=None, range=Optional[str]) slots.affected_organization = Slot(uri=PROV.entity, name="affected_organization", curie=PROV.curie('entity'), model_uri=HERITAGE.affected_organization, domain=None, range=Optional[Union[str, HeritageCustodianId]]) slots.resulting_organization = Slot(uri=PROV.generated, name="resulting_organization", curie=PROV.curie('generated'), model_uri=HERITAGE.resulting_organization, domain=None, range=Optional[Union[str, HeritageCustodianId]]) slots.related_organizations = Slot(uri=PROV.wasAssociatedWith, name="related_organizations", curie=PROV.curie('wasAssociatedWith'), model_uri=HERITAGE.related_organizations, domain=None, range=Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]]) slots.source_documentation = Slot(uri=DCTERMS.source, name="source_documentation", curie=DCTERMS.curie('source'), model_uri=HERITAGE.source_documentation, domain=None, range=Optional[Union[str, URI]]) slots.enrichment_history = Slot(uri=HERITAGE.enrichment_history, name="enrichment_history", curie=HERITAGE.curie('enrichment_history'), model_uri=HERITAGE.enrichment_history, domain=None, range=Optional[Union[Union[dict, EnrichmentHistoryEntry], list[Union[dict, EnrichmentHistoryEntry]]]]) slots.enrichment_date = Slot(uri=PROV.atTime, name="enrichment_date", curie=PROV.curie('atTime'), model_uri=HERITAGE.enrichment_date, domain=None, range=Union[str, XSDDateTime]) slots.enrichment_method = Slot(uri=PROV.hadPlan, name="enrichment_method", curie=PROV.curie('hadPlan'), model_uri=HERITAGE.enrichment_method, domain=None, range=str) slots.enrichment_type = Slot(uri=RDF.type, name="enrichment_type", curie=RDF.curie('type'), model_uri=HERITAGE.enrichment_type, domain=None, range=Union[str, "EnrichmentTypeEnum"]) slots.match_score = Slot(uri=ADMS.confidence, name="match_score", curie=ADMS.curie('confidence'), model_uri=HERITAGE.match_score, domain=None, range=Optional[float]) slots.verified = Slot(uri=ADMS.status, name="verified", curie=ADMS.curie('status'), model_uri=HERITAGE.verified, domain=None, range=Union[bool, Bool]) slots.enrichment_source = Slot(uri=DCTERMS.source, name="enrichment_source", curie=DCTERMS.curie('source'), model_uri=HERITAGE.enrichment_source, domain=None, range=Optional[Union[str, URI]]) slots.enrichment_notes = Slot(uri=DCTERMS.description, name="enrichment_notes", curie=DCTERMS.curie('description'), model_uri=HERITAGE.enrichment_notes, domain=None, range=Optional[str]) slots.collection_id = Slot(uri=HERITAGE.collection_id, name="collection_id", curie=HERITAGE.curie('collection_id'), model_uri=HERITAGE.collection_id, domain=None, range=Optional[str]) slots.collection_name = Slot(uri=HERITAGE.collection_name, name="collection_name", curie=HERITAGE.curie('collection_name'), model_uri=HERITAGE.collection_name, domain=None, range=Optional[str]) slots.collection_description = Slot(uri=DCTERMS.description, name="collection_description", curie=DCTERMS.curie('description'), model_uri=HERITAGE.collection_description, domain=None, range=Optional[str]) slots.collection_type = Slot(uri=HERITAGE.collection_type, name="collection_type", curie=HERITAGE.curie('collection_type'), model_uri=HERITAGE.collection_type, domain=None, range=Optional[str]) slots.item_count = Slot(uri=SCHEMA.size, name="item_count", curie=SCHEMA.curie('size'), model_uri=HERITAGE.item_count, domain=None, range=Optional[str]) slots.subjects = Slot(uri=DCTERMS.subject, name="subjects", curie=DCTERMS.curie('subject'), model_uri=HERITAGE.subjects, domain=None, range=Optional[Union[str, list[str]]]) slots.time_period_start = Slot(uri=HERITAGE.time_period_start, name="time_period_start", curie=HERITAGE.curie('time_period_start'), model_uri=HERITAGE.time_period_start, domain=None, range=Optional[Union[str, XSDDate]]) slots.time_period_end = Slot(uri=HERITAGE.time_period_end, name="time_period_end", curie=HERITAGE.curie('time_period_end'), model_uri=HERITAGE.time_period_end, domain=None, range=Optional[Union[str, XSDDate]]) slots.temporal_coverage = Slot(uri=DCTERMS.temporal, name="temporal_coverage", curie=DCTERMS.curie('temporal'), model_uri=HERITAGE.temporal_coverage, domain=None, range=Optional[str], pattern=re.compile(r'^\d{4}-\d{2}-\d{2}/\d{4}-\d{2}-\d{2}$')) slots.access_rights = Slot(uri=HERITAGE.access_rights, name="access_rights", curie=HERITAGE.curie('access_rights'), model_uri=HERITAGE.access_rights, domain=None, range=Optional[str]) slots.catalog_url = Slot(uri=HERITAGE.catalog_url, name="catalog_url", curie=HERITAGE.curie('catalog_url'), model_uri=HERITAGE.catalog_url, domain=None, range=Optional[Union[str, URI]]) slots.custodian = Slot(uri=RICO.hasOrHadHolder, name="custodian", curie=RICO.curie('hasOrHadHolder'), model_uri=HERITAGE.custodian, domain=None, range=Optional[Union[str, HeritageCustodianId]]) slots.platform_name = Slot(uri=HERITAGE.platform_name, name="platform_name", curie=HERITAGE.curie('platform_name'), model_uri=HERITAGE.platform_name, domain=None, range=Optional[str]) slots.platform_type = Slot(uri=HERITAGE.platform_type, name="platform_type", curie=HERITAGE.curie('platform_type'), model_uri=HERITAGE.platform_type, domain=None, range=Optional[Union[str, "DigitalPlatformTypeEnum"]]) slots.platform_url = Slot(uri=HERITAGE.platform_url, name="platform_url", curie=HERITAGE.curie('platform_url'), model_uri=HERITAGE.platform_url, domain=None, range=Optional[Union[str, URI]]) slots.platform_description = Slot(uri=DCTERMS.description, name="platform_description", curie=DCTERMS.curie('description'), model_uri=HERITAGE.platform_description, domain=None, range=Optional[str]) slots.vendor = Slot(uri=HERITAGE.vendor, name="vendor", curie=HERITAGE.curie('vendor'), model_uri=HERITAGE.vendor, domain=None, range=Optional[str]) slots.implemented_standards = Slot(uri=HERITAGE.implemented_standards, name="implemented_standards", curie=HERITAGE.curie('implemented_standards'), model_uri=HERITAGE.implemented_standards, domain=None, range=Optional[Union[Union[str, "MetadataStandardEnum"], list[Union[str, "MetadataStandardEnum"]]]]) slots.integration_method = Slot(uri=SCHEMA.applicationCategory, name="integration_method", curie=SCHEMA.curie('applicationCategory'), model_uri=HERITAGE.integration_method, domain=None, range=Optional[str]) slots.partner_name = Slot(uri=HERITAGE.partner_name, name="partner_name", curie=HERITAGE.curie('partner_name'), model_uri=HERITAGE.partner_name, domain=None, range=Optional[str]) slots.partner_id = Slot(uri=HERITAGE.partner_id, name="partner_id", curie=HERITAGE.curie('partner_id'), model_uri=HERITAGE.partner_id, domain=None, range=Optional[Union[str, URIorCURIE]]) slots.partnership_type = Slot(uri=HERITAGE.partnership_type, name="partnership_type", curie=HERITAGE.curie('partnership_type'), model_uri=HERITAGE.partnership_type, domain=None, range=Optional[str]) slots.start_date = Slot(uri=HERITAGE.start_date, name="start_date", curie=HERITAGE.curie('start_date'), model_uri=HERITAGE.start_date, domain=None, range=Optional[Union[str, XSDDate]]) slots.end_date = Slot(uri=HERITAGE.end_date, name="end_date", curie=HERITAGE.curie('end_date'), model_uri=HERITAGE.end_date, domain=None, range=Optional[Union[str, XSDDate]]) slots.kvk_number = Slot(uri=DCTERMS.identifier, name="kvk_number", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.kvk_number, domain=None, range=Optional[str], pattern=re.compile(r'^[0-9]{8}$')) slots.gemeente_code = Slot(uri=TOOIONT.gemeente, name="gemeente_code", curie=TOOIONT.curie('gemeente'), model_uri=HERITAGE.gemeente_code, domain=None, range=Optional[str], pattern=re.compile(r'^[0-9]{4}$')) slots.work_id = Slot(uri=DCTERMS.identifier, name="work_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.work_id, domain=None, range=URIRef) slots.work_title = Slot(uri=DCTERMS.title, name="work_title", curie=DCTERMS.curie('title'), model_uri=HERITAGE.work_title, domain=None, range=Optional[str]) slots.work_subject = Slot(uri=DCTERMS.subject, name="work_subject", curie=DCTERMS.curie('subject'), model_uri=HERITAGE.work_subject, domain=None, range=Optional[Union[str, list[str]]]) slots.work_keywords = Slot(uri=SCHEMA.keywords, name="work_keywords", curie=SCHEMA.curie('keywords'), model_uri=HERITAGE.work_keywords, domain=None, range=Optional[Union[str, list[str]]]) slots.discipline = Slot(uri=HERITAGE.discipline, name="discipline", curie=HERITAGE.curie('discipline'), model_uri=HERITAGE.discipline, domain=None, range=Optional[Union[str, list[str]]]) slots.research_field = Slot(uri=HERITAGE.research_field, name="research_field", curie=HERITAGE.curie('research_field'), model_uri=HERITAGE.research_field, domain=None, range=Optional[Union[str, list[str]]]) slots.has_expression = Slot(uri=FRBR.realization, name="has_expression", curie=FRBR.curie('realization'), model_uri=HERITAGE.has_expression, domain=None, range=Optional[Union[Union[str, PublicationPublicationId], list[Union[str, PublicationPublicationId]]]]) slots.related_institutions = Slot(uri=HERITAGE.related_institutions, name="related_institutions", curie=HERITAGE.curie('related_institutions'), model_uri=HERITAGE.related_institutions, domain=None, range=Optional[Union[Union[str, HeritageCustodianId], list[Union[str, HeritageCustodianId]]]]) slots.publication_id = Slot(uri=DCTERMS.identifier, name="publication_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.publication_id, domain=None, range=URIRef) slots.title = Slot(uri=DCTERMS.title, name="title", curie=DCTERMS.curie('title'), model_uri=HERITAGE.title, domain=None, range=Optional[str]) slots.alternative_titles = Slot(uri=DCTERMS.alternative, name="alternative_titles", curie=DCTERMS.curie('alternative'), model_uri=HERITAGE.alternative_titles, domain=None, range=Optional[Union[str, list[str]]]) slots.publication_type = Slot(uri=DCTERMS.type, name="publication_type", curie=DCTERMS.curie('type'), model_uri=HERITAGE.publication_type, domain=None, range=Optional[Union[str, "PublicationTypeEnum"]]) slots.authors = Slot(uri=DCTERMS.creator, name="authors", curie=DCTERMS.curie('creator'), model_uri=HERITAGE.authors, domain=None, range=Optional[Union[dict[Union[str, PersonPersonId], Union[dict, Person]], list[Union[dict, Person]]]]) slots.editors = Slot(uri=BIBO.editor, name="editors", curie=BIBO.curie('editor'), model_uri=HERITAGE.editors, domain=None, range=Optional[Union[dict[Union[str, PersonPersonId], Union[dict, Person]], list[Union[dict, Person]]]]) slots.contributors = Slot(uri=DCTERMS.contributor, name="contributors", curie=DCTERMS.curie('contributor'), model_uri=HERITAGE.contributors, domain=None, range=Optional[Union[dict[Union[str, PersonPersonId], Union[dict, Person]], list[Union[dict, Person]]]]) slots.publication_date = Slot(uri=DCTERMS.issued, name="publication_date", curie=DCTERMS.curie('issued'), model_uri=HERITAGE.publication_date, domain=None, range=Optional[Union[str, XSDDate]]) slots.publication_year = Slot(uri=PRISM.publicationDate, name="publication_year", curie=PRISM.curie('publicationDate'), model_uri=HERITAGE.publication_year, domain=None, range=Optional[int]) slots.abstract = Slot(uri=DCTERMS.abstract, name="abstract", curie=DCTERMS.curie('abstract'), model_uri=HERITAGE.abstract, domain=None, range=Optional[str]) slots.keywords = Slot(uri=PRISM.keyword, name="keywords", curie=PRISM.curie('keyword'), model_uri=HERITAGE.keywords, domain=None, range=Optional[Union[str, list[str]]]) slots.language = Slot(uri=DCTERMS.language, name="language", curie=DCTERMS.curie('language'), model_uri=HERITAGE.language, domain=None, range=Optional[str]) slots.doi = Slot(uri=DATACITE.doi, name="doi", curie=DATACITE.curie('doi'), model_uri=HERITAGE.doi, domain=None, range=Optional[str], pattern=re.compile(r'^10\.\d{4,9}/[-._;()/:A-Za-z0-9]+$')) slots.url = Slot(uri=SCHEMA.url, name="url", curie=SCHEMA.curie('url'), model_uri=HERITAGE.url, domain=None, range=Optional[Union[str, URI]]) slots.published_in = Slot(uri=DCTERMS.isPartOf, name="published_in", curie=DCTERMS.curie('isPartOf'), model_uri=HERITAGE.published_in, domain=None, range=Optional[Union[str, JournalJournalId]]) slots.volume = Slot(uri=PRISM.volume, name="volume", curie=PRISM.curie('volume'), model_uri=HERITAGE.volume, domain=None, range=Optional[str]) slots.issue = Slot(uri=PRISM.number, name="issue", curie=PRISM.curie('number'), model_uri=HERITAGE.issue, domain=None, range=Optional[str]) slots.page_range = Slot(uri=PRISM.pageRange, name="page_range", curie=PRISM.curie('pageRange'), model_uri=HERITAGE.page_range, domain=None, range=Optional[str]) slots.article_number = Slot(uri=HERITAGE.article_number, name="article_number", curie=HERITAGE.curie('article_number'), model_uri=HERITAGE.article_number, domain=None, range=Optional[str]) slots.publisher = Slot(uri=DCTERMS.publisher, name="publisher", curie=DCTERMS.curie('publisher'), model_uri=HERITAGE.publisher, domain=None, range=Optional[Union[dict, Organization]]) slots.place_of_publication = Slot(uri=PRISM.location, name="place_of_publication", curie=PRISM.curie('location'), model_uri=HERITAGE.place_of_publication, domain=None, range=Optional[str]) slots.isbn = Slot(uri=BIBO.isbn, name="isbn", curie=BIBO.curie('isbn'), model_uri=HERITAGE.isbn, domain=None, range=Optional[str], pattern=re.compile(r'^(97[89])?[0-9]{9}[0-9X]$')) slots.issn = Slot(uri=BIBO.issn, name="issn", curie=BIBO.curie('issn'), model_uri=HERITAGE.issn, domain=None, range=Optional[str], pattern=re.compile(r'^\d{4}-\d{3}[\dX]$')) slots.eissn = Slot(uri=FABIO.hasElectronicISSN, name="eissn", curie=FABIO.curie('hasElectronicISSN'), model_uri=HERITAGE.eissn, domain=None, range=Optional[str], pattern=re.compile(r'^\d{4}-\d{3}[\dX]$')) slots.citations = Slot(uri=CITO.cites, name="citations", curie=CITO.curie('cites'), model_uri=HERITAGE.citations, domain=None, range=Optional[Union[dict[Union[str, CitationCitationId], Union[dict, Citation]], list[Union[dict, Citation]]]]) slots.cited_by = Slot(uri=CITO.isCitedBy, name="cited_by", curie=CITO.curie('isCitedBy'), model_uri=HERITAGE.cited_by, domain=None, range=Optional[Union[Union[str, CitationCitationId], list[Union[str, CitationCitationId]]]]) slots.related_works = Slot(uri=DCTERMS.relation, name="related_works", curie=DCTERMS.curie('relation'), model_uri=HERITAGE.related_works, domain=None, range=Optional[Union[Union[str, PublicationPublicationId], list[Union[str, PublicationPublicationId]]]]) slots.document_sections = Slot(uri=HERITAGE.document_sections, name="document_sections", curie=HERITAGE.curie('document_sections'), model_uri=HERITAGE.document_sections, domain=None, range=Optional[Union[dict[Union[str, DocumentSectionSectionId], Union[dict, DocumentSection]], list[Union[dict, DocumentSection]]]]) slots.open_access_status = Slot(uri=FABIO.hasOpenAccessStatus, name="open_access_status", curie=FABIO.curie('hasOpenAccessStatus'), model_uri=HERITAGE.open_access_status, domain=None, range=Optional[Union[str, "OpenAccessStatusEnum"]]) slots.publishing_status = Slot(uri=PSO.holdsStatusInTime, name="publishing_status", curie=PSO.curie('holdsStatusInTime'), model_uri=HERITAGE.publishing_status, domain=None, range=Optional[Union[str, "PublishingStatusEnum"]]) slots.peer_reviewed = Slot(uri=FABIO.hasPeerReviewStatus, name="peer_reviewed", curie=FABIO.curie('hasPeerReviewStatus'), model_uri=HERITAGE.peer_reviewed, domain=None, range=Optional[Union[bool, Bool]]) slots.license = Slot(uri=DCTERMS.license, name="license", curie=DCTERMS.curie('license'), model_uri=HERITAGE.license, domain=None, range=Optional[str]) slots.journal_id = Slot(uri=DCTERMS.identifier, name="journal_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.journal_id, domain=None, range=URIRef) slots.journal_title = Slot(uri=DCTERMS.title, name="journal_title", curie=DCTERMS.curie('title'), model_uri=HERITAGE.journal_title, domain=None, range=Optional[str]) slots.alternative_journal_titles = Slot(uri=DCTERMS.alternative, name="alternative_journal_titles", curie=DCTERMS.curie('alternative'), model_uri=HERITAGE.alternative_journal_titles, domain=None, range=Optional[Union[str, list[str]]]) slots.journal_url = Slot(uri=SCHEMA.url, name="journal_url", curie=SCHEMA.curie('url'), model_uri=HERITAGE.journal_url, domain=None, range=Optional[Union[str, URI]]) slots.impact_factor = Slot(uri=HERITAGE.impact_factor, name="impact_factor", curie=HERITAGE.curie('impact_factor'), model_uri=HERITAGE.impact_factor, domain=None, range=Optional[float]) slots.cite_score = Slot(uri=HERITAGE.cite_score, name="cite_score", curie=HERITAGE.curie('cite_score'), model_uri=HERITAGE.cite_score, domain=None, range=Optional[float]) slots.subject_areas = Slot(uri=DCTERMS.subject, name="subject_areas", curie=DCTERMS.curie('subject'), model_uri=HERITAGE.subject_areas, domain=None, range=Optional[Union[str, list[str]]]) slots.indexing_services = Slot(uri=HERITAGE.indexing_services, name="indexing_services", curie=HERITAGE.curie('indexing_services'), model_uri=HERITAGE.indexing_services, domain=None, range=Optional[Union[str, list[str]]]) slots.conference_id = Slot(uri=DCTERMS.identifier, name="conference_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.conference_id, domain=None, range=URIRef) slots.conference_name = Slot(uri=SCHEMA.name, name="conference_name", curie=SCHEMA.curie('name'), model_uri=HERITAGE.conference_name, domain=None, range=Optional[str]) slots.conference_acronym = Slot(uri=HERITAGE.conference_acronym, name="conference_acronym", curie=HERITAGE.curie('conference_acronym'), model_uri=HERITAGE.conference_acronym, domain=None, range=Optional[str]) slots.conference_date = Slot(uri=SCHEMA.startDate, name="conference_date", curie=SCHEMA.curie('startDate'), model_uri=HERITAGE.conference_date, domain=None, range=Optional[str]) slots.conference_location = Slot(uri=SCHEMA.location, name="conference_location", curie=SCHEMA.curie('location'), model_uri=HERITAGE.conference_location, domain=None, range=Optional[str]) slots.conference_url = Slot(uri=SCHEMA.url, name="conference_url", curie=SCHEMA.curie('url'), model_uri=HERITAGE.conference_url, domain=None, range=Optional[Union[str, URI]]) slots.proceedings_title = Slot(uri=HERITAGE.proceedings_title, name="proceedings_title", curie=HERITAGE.curie('proceedings_title'), model_uri=HERITAGE.proceedings_title, domain=None, range=Optional[str]) slots.proceedings_isbn = Slot(uri=HERITAGE.proceedings_isbn, name="proceedings_isbn", curie=HERITAGE.curie('proceedings_isbn'), model_uri=HERITAGE.proceedings_isbn, domain=None, range=Optional[str]) slots.proceedings_publisher = Slot(uri=HERITAGE.proceedings_publisher, name="proceedings_publisher", curie=HERITAGE.curie('proceedings_publisher'), model_uri=HERITAGE.proceedings_publisher, domain=None, range=Optional[Union[dict, Organization]]) slots.person_id = Slot(uri=DCTERMS.identifier, name="person_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.person_id, domain=None, range=URIRef) slots.person_name = Slot(uri=FOAF.name, name="person_name", curie=FOAF.curie('name'), model_uri=HERITAGE.person_name, domain=None, range=Optional[str]) slots.given_name = Slot(uri=FOAF.givenName, name="given_name", curie=FOAF.curie('givenName'), model_uri=HERITAGE.given_name, domain=None, range=Optional[str]) slots.family_name = Slot(uri=FOAF.familyName, name="family_name", curie=FOAF.curie('familyName'), model_uri=HERITAGE.family_name, domain=None, range=Optional[str]) slots.orcid = Slot(uri=DATACITE.orcid, name="orcid", curie=DATACITE.curie('orcid'), model_uri=HERITAGE.orcid, domain=None, range=Optional[str], pattern=re.compile(r'^\d{4}-\d{4}-\d{4}-\d{3}[0-9X]$')) slots.affiliation = Slot(uri=SCHEMA.affiliation, name="affiliation", curie=SCHEMA.curie('affiliation'), model_uri=HERITAGE.affiliation, domain=None, range=Optional[Union[dict, Organization]]) slots.roles = Slot(uri=HERITAGE.roles, name="roles", curie=HERITAGE.curie('roles'), model_uri=HERITAGE.roles, domain=None, range=Optional[Union[Union[dict, PublishingRole], list[Union[dict, PublishingRole]]]]) slots.organization_id = Slot(uri=DCTERMS.identifier, name="organization_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.organization_id, domain=None, range=URIRef) slots.organization_name = Slot(uri=SCHEMA.name, name="organization_name", curie=SCHEMA.curie('name'), model_uri=HERITAGE.organization_name, domain=None, range=Optional[str]) slots.organization_type = Slot(uri=SCHEMA.additionalType, name="organization_type", curie=SCHEMA.curie('additionalType'), model_uri=HERITAGE.organization_type, domain=None, range=Optional[str]) slots.location = Slot(uri=SCHEMA.location, name="location", curie=SCHEMA.curie('location'), model_uri=HERITAGE.location, domain=None, range=Optional[str]) slots.ror_id = Slot(uri=HERITAGE.ror_id, name="ror_id", curie=HERITAGE.curie('ror_id'), model_uri=HERITAGE.ror_id, domain=None, range=Optional[str], pattern=re.compile(r'^https://ror\.org/0[a-z0-9]{6}[0-9]{2}$')) slots.citation_id = Slot(uri=DCTERMS.identifier, name="citation_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.citation_id, domain=None, range=URIRef) slots.citing_work = Slot(uri=CITO.hasCitingEntity, name="citing_work", curie=CITO.curie('hasCitingEntity'), model_uri=HERITAGE.citing_work, domain=None, range=Optional[Union[str, PublicationPublicationId]]) slots.cited_work = Slot(uri=CITO.hasCitedEntity, name="cited_work", curie=CITO.curie('hasCitedEntity'), model_uri=HERITAGE.cited_work, domain=None, range=Optional[Union[str, PublicationPublicationId]]) slots.citation_type = Slot(uri=CITO.hasCitationCharacterization, name="citation_type", curie=CITO.curie('hasCitationCharacterization'), model_uri=HERITAGE.citation_type, domain=None, range=Optional[Union[str, "CitationTypeEnum"]]) slots.citation_intent = Slot(uri=CITO.hasCitationIntent, name="citation_intent", curie=CITO.curie('hasCitationIntent'), model_uri=HERITAGE.citation_intent, domain=None, range=Optional[str]) slots.citation_context = Slot(uri=HERITAGE.citation_context, name="citation_context", curie=HERITAGE.curie('citation_context'), model_uri=HERITAGE.citation_context, domain=None, range=Optional[str]) slots.page_number = Slot(uri=HERITAGE.page_number, name="page_number", curie=HERITAGE.curie('page_number'), model_uri=HERITAGE.page_number, domain=None, range=Optional[str]) slots.section_id = Slot(uri=DCTERMS.identifier, name="section_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.section_id, domain=None, range=URIRef) slots.section_title = Slot(uri=DCTERMS.title, name="section_title", curie=DCTERMS.curie('title'), model_uri=HERITAGE.section_title, domain=None, range=Optional[str]) slots.section_type = Slot(uri=DCTERMS.type, name="section_type", curie=DCTERMS.curie('type'), model_uri=HERITAGE.section_type, domain=None, range=Optional[Union[str, "DocumentSectionTypeEnum"]]) slots.section_content = Slot(uri=HERITAGE.section_content, name="section_content", curie=HERITAGE.curie('section_content'), model_uri=HERITAGE.section_content, domain=None, range=Optional[str]) slots.section_order = Slot(uri=HERITAGE.section_order, name="section_order", curie=HERITAGE.curie('section_order'), model_uri=HERITAGE.section_order, domain=None, range=Optional[int]) slots.role_type = Slot(uri=PRO.withRole, name="role_type", curie=PRO.curie('withRole'), model_uri=HERITAGE.role_type, domain=None, range=Optional[Union[str, "PublishingRoleTypeEnum"]]) slots.role_holder = Slot(uri=PRO.isHeldBy, name="role_holder", curie=PRO.curie('isHeldBy'), model_uri=HERITAGE.role_holder, domain=None, range=Optional[Union[str, PersonPersonId]]) slots.role_context = Slot(uri=HERITAGE.role_context, name="role_context", curie=HERITAGE.curie('role_context'), model_uri=HERITAGE.role_context, domain=None, range=Optional[str]) slots.HeritageCustodian_id = Slot(uri=DCTERMS.identifier, name="HeritageCustodian_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.HeritageCustodian_id, domain=HeritageCustodian, range=Union[str, HeritageCustodianId]) slots.HeritageCustodian_name = Slot(uri=SCHEMA.name, name="HeritageCustodian_name", curie=SCHEMA.curie('name'), model_uri=HERITAGE.HeritageCustodian_name, domain=HeritageCustodian, range=str) slots.HeritageCustodian_institution_type = Slot(uri=DCTERMS.type, name="HeritageCustodian_institution_type", curie=DCTERMS.curie('type'), model_uri=HERITAGE.HeritageCustodian_institution_type, domain=HeritageCustodian, range=Union[str, "InstitutionTypeEnum"]) slots.Identifier_identifier_scheme = Slot(uri=HERITAGE.identifier_scheme, name="Identifier_identifier_scheme", curie=HERITAGE.curie('identifier_scheme'), model_uri=HERITAGE.Identifier_identifier_scheme, domain=Identifier, range=str) slots.Identifier_identifier_value = Slot(uri=HERITAGE.identifier_value, name="Identifier_identifier_value", curie=HERITAGE.curie('identifier_value'), model_uri=HERITAGE.Identifier_identifier_value, domain=Identifier, range=str) slots.OrganizationalUnit_unit_id = Slot(uri=DCTERMS.identifier, name="OrganizationalUnit_unit_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.OrganizationalUnit_unit_id, domain=OrganizationalUnit, range=Union[str, OrganizationalUnitUnitId]) slots.OrganizationalUnit_unit_name = Slot(uri=ORG.unitName, name="OrganizationalUnit_unit_name", curie=ORG.curie('unitName'), model_uri=HERITAGE.OrganizationalUnit_unit_name, domain=OrganizationalUnit, range=str) slots.EnrichmentHistoryEntry_enrichment_date = Slot(uri=PROV.atTime, name="EnrichmentHistoryEntry_enrichment_date", curie=PROV.curie('atTime'), model_uri=HERITAGE.EnrichmentHistoryEntry_enrichment_date, domain=EnrichmentHistoryEntry, range=Union[str, XSDDateTime]) slots.EnrichmentHistoryEntry_enrichment_method = Slot(uri=PROV.hadPlan, name="EnrichmentHistoryEntry_enrichment_method", curie=PROV.curie('hadPlan'), model_uri=HERITAGE.EnrichmentHistoryEntry_enrichment_method, domain=EnrichmentHistoryEntry, range=str) slots.EnrichmentHistoryEntry_enrichment_type = Slot(uri=RDF.type, name="EnrichmentHistoryEntry_enrichment_type", curie=RDF.curie('type'), model_uri=HERITAGE.EnrichmentHistoryEntry_enrichment_type, domain=EnrichmentHistoryEntry, range=Union[str, "EnrichmentTypeEnum"]) slots.EnrichmentHistoryEntry_match_score = Slot(uri=ADMS.confidence, name="EnrichmentHistoryEntry_match_score", curie=ADMS.curie('confidence'), model_uri=HERITAGE.EnrichmentHistoryEntry_match_score, domain=EnrichmentHistoryEntry, range=Optional[float]) slots.EnrichmentHistoryEntry_verified = Slot(uri=ADMS.status, name="EnrichmentHistoryEntry_verified", curie=ADMS.curie('status'), model_uri=HERITAGE.EnrichmentHistoryEntry_verified, domain=EnrichmentHistoryEntry, range=Union[bool, Bool]) slots.EnrichmentHistoryEntry_enrichment_source = Slot(uri=DCTERMS.source, name="EnrichmentHistoryEntry_enrichment_source", curie=DCTERMS.curie('source'), model_uri=HERITAGE.EnrichmentHistoryEntry_enrichment_source, domain=EnrichmentHistoryEntry, range=Optional[Union[str, URI]]) slots.EnrichmentHistoryEntry_enrichment_notes = Slot(uri=DCTERMS.description, name="EnrichmentHistoryEntry_enrichment_notes", curie=DCTERMS.curie('description'), model_uri=HERITAGE.EnrichmentHistoryEntry_enrichment_notes, domain=EnrichmentHistoryEntry, range=Optional[str]) slots.GHCIDHistoryEntry_ghcid = Slot(uri=HERITAGE.ghcid, name="GHCIDHistoryEntry_ghcid", curie=HERITAGE.curie('ghcid'), model_uri=HERITAGE.GHCIDHistoryEntry_ghcid, domain=GHCIDHistoryEntry, range=str, pattern=re.compile(r'^[A-Z]{2}-[A-Z0-9]{1,3}-[A-Z]{3}-[A-Z]-[A-Z0-9]{1,10}(-Q[0-9]+)?$')) slots.GHCIDHistoryEntry_ghcid_numeric = Slot(uri=DCTERMS.identifier, name="GHCIDHistoryEntry_ghcid_numeric", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.GHCIDHistoryEntry_ghcid_numeric, domain=GHCIDHistoryEntry, range=int) slots.GHCIDHistoryEntry_valid_from = Slot(uri=HERITAGE.valid_from, name="GHCIDHistoryEntry_valid_from", curie=HERITAGE.curie('valid_from'), model_uri=HERITAGE.GHCIDHistoryEntry_valid_from, domain=GHCIDHistoryEntry, range=Union[str, XSDDateTime]) slots.GHCIDHistoryEntry_valid_to = Slot(uri=HERITAGE.valid_to, name="GHCIDHistoryEntry_valid_to", curie=HERITAGE.curie('valid_to'), model_uri=HERITAGE.GHCIDHistoryEntry_valid_to, domain=GHCIDHistoryEntry, range=Optional[Union[str, XSDDateTime]]) slots.GHCIDHistoryEntry_reason = Slot(uri=HERITAGE.reason, name="GHCIDHistoryEntry_reason", curie=HERITAGE.curie('reason'), model_uri=HERITAGE.GHCIDHistoryEntry_reason, domain=GHCIDHistoryEntry, range=str) slots.GHCIDHistoryEntry_institution_name = Slot(uri=HERITAGE.institution_name, name="GHCIDHistoryEntry_institution_name", curie=HERITAGE.curie('institution_name'), model_uri=HERITAGE.GHCIDHistoryEntry_institution_name, domain=GHCIDHistoryEntry, range=str) slots.GHCIDHistoryEntry_location_city = Slot(uri=HERITAGE.location_city, name="GHCIDHistoryEntry_location_city", curie=HERITAGE.curie('location_city'), model_uri=HERITAGE.GHCIDHistoryEntry_location_city, domain=GHCIDHistoryEntry, range=str) slots.GHCIDHistoryEntry_location_country = Slot(uri=HERITAGE.location_country, name="GHCIDHistoryEntry_location_country", curie=HERITAGE.curie('location_country'), model_uri=HERITAGE.GHCIDHistoryEntry_location_country, domain=GHCIDHistoryEntry, range=str) slots.ChangeEvent_event_id = Slot(uri=DCTERMS.identifier, name="ChangeEvent_event_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.ChangeEvent_event_id, domain=ChangeEvent, range=Union[str, ChangeEventEventId]) slots.ChangeEvent_change_type = Slot(uri=RDF.type, name="ChangeEvent_change_type", curie=RDF.curie('type'), model_uri=HERITAGE.ChangeEvent_change_type, domain=ChangeEvent, range=Union[str, "ChangeTypeEnum"]) slots.ChangeEvent_event_date = Slot(uri=PROV.atTime, name="ChangeEvent_event_date", curie=PROV.curie('atTime'), model_uri=HERITAGE.ChangeEvent_event_date, domain=ChangeEvent, range=Union[str, XSDDate]) slots.DutchHeritageCustodian_identifiers = Slot(uri=HERITAGE.identifiers, name="DutchHeritageCustodian_identifiers", curie=HERITAGE.curie('identifiers'), model_uri=HERITAGE.DutchHeritageCustodian_identifiers, domain=DutchHeritageCustodian, range=Optional[Union[Union[dict, Identifier], list[Union[dict, Identifier]]]]) slots.DutchHeritageCustodian_partnerships = Slot(uri=HERITAGE.partnerships, name="DutchHeritageCustodian_partnerships", curie=HERITAGE.curie('partnerships'), model_uri=HERITAGE.DutchHeritageCustodian_partnerships, domain=DutchHeritageCustodian, range=Optional[Union[Union[dict, Partnership], list[Union[dict, Partnership]]]]) slots.DutchHeritageCustodian_locations = Slot(uri=HERITAGE.locations, name="DutchHeritageCustodian_locations", curie=HERITAGE.curie('locations'), model_uri=HERITAGE.DutchHeritageCustodian_locations, domain=DutchHeritageCustodian, range=Optional[Union[Union[dict, Location], list[Union[dict, Location]]]]) slots.Publication_publication_id = Slot(uri=DCTERMS.identifier, name="Publication_publication_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.Publication_publication_id, domain=Publication, range=Union[str, PublicationPublicationId]) slots.Publication_title = Slot(uri=DCTERMS.title, name="Publication_title", curie=DCTERMS.curie('title'), model_uri=HERITAGE.Publication_title, domain=Publication, range=str) slots.Publication_publication_type = Slot(uri=DCTERMS.type, name="Publication_publication_type", curie=DCTERMS.curie('type'), model_uri=HERITAGE.Publication_publication_type, domain=Publication, range=Union[str, "PublicationTypeEnum"]) slots.Journal_journal_id = Slot(uri=DCTERMS.identifier, name="Journal_journal_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.Journal_journal_id, domain=Journal, range=Union[str, JournalJournalId]) slots.Journal_journal_title = Slot(uri=DCTERMS.title, name="Journal_journal_title", curie=DCTERMS.curie('title'), model_uri=HERITAGE.Journal_journal_title, domain=Journal, range=str) slots.Conference_conference_id = Slot(uri=DCTERMS.identifier, name="Conference_conference_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.Conference_conference_id, domain=Conference, range=Union[str, ConferenceConferenceId]) slots.Conference_conference_name = Slot(uri=SCHEMA.name, name="Conference_conference_name", curie=SCHEMA.curie('name'), model_uri=HERITAGE.Conference_conference_name, domain=Conference, range=str) slots.Person_person_id = Slot(uri=DCTERMS.identifier, name="Person_person_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.Person_person_id, domain=Person, range=Union[str, PersonPersonId]) slots.Person_person_name = Slot(uri=FOAF.name, name="Person_person_name", curie=FOAF.curie('name'), model_uri=HERITAGE.Person_person_name, domain=Person, range=str) slots.Organization_organization_id = Slot(uri=DCTERMS.identifier, name="Organization_organization_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.Organization_organization_id, domain=Organization, range=Union[str, OrganizationOrganizationId]) slots.Organization_organization_name = Slot(uri=SCHEMA.name, name="Organization_organization_name", curie=SCHEMA.curie('name'), model_uri=HERITAGE.Organization_organization_name, domain=Organization, range=str) slots.Citation_citation_id = Slot(uri=DCTERMS.identifier, name="Citation_citation_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.Citation_citation_id, domain=Citation, range=Union[str, CitationCitationId]) slots.Citation_citing_work = Slot(uri=CITO.hasCitingEntity, name="Citation_citing_work", curie=CITO.curie('hasCitingEntity'), model_uri=HERITAGE.Citation_citing_work, domain=Citation, range=Union[str, PublicationPublicationId]) slots.Citation_cited_work = Slot(uri=CITO.hasCitedEntity, name="Citation_cited_work", curie=CITO.curie('hasCitedEntity'), model_uri=HERITAGE.Citation_cited_work, domain=Citation, range=Union[str, PublicationPublicationId]) slots.Citation_citation_type = Slot(uri=CITO.hasCitationCharacterization, name="Citation_citation_type", curie=CITO.curie('hasCitationCharacterization'), model_uri=HERITAGE.Citation_citation_type, domain=Citation, range=Union[str, "CitationTypeEnum"]) slots.DocumentSection_section_id = Slot(uri=DCTERMS.identifier, name="DocumentSection_section_id", curie=DCTERMS.curie('identifier'), model_uri=HERITAGE.DocumentSection_section_id, domain=DocumentSection, range=Union[str, DocumentSectionSectionId]) slots.PublishingRole_role_type = Slot(uri=PRO.withRole, name="PublishingRole_role_type", curie=PRO.curie('withRole'), model_uri=HERITAGE.PublishingRole_role_type, domain=PublishingRole, range=Union[str, "PublishingRoleTypeEnum"]) slots.PublishingRole_role_holder = Slot(uri=PRO.isHeldBy, name="PublishingRole_role_holder", curie=PRO.curie('isHeldBy'), model_uri=HERITAGE.PublishingRole_role_holder, domain=PublishingRole, range=Union[str, PersonPersonId]) # ============================================================================= # BACKWARD COMPATIBILITY ALIASES # ============================================================================= # These aliases maintain backward compatibility with code that uses the old # enum names without the "Enum" suffix. New code should use the full names. # ============================================================================= # Enum aliases (old name -> new name) InstitutionType = InstitutionTypeEnum OrganizationStatus = OrganizationStatusEnum DataSource = DataSourceEnum DataTier = DataTierEnum MetadataStandard = MetadataStandardEnum DigitalPlatformType = DigitalPlatformTypeEnum ChangeType = ChangeTypeEnum EnrichmentType = EnrichmentTypeEnum PublicationType = PublicationTypeEnum CitationType = CitationTypeEnum OpenAccessStatus = OpenAccessStatusEnum PublishingStatus = PublishingStatusEnum DocumentSectionType = DocumentSectionTypeEnum PublishingRoleType = PublishingRoleTypeEnum