# Auto generated from referansemodell-gold-schema.yaml by pythongen.py version: 0.0.1
# Generation date: 2026-08-15T06:19:26
# Schema: referansemodell-gold
#
# id: https://data.norge.no/linkml/referansemodell-gold
# description: Viser minstekrava for å bestå gullpolicyen: alle sølv-krav pluss FAIR-metadata (title, version, prefiks, lisens, proveniens).
# 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 Date, String, Uriorcurie
from linkml_runtime.utils.metamodelcore import URIorCURIE, XSDDate

metamodel_version = "1.11.0"
version = "1.0.0"

# Namespaces
DCAT = CurieNamespace('dcat', 'http://www.w3.org/ns/dcat#')
DCT = CurieNamespace('dct', 'http://purl.org/dc/terms/')
DQV = CurieNamespace('dqv', 'http://www.w3.org/ns/dqv#')
EX = CurieNamespace('ex', 'https://example.org/vocab/')
FOAF = CurieNamespace('foaf', 'http://xmlns.com/foaf/0.1/')
LINKML = CurieNamespace('linkml', 'https://w3id.org/linkml/')
DEFAULT_ = CurieNamespace('', 'https://data.norge.no/linkml/referansemodell-gold/')


# Types

# Class references
class KatalogId(URIorCURIE):
    pass


class KatalogpostId(URIorCURIE):
    pass


class DatasettId(URIorCURIE):
    pass


class DistribusjonId(URIorCURIE):
    pass


class DatatjenesteId(URIorCURIE):
    pass


class AktorId(URIorCURIE):
    pass


class KvalitetsmaalId(URIorCURIE):
    pass


class KvalitetsmaalingId(URIorCURIE):
    pass


class KvalitetsdimensjonId(URIorCURIE):
    pass


class KvalitetsmerknadId(URIorCURIE):
    pass


@dataclass(repr=False)
class ReferanseGullContainer(YAMLRoot):
    """
    Toppnivåobjekt for datafila — samlar alle AP-NO- og DQV-AP-NO-entitetar.
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/ReferanseGullContainer")
    class_class_curie: ClassVar[str] = None
    class_name: ClassVar[str] = "ReferanseGullContainer"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/ReferanseGullContainer")

    katalogar: Optional[Union[dict[Union[str, KatalogId], Union[dict, "Katalog"]], list[Union[dict, "Katalog"]]]] = empty_dict()
    katalogpostar: Optional[Union[dict[Union[str, KatalogpostId], Union[dict, "Katalogpost"]], list[Union[dict, "Katalogpost"]]]] = empty_dict()
    datasett: Optional[Union[dict[Union[str, DatasettId], Union[dict, "Datasett"]], list[Union[dict, "Datasett"]]]] = empty_dict()
    distribusjoner: Optional[Union[dict[Union[str, DistribusjonId], Union[dict, "Distribusjon"]], list[Union[dict, "Distribusjon"]]]] = empty_dict()
    datatenestar: Optional[Union[dict[Union[str, DatatjenesteId], Union[dict, "Datatjeneste"]], list[Union[dict, "Datatjeneste"]]]] = empty_dict()
    aktorar: Optional[Union[dict[Union[str, AktorId], Union[dict, "Aktor"]], list[Union[dict, "Aktor"]]]] = empty_dict()
    kvalitetsmaal: Optional[Union[list[Union[str, KvalitetsmaalId]], dict[Union[str, KvalitetsmaalId], Union[dict, "Kvalitetsmaal"]]]] = empty_dict()
    kvalitetsmaalingar: Optional[Union[list[Union[str, KvalitetsmaalingId]], dict[Union[str, KvalitetsmaalingId], Union[dict, "Kvalitetsmaaling"]]]] = empty_dict()
    kvalitetsdimensjonar: Optional[Union[list[Union[str, KvalitetsdimensjonId]], dict[Union[str, KvalitetsdimensjonId], Union[dict, "Kvalitetsdimensjon"]]]] = empty_dict()
    kvalitetsmerknader: Optional[Union[list[Union[str, KvalitetsmerknadId]], dict[Union[str, KvalitetsmerknadId], Union[dict, "Kvalitetsmerknad"]]]] = empty_dict()

    def __post_init__(self, *_: str, **kwargs: Any):
        self._normalize_inlined_as_list(slot_name="katalogar", slot_type=Katalog, key_name="id", keyed=True)

        self._normalize_inlined_as_list(slot_name="katalogpostar", slot_type=Katalogpost, key_name="id", keyed=True)

        self._normalize_inlined_as_list(slot_name="datasett", slot_type=Datasett, key_name="id", keyed=True)

        self._normalize_inlined_as_list(slot_name="distribusjoner", slot_type=Distribusjon, key_name="id", keyed=True)

        self._normalize_inlined_as_list(slot_name="datatenestar", slot_type=Datatjeneste, key_name="id", keyed=True)

        self._normalize_inlined_as_list(slot_name="aktorar", slot_type=Aktor, key_name="id", keyed=True)

        self._normalize_inlined_as_list(slot_name="kvalitetsmaal", slot_type=Kvalitetsmaal, key_name="id", keyed=True)

        self._normalize_inlined_as_list(slot_name="kvalitetsmaalingar", slot_type=Kvalitetsmaaling, key_name="id", keyed=True)

        self._normalize_inlined_as_list(slot_name="kvalitetsdimensjonar", slot_type=Kvalitetsdimensjon, key_name="id", keyed=True)

        self._normalize_inlined_as_list(slot_name="kvalitetsmerknader", slot_type=Kvalitetsmerknad, key_name="id", keyed=True)

        super().__post_init__(**kwargs)


@dataclass(repr=False)
class Katalog(YAMLRoot):
    """
    Samling av datasett, datatenestar og distribusjonar.
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = DCAT["Catalog"]
    class_class_curie: ClassVar[str] = "dcat:Catalog"
    class_name: ClassVar[str] = "Katalog"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/Katalog")

    id: Union[str, KatalogId] = None
    tittel: str = None
    skildring: str = None
    kontaktpunkt: Union[str, URIorCURIE] = None
    utgjevar: Union[str, URIorCURIE] = None
    lisens: Optional[Union[str, URIorCURIE]] = None

    def __post_init__(self, *_: str, **kwargs: Any):
        if self._is_empty(self.id):
            self.MissingRequiredField("id")
        if not isinstance(self.id, KatalogId):
            self.id = KatalogId(self.id)

        if self._is_empty(self.tittel):
            self.MissingRequiredField("tittel")
        if not isinstance(self.tittel, str):
            self.tittel = str(self.tittel)

        if self._is_empty(self.skildring):
            self.MissingRequiredField("skildring")
        if not isinstance(self.skildring, str):
            self.skildring = str(self.skildring)

        if self._is_empty(self.kontaktpunkt):
            self.MissingRequiredField("kontaktpunkt")
        if not isinstance(self.kontaktpunkt, URIorCURIE):
            self.kontaktpunkt = URIorCURIE(self.kontaktpunkt)

        if self._is_empty(self.utgjevar):
            self.MissingRequiredField("utgjevar")
        if not isinstance(self.utgjevar, URIorCURIE):
            self.utgjevar = URIorCURIE(self.utgjevar)

        if self.lisens is not None and not isinstance(self.lisens, URIorCURIE):
            self.lisens = URIorCURIE(self.lisens)

        super().__post_init__(**kwargs)


@dataclass(repr=False)
class Katalogpost(YAMLRoot):
    """
    Oppføring i ein katalog som skildrar ein ressurs.
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = DCAT["CatalogRecord"]
    class_class_curie: ClassVar[str] = "dcat:CatalogRecord"
    class_name: ClassVar[str] = "Katalogpost"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/Katalogpost")

    id: Union[str, KatalogpostId] = None
    endringsdato: Union[str, XSDDate] = None
    primaertema: Union[str, URIorCURIE] = None

    def __post_init__(self, *_: str, **kwargs: Any):
        if self._is_empty(self.id):
            self.MissingRequiredField("id")
        if not isinstance(self.id, KatalogpostId):
            self.id = KatalogpostId(self.id)

        if self._is_empty(self.endringsdato):
            self.MissingRequiredField("endringsdato")
        if not isinstance(self.endringsdato, XSDDate):
            self.endringsdato = XSDDate(self.endringsdato)

        if self._is_empty(self.primaertema):
            self.MissingRequiredField("primaertema")
        if not isinstance(self.primaertema, URIorCURIE):
            self.primaertema = URIorCURIE(self.primaertema)

        super().__post_init__(**kwargs)


@dataclass(repr=False)
class Datasett(YAMLRoot):
    """
    Ei samling av data, utgitt eller kuratert av ei einskild kjelde.
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = DCAT["Dataset"]
    class_class_curie: ClassVar[str] = "dcat:Dataset"
    class_name: ClassVar[str] = "Datasett"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/Datasett")

    id: Union[str, DatasettId] = None
    tittel: str = None
    skildring: str = None
    kontaktpunkt: Union[str, URIorCURIE] = None
    utgjevar: Union[str, URIorCURIE] = None
    tema: Union[str, URIorCURIE] = None
    lisens: Optional[Union[str, URIorCURIE]] = None

    def __post_init__(self, *_: str, **kwargs: Any):
        if self._is_empty(self.id):
            self.MissingRequiredField("id")
        if not isinstance(self.id, DatasettId):
            self.id = DatasettId(self.id)

        if self._is_empty(self.tittel):
            self.MissingRequiredField("tittel")
        if not isinstance(self.tittel, str):
            self.tittel = str(self.tittel)

        if self._is_empty(self.skildring):
            self.MissingRequiredField("skildring")
        if not isinstance(self.skildring, str):
            self.skildring = str(self.skildring)

        if self._is_empty(self.kontaktpunkt):
            self.MissingRequiredField("kontaktpunkt")
        if not isinstance(self.kontaktpunkt, URIorCURIE):
            self.kontaktpunkt = URIorCURIE(self.kontaktpunkt)

        if self._is_empty(self.utgjevar):
            self.MissingRequiredField("utgjevar")
        if not isinstance(self.utgjevar, URIorCURIE):
            self.utgjevar = URIorCURIE(self.utgjevar)

        if self._is_empty(self.tema):
            self.MissingRequiredField("tema")
        if not isinstance(self.tema, URIorCURIE):
            self.tema = URIorCURIE(self.tema)

        if self.lisens is not None and not isinstance(self.lisens, URIorCURIE):
            self.lisens = URIorCURIE(self.lisens)

        super().__post_init__(**kwargs)


@dataclass(repr=False)
class Distribusjon(YAMLRoot):
    """
    Ei spesifikk representasjon av eit datasett.
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = DCAT["Distribution"]
    class_class_curie: ClassVar[str] = "dcat:Distribution"
    class_name: ClassVar[str] = "Distribusjon"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/Distribusjon")

    id: Union[str, DistribusjonId] = None
    tilgangsurl: Union[str, URIorCURIE] = None

    def __post_init__(self, *_: str, **kwargs: Any):
        if self._is_empty(self.id):
            self.MissingRequiredField("id")
        if not isinstance(self.id, DistribusjonId):
            self.id = DistribusjonId(self.id)

        if self._is_empty(self.tilgangsurl):
            self.MissingRequiredField("tilgangsurl")
        if not isinstance(self.tilgangsurl, URIorCURIE):
            self.tilgangsurl = URIorCURIE(self.tilgangsurl)

        super().__post_init__(**kwargs)


@dataclass(repr=False)
class Datatjeneste(YAMLRoot):
    """
    Ei samling av operasjonar som gir tilgang til data via eit grensesnitt.
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = DCAT["DataService"]
    class_class_curie: ClassVar[str] = "dcat:DataService"
    class_name: ClassVar[str] = "Datatjeneste"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/Datatjeneste")

    id: Union[str, DatatjenesteId] = None
    tittel: str = None
    kontaktpunkt: Union[str, URIorCURIE] = None
    utgjevar: Union[str, URIorCURIE] = None
    endepunktsurl: Union[str, URIorCURIE] = None

    def __post_init__(self, *_: str, **kwargs: Any):
        if self._is_empty(self.id):
            self.MissingRequiredField("id")
        if not isinstance(self.id, DatatjenesteId):
            self.id = DatatjenesteId(self.id)

        if self._is_empty(self.tittel):
            self.MissingRequiredField("tittel")
        if not isinstance(self.tittel, str):
            self.tittel = str(self.tittel)

        if self._is_empty(self.kontaktpunkt):
            self.MissingRequiredField("kontaktpunkt")
        if not isinstance(self.kontaktpunkt, URIorCURIE):
            self.kontaktpunkt = URIorCURIE(self.kontaktpunkt)

        if self._is_empty(self.utgjevar):
            self.MissingRequiredField("utgjevar")
        if not isinstance(self.utgjevar, URIorCURIE):
            self.utgjevar = URIorCURIE(self.utgjevar)

        if self._is_empty(self.endepunktsurl):
            self.MissingRequiredField("endepunktsurl")
        if not isinstance(self.endepunktsurl, URIorCURIE):
            self.endepunktsurl = URIorCURIE(self.endepunktsurl)

        super().__post_init__(**kwargs)


@dataclass(repr=False)
class Aktor(YAMLRoot):
    """
    Ein aktør (person, organisasjon eller programvaresystem).
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = FOAF["Agent"]
    class_class_curie: ClassVar[str] = "foaf:Agent"
    class_name: ClassVar[str] = "Aktor"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/Aktor")

    id: Union[str, AktorId] = None
    namn: str = None

    def __post_init__(self, *_: str, **kwargs: Any):
        if self._is_empty(self.id):
            self.MissingRequiredField("id")
        if not isinstance(self.id, AktorId):
            self.id = AktorId(self.id)

        if self._is_empty(self.namn):
            self.MissingRequiredField("namn")
        if not isinstance(self.namn, str):
            self.namn = str(self.namn)

        super().__post_init__(**kwargs)


@dataclass(repr=False)
class Kvalitetsmaal(YAMLRoot):
    """
    Eit mål for å evaluere kvaliteten til ein ressurs.
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = DQV["Metric"]
    class_class_curie: ClassVar[str] = "dqv:Metric"
    class_name: ClassVar[str] = "Kvalitetsmaal"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/Kvalitetsmaal")

    id: Union[str, KvalitetsmaalId] = None

    def __post_init__(self, *_: str, **kwargs: Any):
        if self._is_empty(self.id):
            self.MissingRequiredField("id")
        if not isinstance(self.id, KvalitetsmaalId):
            self.id = KvalitetsmaalId(self.id)

        super().__post_init__(**kwargs)


@dataclass(repr=False)
class Kvalitetsmaaling(YAMLRoot):
    """
    Resultat av å evaluere eit datasett mot eit kvalitetsmål.
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = DQV["QualityMeasurement"]
    class_class_curie: ClassVar[str] = "dqv:QualityMeasurement"
    class_name: ClassVar[str] = "Kvalitetsmaaling"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/Kvalitetsmaaling")

    id: Union[str, KvalitetsmaalingId] = None

    def __post_init__(self, *_: str, **kwargs: Any):
        if self._is_empty(self.id):
            self.MissingRequiredField("id")
        if not isinstance(self.id, KvalitetsmaalingId):
            self.id = KvalitetsmaalingId(self.id)

        super().__post_init__(**kwargs)


@dataclass(repr=False)
class Kvalitetsdimensjon(YAMLRoot):
    """
    Ein kategori av kvalitetsegenskapar for data.
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = DQV["Dimension"]
    class_class_curie: ClassVar[str] = "dqv:Dimension"
    class_name: ClassVar[str] = "Kvalitetsdimensjon"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/Kvalitetsdimensjon")

    id: Union[str, KvalitetsdimensjonId] = None

    def __post_init__(self, *_: str, **kwargs: Any):
        if self._is_empty(self.id):
            self.MissingRequiredField("id")
        if not isinstance(self.id, KvalitetsdimensjonId):
            self.id = KvalitetsdimensjonId(self.id)

        super().__post_init__(**kwargs)


@dataclass(repr=False)
class Kvalitetsmerknad(YAMLRoot):
    """
    Ei kvalitetsvurdering av ein ressurs.
    """
    _inherited_slots: ClassVar[list[str]] = []

    class_class_uri: ClassVar[URIRef] = DQV["QualityAnnotation"]
    class_class_curie: ClassVar[str] = "dqv:QualityAnnotation"
    class_name: ClassVar[str] = "Kvalitetsmerknad"
    class_model_uri: ClassVar[URIRef] = URIRef("https://data.norge.no/linkml/referansemodell-gold/Kvalitetsmerknad")

    id: Union[str, KvalitetsmerknadId] = None

    def __post_init__(self, *_: str, **kwargs: Any):
        if self._is_empty(self.id):
            self.MissingRequiredField("id")
        if not isinstance(self.id, KvalitetsmerknadId):
            self.id = KvalitetsmerknadId(self.id)

        super().__post_init__(**kwargs)


# Enumerations


# Slots
class slots:
    pass

slots.id = Slot(uri=DCT.identifier, name="id", curie=DCT.curie('identifier'),
                   model_uri=DEFAULT_.id, domain=None, range=URIRef)

slots.tittel = Slot(uri=DCT.title, name="tittel", curie=DCT.curie('title'),
                   model_uri=DEFAULT_.tittel, domain=None, range=Optional[str])

slots.skildring = Slot(uri=DCT.description, name="skildring", curie=DCT.curie('description'),
                   model_uri=DEFAULT_.skildring, domain=None, range=Optional[str])

slots.kontaktpunkt = Slot(uri=DCAT.contactPoint, name="kontaktpunkt", curie=DCAT.curie('contactPoint'),
                   model_uri=DEFAULT_.kontaktpunkt, domain=None, range=Optional[Union[str, URIorCURIE]])

slots.utgjevar = Slot(uri=DCT.publisher, name="utgjevar", curie=DCT.curie('publisher'),
                   model_uri=DEFAULT_.utgjevar, domain=None, range=Optional[Union[str, URIorCURIE]])

slots.endringsdato = Slot(uri=DCT.modified, name="endringsdato", curie=DCT.curie('modified'),
                   model_uri=DEFAULT_.endringsdato, domain=None, range=Optional[Union[str, XSDDate]])

slots.primaertema = Slot(uri=FOAF.primaryTopic, name="primaertema", curie=FOAF.curie('primaryTopic'),
                   model_uri=DEFAULT_.primaertema, domain=None, range=Optional[Union[str, URIorCURIE]])

slots.tema = Slot(uri=DCAT.theme, name="tema", curie=DCAT.curie('theme'),
                   model_uri=DEFAULT_.tema, domain=None, range=Optional[Union[str, URIorCURIE]])

slots.tilgangsurl = Slot(uri=DCAT.accessURL, name="tilgangsurl", curie=DCAT.curie('accessURL'),
                   model_uri=DEFAULT_.tilgangsurl, domain=None, range=Optional[Union[str, URIorCURIE]])

slots.endepunktsurl = Slot(uri=DCAT.endpointURL, name="endepunktsurl", curie=DCAT.curie('endpointURL'),
                   model_uri=DEFAULT_.endepunktsurl, domain=None, range=Optional[Union[str, URIorCURIE]])

slots.namn = Slot(uri=FOAF.name, name="namn", curie=FOAF.curie('name'),
                   model_uri=DEFAULT_.namn, domain=None, range=Optional[str])

slots.lisens = Slot(uri=DCT.license, name="lisens", curie=DCT.curie('license'),
                   model_uri=DEFAULT_.lisens, domain=None, range=Optional[Union[str, URIorCURIE]])

slots.referanseGullContainer__katalogar = Slot(uri=DEFAULT_.katalogar, name="referanseGullContainer__katalogar", curie=DEFAULT_.curie('katalogar'),
                   model_uri=DEFAULT_.referanseGullContainer__katalogar, domain=None, range=Optional[Union[dict[Union[str, KatalogId], Union[dict, Katalog]], list[Union[dict, Katalog]]]])

slots.referanseGullContainer__katalogpostar = Slot(uri=DEFAULT_.katalogpostar, name="referanseGullContainer__katalogpostar", curie=DEFAULT_.curie('katalogpostar'),
                   model_uri=DEFAULT_.referanseGullContainer__katalogpostar, domain=None, range=Optional[Union[dict[Union[str, KatalogpostId], Union[dict, Katalogpost]], list[Union[dict, Katalogpost]]]])

slots.referanseGullContainer__datasett = Slot(uri=DEFAULT_.datasett, name="referanseGullContainer__datasett", curie=DEFAULT_.curie('datasett'),
                   model_uri=DEFAULT_.referanseGullContainer__datasett, domain=None, range=Optional[Union[dict[Union[str, DatasettId], Union[dict, Datasett]], list[Union[dict, Datasett]]]])

slots.referanseGullContainer__distribusjoner = Slot(uri=DEFAULT_.distribusjoner, name="referanseGullContainer__distribusjoner", curie=DEFAULT_.curie('distribusjoner'),
                   model_uri=DEFAULT_.referanseGullContainer__distribusjoner, domain=None, range=Optional[Union[dict[Union[str, DistribusjonId], Union[dict, Distribusjon]], list[Union[dict, Distribusjon]]]])

slots.referanseGullContainer__datatenestar = Slot(uri=DEFAULT_.datatenestar, name="referanseGullContainer__datatenestar", curie=DEFAULT_.curie('datatenestar'),
                   model_uri=DEFAULT_.referanseGullContainer__datatenestar, domain=None, range=Optional[Union[dict[Union[str, DatatjenesteId], Union[dict, Datatjeneste]], list[Union[dict, Datatjeneste]]]])

slots.referanseGullContainer__aktorar = Slot(uri=DEFAULT_.aktorar, name="referanseGullContainer__aktorar", curie=DEFAULT_.curie('aktorar'),
                   model_uri=DEFAULT_.referanseGullContainer__aktorar, domain=None, range=Optional[Union[dict[Union[str, AktorId], Union[dict, Aktor]], list[Union[dict, Aktor]]]])

slots.referanseGullContainer__kvalitetsmaal = Slot(uri=DEFAULT_.kvalitetsmaal, name="referanseGullContainer__kvalitetsmaal", curie=DEFAULT_.curie('kvalitetsmaal'),
                   model_uri=DEFAULT_.referanseGullContainer__kvalitetsmaal, domain=None, range=Optional[Union[list[Union[str, KvalitetsmaalId]], dict[Union[str, KvalitetsmaalId], Union[dict, Kvalitetsmaal]]]])

slots.referanseGullContainer__kvalitetsmaalingar = Slot(uri=DEFAULT_.kvalitetsmaalingar, name="referanseGullContainer__kvalitetsmaalingar", curie=DEFAULT_.curie('kvalitetsmaalingar'),
                   model_uri=DEFAULT_.referanseGullContainer__kvalitetsmaalingar, domain=None, range=Optional[Union[list[Union[str, KvalitetsmaalingId]], dict[Union[str, KvalitetsmaalingId], Union[dict, Kvalitetsmaaling]]]])

slots.referanseGullContainer__kvalitetsdimensjonar = Slot(uri=DEFAULT_.kvalitetsdimensjonar, name="referanseGullContainer__kvalitetsdimensjonar", curie=DEFAULT_.curie('kvalitetsdimensjonar'),
                   model_uri=DEFAULT_.referanseGullContainer__kvalitetsdimensjonar, domain=None, range=Optional[Union[list[Union[str, KvalitetsdimensjonId]], dict[Union[str, KvalitetsdimensjonId], Union[dict, Kvalitetsdimensjon]]]])

slots.referanseGullContainer__kvalitetsmerknader = Slot(uri=DEFAULT_.kvalitetsmerknader, name="referanseGullContainer__kvalitetsmerknader", curie=DEFAULT_.curie('kvalitetsmerknader'),
                   model_uri=DEFAULT_.referanseGullContainer__kvalitetsmerknader, domain=None, range=Optional[Union[list[Union[str, KvalitetsmerknadId]], dict[Union[str, KvalitetsmerknadId], Union[dict, Kvalitetsmerknad]]]])

slots.Katalog_tittel = Slot(uri=DCT.title, name="Katalog_tittel", curie=DCT.curie('title'),
                   model_uri=DEFAULT_.Katalog_tittel, domain=Katalog, range=str)

slots.Katalog_skildring = Slot(uri=DCT.description, name="Katalog_skildring", curie=DCT.curie('description'),
                   model_uri=DEFAULT_.Katalog_skildring, domain=Katalog, range=str)

slots.Katalog_kontaktpunkt = Slot(uri=DCAT.contactPoint, name="Katalog_kontaktpunkt", curie=DCAT.curie('contactPoint'),
                   model_uri=DEFAULT_.Katalog_kontaktpunkt, domain=Katalog, range=Union[str, URIorCURIE])

slots.Katalog_utgjevar = Slot(uri=DCT.publisher, name="Katalog_utgjevar", curie=DCT.curie('publisher'),
                   model_uri=DEFAULT_.Katalog_utgjevar, domain=Katalog, range=Union[str, URIorCURIE])

slots.Katalog_lisens = Slot(uri=DCT.license, name="Katalog_lisens", curie=DCT.curie('license'),
                   model_uri=DEFAULT_.Katalog_lisens, domain=Katalog, range=Optional[Union[str, URIorCURIE]])

slots.Katalogpost_endringsdato = Slot(uri=DCT.modified, name="Katalogpost_endringsdato", curie=DCT.curie('modified'),
                   model_uri=DEFAULT_.Katalogpost_endringsdato, domain=Katalogpost, range=Union[str, XSDDate])

slots.Katalogpost_primaertema = Slot(uri=FOAF.primaryTopic, name="Katalogpost_primaertema", curie=FOAF.curie('primaryTopic'),
                   model_uri=DEFAULT_.Katalogpost_primaertema, domain=Katalogpost, range=Union[str, URIorCURIE])

slots.Datasett_tittel = Slot(uri=DCT.title, name="Datasett_tittel", curie=DCT.curie('title'),
                   model_uri=DEFAULT_.Datasett_tittel, domain=Datasett, range=str)

slots.Datasett_skildring = Slot(uri=DCT.description, name="Datasett_skildring", curie=DCT.curie('description'),
                   model_uri=DEFAULT_.Datasett_skildring, domain=Datasett, range=str)

slots.Datasett_kontaktpunkt = Slot(uri=DCAT.contactPoint, name="Datasett_kontaktpunkt", curie=DCAT.curie('contactPoint'),
                   model_uri=DEFAULT_.Datasett_kontaktpunkt, domain=Datasett, range=Union[str, URIorCURIE])

slots.Datasett_utgjevar = Slot(uri=DCT.publisher, name="Datasett_utgjevar", curie=DCT.curie('publisher'),
                   model_uri=DEFAULT_.Datasett_utgjevar, domain=Datasett, range=Union[str, URIorCURIE])

slots.Datasett_tema = Slot(uri=DCAT.theme, name="Datasett_tema", curie=DCAT.curie('theme'),
                   model_uri=DEFAULT_.Datasett_tema, domain=Datasett, range=Union[str, URIorCURIE])

slots.Datasett_lisens = Slot(uri=DCT.license, name="Datasett_lisens", curie=DCT.curie('license'),
                   model_uri=DEFAULT_.Datasett_lisens, domain=Datasett, range=Optional[Union[str, URIorCURIE]])

slots.Distribusjon_tilgangsurl = Slot(uri=DCAT.accessURL, name="Distribusjon_tilgangsurl", curie=DCAT.curie('accessURL'),
                   model_uri=DEFAULT_.Distribusjon_tilgangsurl, domain=Distribusjon, range=Union[str, URIorCURIE])

slots.Datatjeneste_tittel = Slot(uri=DCT.title, name="Datatjeneste_tittel", curie=DCT.curie('title'),
                   model_uri=DEFAULT_.Datatjeneste_tittel, domain=Datatjeneste, range=str)

slots.Datatjeneste_kontaktpunkt = Slot(uri=DCAT.contactPoint, name="Datatjeneste_kontaktpunkt", curie=DCAT.curie('contactPoint'),
                   model_uri=DEFAULT_.Datatjeneste_kontaktpunkt, domain=Datatjeneste, range=Union[str, URIorCURIE])

slots.Datatjeneste_utgjevar = Slot(uri=DCT.publisher, name="Datatjeneste_utgjevar", curie=DCT.curie('publisher'),
                   model_uri=DEFAULT_.Datatjeneste_utgjevar, domain=Datatjeneste, range=Union[str, URIorCURIE])

slots.Datatjeneste_endepunktsurl = Slot(uri=DCAT.endpointURL, name="Datatjeneste_endepunktsurl", curie=DCAT.curie('endpointURL'),
                   model_uri=DEFAULT_.Datatjeneste_endepunktsurl, domain=Datatjeneste, range=Union[str, URIorCURIE])

slots.Aktor_namn = Slot(uri=FOAF.name, name="Aktor_namn", curie=FOAF.curie('name'),
                   model_uri=DEFAULT_.Aktor_namn, domain=Aktor, range=str)