# This file was auto-generated by shacl2code 1.0.0. DO NOT MANUALLY MODIFY IT
#
# SPDX-License-Identifier: MIT
"""Generated stub for the generated Python bindings"""

from __future__ import annotations

from datetime import datetime
from enum import Enum
from typing import (
    Any,
    BinaryIO,
    Callable,
    Dict,
    Generic,
    Iterable,
    Iterator,
    List,
    Optional,
    Tuple,
    Type,
    TypeVar,
    Union,
    overload,
)

T_PropV = TypeVar("T_PropV")
T_SHACLObject = TypeVar("T_SHACLObject", bound="SHACLObject")


class NodeKind(Enum):
    BlankNode = 1
    IRI = 2
    BlankNodeOrIRI = 3


class ListProxy(Generic[T_PropV]): ...


class SHACLObject:
    NAMED_INDIVIDUALS: Dict[str, str]
    AUTO_NAMED_INDIVIDUALS: bool
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool
    IS_DEPRECATED: bool
    TYPE: str
    COMPACT_TYPE: Optional[str]

    def __init__(self, **kwargs: Any) -> None: ...
    def get_type(self) -> str: ...
    def get_compact_type(self) -> Optional[str]: ...
    def walk(
        self,
        callback: Callable[[Any, List[str]], bool],
        path: Optional[List[str]] = None,
    ) -> None: ...
    def property_keys(
        self,
    ) -> Iterator[Tuple[Optional[str], str, Optional[str]]]: ...
    def iter_objects(
        self,
        *,
        recursive: bool = False,
        visited: Optional[Any] = None,
    ) -> Iterable[SHACLObject]: ...
    def __iter__(self) -> Iterator[str]: ...
    def __getitem__(self, iri: str) -> Any: ...
    def __setitem__(self, iri: str, value: Any) -> None: ...
    def __delitem__(self, iri: str) -> None: ...


class SHACLExtensibleObject(SHACLObject):
    CLOSED: bool

    def __init__(self, typ: Optional[str] = None, **kwargs: Any) -> None: ...


class SHACLObjectSet:
    def __init__(self) -> None: ...
    def add(self, obj: SHACLObject) -> SHACLObject: ...
    def update(self, *others: Iterable[SHACLObject]) -> None: ...
    def find_by_id(
        self, _id: str, default: Optional[SHACLObject] = None
    ) -> Optional[SHACLObject]: ...
    def link(self) -> Any: ...
    def merge(self, *objectsets: SHACLObjectSet) -> SHACLObjectSet: ...
    def inline_blank_nodes(self) -> None: ...
    def foreach(self) -> Iterable[SHACLObject]: ...
    @overload
    def foreach_type(
        self,
        typ: Type[T_SHACLObject],
        *,
        match_subclass: bool = ...,
    ) -> Iterable[T_SHACLObject]: ...
    @overload
    def foreach_type(
        self,
        typ: str,
        *,
        match_subclass: bool = ...,
    ) -> Iterable[SHACLObject]: ...
    def __iter__(self) -> Iterator[SHACLObject]: ...
    def __contains__(self, item: SHACLObject) -> bool: ...
    @property
    def objects(self) -> Iterable[SHACLObject]: ...


class JSONLDDeserializer:
    def deserialize_data(self, data: Any, objectset: SHACLObjectSet) -> None: ...
    def read(self, f: BinaryIO, objectset: SHACLObjectSet) -> None: ...


class JSONLDSerializer:
    def __init__(self, **kwargs: Any) -> None: ...
    def serialize_data(
        self, objectset: SHACLObjectSet, force_at_graph: bool = False
    ) -> Any: ...
    def write(
        self,
        objectset: SHACLObjectSet,
        f: BinaryIO,
        force_at_graph: bool = False,
        **kwargs: Any,
    ) -> str: ...


class JSONLDInlineSerializer:
    def write(
        self,
        objectset: SHACLObjectSet,
        f: BinaryIO,
        force_at_graph: bool = False,
    ) -> str: ...


def encode_context(encoder: Any, objectset: SHACLObjectSet) -> None: ...
def decode_context(decoder: Any, objectset: SHACLObjectSet) -> None: ...


# fmt: off
"""Format Guard"""
# CLASSES
class ai_EnergyConsumption(SHACLObject):
    """
    A class for describing the energy consumption incurred by an AI model in
    different stages of its lifecycle.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/AI/EnergyConsumption"
    COMPACT_TYPE = "ai_EnergyConsumption"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        ai_finetuningEnergyConsumption: Optional[Iterable[Union[str, 'ai_EnergyConsumptionDescription']]] = None,
        ai_inferenceEnergyConsumption: Optional[Iterable[Union[str, 'ai_EnergyConsumptionDescription']]] = None,
        ai_trainingEnergyConsumption: Optional[Iterable[Union[str, 'ai_EnergyConsumptionDescription']]] = None,
        **kwargs: Any
    ) -> None: ...
    ai_finetuningEnergyConsumption: ListProxy[Union[str, 'ai_EnergyConsumptionDescription']]
    ai_inferenceEnergyConsumption: ListProxy[Union[str, 'ai_EnergyConsumptionDescription']]
    ai_trainingEnergyConsumption: ListProxy[Union[str, 'ai_EnergyConsumptionDescription']]


class ai_EnergyConsumptionDescription(SHACLObject):
    """
    The class that helps note down the quantity of energy consumption and the unit
    used for measurement.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/AI/EnergyConsumptionDescription"
    COMPACT_TYPE = "ai_EnergyConsumptionDescription"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        ai_energyQuantity: Optional[float] = None,
        ai_energyUnit: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    ai_energyQuantity: Optional[float]
    ai_energyUnit: Optional[str]


class ai_EnergyUnitType(SHACLObject):
    """
    Specifies the unit of energy consumption.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/AI/EnergyUnitType"
    COMPACT_TYPE = "ai_EnergyUnitType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # Kilowatt-hour.
    kilowattHour: str
    # Megajoule.
    megajoule: str
    # Any other units of energy measurement.
    other: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class ai_SafetyRiskAssessmentType(SHACLObject):
    """
    Specifies the safety risk level.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/AI/SafetyRiskAssessmentType"
    COMPACT_TYPE = "ai_SafetyRiskAssessmentType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # The second-highest level of risk posed by an AI system.
    high: str
    # Low/no risk is posed by an AI system.
    low: str
    # The third-highest level of risk posed by an AI system.
    medium: str
    # The highest level of risk posed by an AI system.
    serious: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class AnnotationType(SHACLObject):
    """
    Specifies the type of an annotation.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/AnnotationType"
    COMPACT_TYPE = "AnnotationType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # Used to store extra information about an Element which is not part of a review (e.g. extra information provided during the creation of the Element).
    other: str
    # Used when someone reviews the Element.
    review: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class CreationInfo(SHACLObject):
    """
    Provides information about the creation of the Element.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/CreationInfo"
    COMPACT_TYPE = "CreationInfo"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        comment: Optional[str] = None,
        created: Optional[datetime] = None,
        createdBy: Optional[Iterable[Union[str, 'Agent']]] = None,
        createdUsing: Optional[Iterable[Union[str, 'Tool']]] = None,
        specVersion: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    comment: Optional[str]
    created: Optional[datetime]
    createdBy: ListProxy[Union[str, 'Agent']]
    createdUsing: ListProxy[Union[str, 'Tool']]
    specVersion: Optional[str]


class DictionaryEntry(SHACLObject):
    """
    A key with an associated value.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/DictionaryEntry"
    COMPACT_TYPE = "DictionaryEntry"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        key: Optional[str] = None,
        value: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    key: Optional[str]
    value: Optional[str]


class Element(SHACLObject):
    """
    Base domain class from which all other SPDX-3.0 domain classes derive.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Element"
    COMPACT_TYPE = "Element"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool

    def __init__(
        self,
        *,
        comment: Optional[str] = None,
        creationInfo: Optional[Union[str, 'CreationInfo']] = None,
        description: Optional[str] = None,
        extension: Optional[Iterable[Union[str, 'extension_Extension']]] = None,
        externalIdentifier: Optional[Iterable[Union[str, 'ExternalIdentifier']]] = None,
        externalRef: Optional[Iterable[Union[str, 'ExternalRef']]] = None,
        name: Optional[str] = None,
        summary: Optional[str] = None,
        verifiedUsing: Optional[Iterable[Union[str, 'IntegrityMethod']]] = None,
        **kwargs: Any
    ) -> None: ...
    comment: Optional[str]
    creationInfo: Optional[Union[str, 'CreationInfo']]
    description: Optional[str]
    extension: ListProxy[Union[str, 'extension_Extension']]
    externalIdentifier: ListProxy[Union[str, 'ExternalIdentifier']]
    externalRef: ListProxy[Union[str, 'ExternalRef']]
    name: Optional[str]
    summary: Optional[str]
    verifiedUsing: ListProxy[Union[str, 'IntegrityMethod']]


class ElementCollection(Element):
    """
    A collection of Elements, not necessarily with unifying context.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/ElementCollection"
    COMPACT_TYPE = "ElementCollection"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool

    def __init__(
        self,
        *,
        element: Optional[Iterable[Union[str, 'Element']]] = None,
        profileConformance: Optional[Iterable[str]] = None,
        rootElement: Optional[Iterable[Union[str, 'Element']]] = None,
        **kwargs: Any
    ) -> None: ...
    element: ListProxy[Union[str, 'Element']]
    profileConformance: ListProxy[str]
    rootElement: ListProxy[Union[str, 'Element']]


class ExternalIdentifier(SHACLObject):
    """
    A reference to a resource identifier defined outside the scope of SPDX-3.0 content that uniquely identifies an Element.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/ExternalIdentifier"
    COMPACT_TYPE = "ExternalIdentifier"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        comment: Optional[str] = None,
        externalIdentifierType: Optional[str] = None,
        identifier: Optional[str] = None,
        identifierLocator: Optional[Iterable[str]] = None,
        issuingAuthority: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    comment: Optional[str]
    externalIdentifierType: Optional[str]
    identifier: Optional[str]
    identifierLocator: ListProxy[str]
    issuingAuthority: Optional[str]


class ExternalIdentifierType(SHACLObject):
    """
    Specifies the type of an external identifier.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/ExternalIdentifierType"
    COMPACT_TYPE = "ExternalIdentifierType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # [Common Platform Enumeration Specification 2.2](https://cpe.mitre.org/files/cpe-specification_2.2.pdf)
    cpe22: str
    # [Common Platform Enumeration: Naming Specification Version 2.3](https://csrc.nist.gov/publications/detail/nistir/7695/final)
    cpe23: str
    # Common Vulnerabilities and Exposures identifiers, an identifier for a specific software flaw defined within the official CVE Dictionary and that conforms to the [CVE specification](https://csrc.nist.gov/glossary/term/cve_id).
    cve: str
    # Email address, as defined in [RFC 3696](https://datatracker.ietf.org/doc/rfc3986/) Section 3.
    email: str
    # [Gitoid](https://www.iana.org/assignments/uri-schemes/prov/gitoid), stands for [Git Object ID](https://git-scm.com/book/en/v2/Git-Internals-Git-Objects). A gitoid of type blob is a unique hash of a binary artifact. A gitoid may represent either an [Artifact Identifier](https://github.com/omnibor/spec/blob/eb1ee5c961c16215eb8709b2975d193a2007a35d/spec/SPEC.md#artifact-identifier-types) for the software artifact or an [Input Manifest Identifier](https://github.com/omnibor/spec/blob/eb1ee5c961c16215eb8709b2975d193a2007a35d/spec/SPEC.md#input-manifest-identifier) for the software artifact's associated [Artifact Input Manifest](https://github.com/omnibor/spec/blob/eb1ee5c961c16215eb8709b2975d193a2007a35d/spec/SPEC.md#artifact-input-manifest); this ambiguity exists because the Artifact Input Manifest is itself an artifact, and the gitoid of that artifact is its valid identifier. Gitoids calculated on software artifacts (Snippet, File, or Package Elements) should be recorded in the SPDX 3.0 SoftwareArtifact's contentIdentifier property. Gitoids calculated on the Artifact Input Manifest (Input Manifest Identifier) should be recorded in the SPDX 3.0 Element's externalIdentifier property. See [OmniBOR Specification](https://github.com/omnibor/spec/), a minimalistic specification for describing software [Artifact Dependency Graphs](https://github.com/omnibor/spec/blob/eb1ee5c961c16215eb8709b2975d193a2007a35d/spec/SPEC.md#artifact-dependency-graph-adg).
    gitoid: str
    # Used when the type does not match any of the other options.
    other: str
    # Package URL, as defined in the corresponding [Annex](../../../annexes/pkg-url-specification.md) of this specification.
    packageUrl: str
    # Used when there is a security related identifier of unspecified type.
    securityOther: str
    # SoftWare Hash IDentifier, a persistent intrinsic identifier for digital artifacts, such as files, trees (also known as directories or folders), commits, and other objects typically found in version control systems. The format of the identifiers is defined in the [SWHID specification](https://www.swhid.org/specification/v1.1/4.Syntax) (ISO/IEC DIS 18670). They typically look like `swh:1:cnt:94a9ed024d3859793618152ea559a168bbcbb5e2`.
    swhid: str
    # Concise Software Identification (CoSWID) tag, as defined in [RFC 9393](https://datatracker.ietf.org/doc/rfc9393/) Section 2.3.
    swid: str
    # [Uniform Resource Identifier (URI) Schemes](https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml). The scheme used in order to locate a resource.
    urlScheme: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class ExternalMap(SHACLObject):
    """
    A map of Element identifiers that are used within an SpdxDocument but defined
    external to that SpdxDocument.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/ExternalMap"
    COMPACT_TYPE = "ExternalMap"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        definingArtifact: Optional[Union[str, 'Artifact']] = None,
        externalSpdxId: Optional[str] = None,
        locationHint: Optional[str] = None,
        verifiedUsing: Optional[Iterable[Union[str, 'IntegrityMethod']]] = None,
        **kwargs: Any
    ) -> None: ...
    definingArtifact: Optional[Union[str, 'Artifact']]
    externalSpdxId: Optional[str]
    locationHint: Optional[str]
    verifiedUsing: ListProxy[Union[str, 'IntegrityMethod']]


class ExternalRef(SHACLObject):
    """
    A reference to a resource outside the scope of SPDX-3.0 content related to an Element.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/ExternalRef"
    COMPACT_TYPE = "ExternalRef"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        comment: Optional[str] = None,
        contentType: Optional[str] = None,
        externalRefType: Optional[str] = None,
        locator: Optional[Iterable[str]] = None,
        **kwargs: Any
    ) -> None: ...
    comment: Optional[str]
    contentType: Optional[str]
    externalRefType: Optional[str]
    locator: ListProxy[str]


class ExternalRefType(SHACLObject):
    """
    Specifies the type of an external reference.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/ExternalRefType"
    COMPACT_TYPE = "ExternalRefType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # A reference to an alternative download location.
    altDownloadLocation: str
    # A reference to an alternative web page.
    altWebPage: str
    # A reference to binary artifacts related to a package.
    binaryArtifact: str
    # A reference to a Bower package. The package locator format, looks like `package#version`, is defined in the "install" section of [Bower API documentation](https://bower.io/docs/api/#install).
    bower: str
    # A reference build metadata related to a published package.
    buildMeta: str
    # A reference build system used to create or publish the package.
    buildSystem: str
    # A reference to a certification report for a package from an accredited/independent body.
    certificationReport: str
    # A reference to the instant messaging system used by the maintainer for a package.
    chat: str
    # A reference to a Software Composition Analysis (SCA) report.
    componentAnalysisReport: str
    # [Common Weakness Enumeration](https://csrc.nist.gov/glossary/term/common_weakness_enumeration). A reference to a source of software flaw defined within the official [CWE List](https://cwe.mitre.org/data/) that conforms to the [CWE specification](https://cwe.mitre.org/).
    cwe: str
    # A reference to the documentation for a package.
    documentation: str
    # A reference to a dynamic analysis report for a package.
    dynamicAnalysisReport: str
    # A reference to the End Of Sale (EOS) and/or End Of Life (EOL) information related to a package.
    eolNotice: str
    # A reference to a export control assessment for a package.
    exportControlAssessment: str
    # A reference to funding information related to a package.
    funding: str
    # A reference to the issue tracker for a package.
    issueTracker: str
    # A reference to additional license information related to an artifact.
    license: str
    # A reference to the mailing list used by the maintainer for a package.
    mailingList: str
    # A reference to a Maven repository artifact. The artifact locator format is defined in the [Maven documentation](https://maven.apache.org/guides/mini/guide-naming-conventions.html) and looks like `groupId:artifactId[:version]`.
    mavenCentral: str
    # A reference to metrics related to package such as OpenSSF scorecards.
    metrics: str
    # A reference to an npm package. The package locator format is defined in the [npm documentation](https://docs.npmjs.com/cli/v10/configuring-npm/package-json) and looks like `package@version`.
    npm: str
    # A reference to a NuGet package. The package locator format is defined in the [NuGet documentation](https://docs.nuget.org) and looks like `package/version`.
    nuget: str
    # Used when the type does not match any of the other options.
    other: str
    # A reference to a privacy assessment for a package.
    privacyAssessment: str
    # A reference to additional product metadata such as reference within organization's product catalog.
    productMetadata: str
    # A reference to a purchase order for a package.
    purchaseOrder: str
    # A reference to a quality assessment for a package.
    qualityAssessmentReport: str
    # A reference to a published list of releases for a package.
    releaseHistory: str
    # A reference to the release notes for a package.
    releaseNotes: str
    # A reference to a risk assessment for a package.
    riskAssessment: str
    # A reference to a runtime analysis report for a package.
    runtimeAnalysisReport: str
    # A reference to information assuring that the software is developed using security practices as defined by [NIST SP 800-218 Secure Software Development Framework (SSDF) Version 1.1](https://csrc.nist.gov/pubs/sp/800/218/final) or [CISA Secure Software Development Attestation Form](https://www.cisa.gov/resources-tools/resources/secure-software-development-attestation-form).
    secureSoftwareAttestation: str
    # A reference to the security adversary model for a package.
    securityAdversaryModel: str
    # A reference to a published security advisory (where advisory as defined per [ISO 29147:2018](https://www.iso.org/standard/72311.html)) that may affect one or more elements, e.g., vendor advisories or specific NVD entries.
    securityAdvisory: str
    # A reference to the patch or source code that fixes a vulnerability.
    securityFix: str
    # A reference to related security information of unspecified type.
    securityOther: str
    # A reference to a [penetration test](https://en.wikipedia.org/wiki/Penetration_test) report for a package.
    securityPenTestReport: str
    # A reference to instructions for reporting newly discovered security vulnerabilities for a package.
    securityPolicy: str
    # A reference the [security threat model](https://en.wikipedia.org/wiki/Threat_model) for a package.
    securityThreatModel: str
    # A reference to a social media channel for a package.
    socialMedia: str
    # A reference to an artifact containing the sources for a package.
    sourceArtifact: str
    # A reference to a static analysis report for a package.
    staticAnalysisReport: str
    # A reference to the software support channel or other support information for a package.
    support: str
    # A reference to a version control system related to a software artifact.
    vcs: str
    # A reference to a Vulnerability Disclosure Report (VDR) which provides the software supplier's analysis and findings describing the impact (or lack of impact) that reported vulnerabilities have on packages or products in the supplier's SBOM as defined in [NIST SP 800-161 Cybersecurity Supply Chain Risk Management Practices for Systems and Organizations](https://csrc.nist.gov/pubs/sp/800/161/r1/final).
    vulnerabilityDisclosureReport: str
    # A reference to a Vulnerability Exploitability eXchange (VEX) statement which provides information on whether a product is impacted by a specific vulnerability in an included package and, if affected, whether there are actions recommended to remediate. See also [NTIA VEX one-page summary](https://ntia.gov/files/ntia/publications/vex_one-page_summary.pdf).
    vulnerabilityExploitabilityAssessment: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class HashAlgorithm(SHACLObject):
    """
    A mathematical algorithm that maps data of arbitrary size to a bit string.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/HashAlgorithm"
    COMPACT_TYPE = "HashAlgorithm"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # Adler-32 checksum is part of the widely used zlib compression library as defined in [RFC 1950](https://datatracker.ietf.org/doc/rfc1950/) Section 2.3.
    adler32: str
    # BLAKE2b algorithm with a digest size of 256, as defined in [RFC 7693](https://datatracker.ietf.org/doc/rfc7693/) Section 4.
    blake2b256: str
    # BLAKE2b algorithm with a digest size of 384, as defined in [RFC 7693](https://datatracker.ietf.org/doc/rfc7693/) Section 4.
    blake2b384: str
    # BLAKE2b algorithm with a digest size of 512, as defined in [RFC 7693](https://datatracker.ietf.org/doc/rfc7693/) Section 4.
    blake2b512: str
    # [BLAKE3](https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/blake3.pdf)
    blake3: str
    # [Dilithium](https://pq-crystals.org/dilithium/)
    crystalsDilithium: str
    # [Kyber](https://pq-crystals.org/kyber/)
    crystalsKyber: str
    # [FALCON](https://falcon-sign.info/falcon.pdf)
    falcon: str
    # MD2 message-digest algorithm, as defined in [RFC 1319](https://datatracker.ietf.org/doc/rfc1319/).
    md2: str
    # MD4 message-digest algorithm, as defined in [RFC 1186](https://datatracker.ietf.org/doc/rfc1186/).
    md4: str
    # MD5 message-digest algorithm, as defined in [RFC 1321](https://datatracker.ietf.org/doc/rfc1321/).
    md5: str
    # [MD6 hash function](https://people.csail.mit.edu/rivest/pubs/RABCx08.pdf)
    md6: str
    # any hashing algorithm that does not exist in this list of entries
    other: str
    # SHA-1, a secure hashing algorithm, as defined in [RFC 3174](https://datatracker.ietf.org/doc/rfc3174/).
    sha1: str
    # SHA-2 with a digest length of 224, as defined in [RFC 3874](https://datatracker.ietf.org/doc/rfc3874/).
    sha224: str
    # SHA-2 with a digest length of 256, as defined in [RFC 6234](https://datatracker.ietf.org/doc/rfc6234/).
    sha256: str
    # SHA-2 with a digest length of 384, as defined in [RFC 6234](https://datatracker.ietf.org/doc/rfc6234/).
    sha384: str
    # SHA-3 with a digest length of 224, as defined in [FIPS 202](https://csrc.nist.gov/pubs/fips/202/final).
    sha3_224: str
    # SHA-3 with a digest length of 256, as defined in [FIPS 202](https://csrc.nist.gov/pubs/fips/202/final).
    sha3_256: str
    # SHA-3 with a digest length of 384, as defined in [FIPS 202](https://csrc.nist.gov/pubs/fips/202/final).
    sha3_384: str
    # SHA-3 with a digest length of 512, as defined in [FIPS 202](https://csrc.nist.gov/pubs/fips/202/final).
    sha3_512: str
    # SHA-2 with a digest length of 512, as defined in [RFC 6234](https://datatracker.ietf.org/doc/rfc6234/).
    sha512: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class IndividualElement(Element):
    """
    A concrete subclass of Element used by Individuals in the
    Core profile.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/IndividualElement"
    COMPACT_TYPE = "IndividualElement"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    NAMED_INDIVIDUALS: Dict[str, str]
    # An Individual Value for Element representing a set of Elements of unknown
    # identify or cardinality (number).
    NoAssertionElement: str
    # An Individual Value for Element representing a set of Elements with
    # cardinality (number/count) of zero.
    NoneElement: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class IntegrityMethod(SHACLObject):
    """
    Provides an independently reproducible mechanism that permits verification of a specific Element.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/IntegrityMethod"
    COMPACT_TYPE = "IntegrityMethod"
    NODE_KIND: NodeKind
    IS_ABSTRACT: bool

    def __init__(
        self,
        *,
        comment: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    comment: Optional[str]


class LifecycleScopeType(SHACLObject):
    """
    Provide an enumerated set of lifecycle phases that can provide context to relationships.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/LifecycleScopeType"
    COMPACT_TYPE = "LifecycleScopeType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # A relationship has specific context implications during an element's build phase, during development.
    build: str
    # A relationship has specific context implications during an element's design.
    design: str
    # A relationship has specific context implications during development phase of an element.
    development: str
    # A relationship has other specific context information necessary to capture that the above set of enumerations does not handle.
    other: str
    # A relationship has specific context implications during the execution phase of an element.
    runtime: str
    # A relationship has specific context implications during an element's testing phase, during development.
    test: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class NamespaceMap(SHACLObject):
    """
    A mapping between prefixes and namespace partial URIs.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/NamespaceMap"
    COMPACT_TYPE = "NamespaceMap"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        namespace: Optional[str] = None,
        prefix: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    namespace: Optional[str]
    prefix: Optional[str]


class PackageVerificationCode(IntegrityMethod):
    """
    An SPDX version 2.X compatible verification method for software packages.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/PackageVerificationCode"
    COMPACT_TYPE = "PackageVerificationCode"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        algorithm: Optional[str] = None,
        hashValue: Optional[str] = None,
        packageVerificationCodeExcludedFile: Optional[Iterable[str]] = None,
        **kwargs: Any
    ) -> None: ...
    algorithm: Optional[str]
    hashValue: Optional[str]
    packageVerificationCodeExcludedFile: ListProxy[str]


class PositiveIntegerRange(SHACLObject):
    """
    A tuple of two positive integers that define a range.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/PositiveIntegerRange"
    COMPACT_TYPE = "PositiveIntegerRange"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        beginIntegerRange: Optional[int] = None,
        endIntegerRange: Optional[int] = None,
        **kwargs: Any
    ) -> None: ...
    beginIntegerRange: Optional[int]
    endIntegerRange: Optional[int]


class PresenceType(SHACLObject):
    """
    Categories of presence or absence.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/PresenceType"
    COMPACT_TYPE = "PresenceType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # Indicates absence of the field.
    no: str
    # Makes no assertion about the field.
    noAssertion: str
    # Indicates presence of the field.
    yes: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class ProfileIdentifierType(SHACLObject):
    """
    Enumeration of the valid profiles.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/ProfileIdentifierType"
    COMPACT_TYPE = "ProfileIdentifierType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # the element follows the AI profile specification
    ai: str
    # the element follows the Build profile specification
    build: str
    # the element follows the Core profile specification
    core: str
    # the element follows the Dataset profile specification
    dataset: str
    # the element follows the ExpandedLicensing profile specification
    expandedLicensing: str
    # the element follows the Extension profile specification
    extension: str
    # the element follows the Lite profile specification
    lite: str
    # the element follows the Security profile specification
    security: str
    # the element follows the SimpleLicensing profile specification
    simpleLicensing: str
    # the element follows the Software profile specification
    software: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class Relationship(Element):
    """
    Describes a relationship between one or more elements.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Relationship"
    COMPACT_TYPE = "Relationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        completeness: Optional[str] = None,
        endTime: Optional[datetime] = None,
        from_: Optional[Union[str, 'Element']] = None,
        relationshipType: Optional[str] = None,
        startTime: Optional[datetime] = None,
        to: Optional[Iterable[Union[str, 'Element']]] = None,
        **kwargs: Any
    ) -> None: ...
    completeness: Optional[str]
    endTime: Optional[datetime]
    from_: Optional[Union[str, 'Element']]
    relationshipType: Optional[str]
    startTime: Optional[datetime]
    to: ListProxy[Union[str, 'Element']]


class RelationshipCompleteness(SHACLObject):
    """
    Indicates whether a relationship is known to be complete, incomplete, or if no assertion is made with respect to relationship completeness.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/RelationshipCompleteness"
    COMPACT_TYPE = "RelationshipCompleteness"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # The relationship is known to be exhaustive.
    complete: str
    # The relationship is known not to be exhaustive.
    incomplete: str
    # No assertion can be made about the completeness of the relationship.
    noAssertion: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class RelationshipType(SHACLObject):
    """
    Information about the relationship between two Elements.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/RelationshipType"
    COMPACT_TYPE = "RelationshipType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # The `from` Vulnerability affects each `to` Element. The use of the `affects` type is constrained to `VexAffectedVulnAssessmentRelationship` classed relationships.
    affects: str
    # The `from` Element is amended by each `to` Element.
    amendedBy: str
    # The `from` Element is an ancestor of each `to` Element.
    ancestorOf: str
    # The `from` Element is available from the additional supplier described by each `to` Element.
    availableFrom: str
    # The `from` Element is a configuration applied to each `to` Element, during a LifecycleScopeType period.
    configures: str
    # The `from` Element contains each `to` Element.
    contains: str
    # The `from` Vulnerability is coordinatedBy the `to` Agent(s) (vendor, researcher, or consumer agent).
    coordinatedBy: str
    # The `from` Element has been copied to each `to` Element.
    copiedTo: str
    # The `from` Agent is delegating an action to the Agent of the `to` Relationship (which must be of type invokedBy), during a LifecycleScopeType (e.g. the `to` invokedBy Relationship is being done on behalf of `from`).
    delegatedTo: str
    # The `from` Element depends on each `to` Element, during a LifecycleScopeType period.
    dependsOn: str
    # The `from` Element is a descendant of each `to` Element.
    descendantOf: str
    # The `from` Element describes each `to` Element. To denote the root(s) of a tree of elements in a collection, the rootElement property should be used.
    describes: str
    # The `from` Vulnerability has no impact on each `to` Element. The use of the `doesNotAffect` is constrained to `VexNotAffectedVulnAssessmentRelationship` classed relationships.
    doesNotAffect: str
    # The `from` archive expands out as an artifact described by each `to` Element.
    expandsTo: str
    # The `from` Vulnerability has had an exploit created against it by each `to` Agent.
    exploitCreatedBy: str
    # Designates a `from` Vulnerability has been fixed by the `to` Agent(s).
    fixedBy: str
    # A `from` Vulnerability has been fixed in each `to` Element. The use of the `fixedIn` type is constrained to `VexFixedVulnAssessmentRelationship` classed relationships.
    fixedIn: str
    # Designates a `from` Vulnerability was originally discovered by the `to` Agent(s).
    foundBy: str
    # The `from` Element generates each `to` Element.
    generates: str
    # Every `to` Element is a file added to the `from` Element (`from` hasAddedFile `to`).
    hasAddedFile: str
    # Relates a `from` Vulnerability and each `to` Element with a security assessment. To be used with `VulnAssessmentRelationship` types.
    hasAssessmentFor: str
    # Used to associate a `from` Artifact with each `to` Vulnerability.
    hasAssociatedVulnerability: str
    # The `from` SoftwareArtifact is concluded by the SPDX data creator to be governed by each `to` license.
    hasConcludedLicense: str
    # The `from` Element treats each `to` Element as a data file. A data file is an artifact that stores data required or optional for the `from` Element's functionality. A data file can be a database file, an index file, a log file, an AI model file, a calibration data file, a temporary file, a backup file, and more. For AI training dataset, test dataset, test artifact, configuration data, build input data, and build output data, please consider using the more specific relationship types: `trainedOn`, `testedOn`, `hasTest`, `configures`, `hasInput`, and `hasOutput`, respectively. This relationship does not imply dependency.
    hasDataFile: str
    # The `from` SoftwareArtifact was discovered to actually contain each `to` license, for example as detected by use of automated tooling.
    hasDeclaredLicense: str
    # Every `to` Element is a file deleted from the `from` Element (`from` hasDeletedFile `to`).
    hasDeletedFile: str
    # The `from` Element has manifest files that contain dependency information in each `to` Element.
    hasDependencyManifest: str
    # The `from` Element is distributed as an artifact in each `to` Element (e.g. an RPM or archive file).
    hasDistributionArtifact: str
    # The `from` Element is documented by each `to` Element.
    hasDocumentation: str
    # The `from` Element dynamically links in each `to` Element, during a LifecycleScopeType period.
    hasDynamicLink: str
    # Every `to` Element is considered as evidence for the `from` Element (`from` hasEvidence `to`).
    hasEvidence: str
    # Every `to` Element is an example for the `from` Element (`from` hasExample `to`).
    hasExample: str
    # The `from` Build was run on the `to` Element during a LifecycleScopeType period (e.g. the host that the build runs on).
    hasHost: str
    # The `from` Build has each `to` Element as an input, during a LifecycleScopeType period.
    hasInput: str
    # Every `to` Element is metadata about the `from` Element (`from` hasMetadata `to`).
    hasMetadata: str
    # Every `to` Element is an optional component of the `from` Element (`from` hasOptionalComponent `to`).
    hasOptionalComponent: str
    # The `from` Element optionally depends on each `to` Element, during a LifecycleScopeType period.
    hasOptionalDependency: str
    # The `from` Build element generates each `to` Element as an output, during a LifecycleScopeType period.
    hasOutput: str
    # The `from` Element has a prerequisite on each `to` Element, during a LifecycleScopeType period.
    hasPrerequisite: str
    # The `from` Element has a dependency on each `to` Element, dependency is not in the distributed artifact, but assumed to be provided, during a LifecycleScopeType period.
    hasProvidedDependency: str
    # The `from` Element has a requirement on each `to` Element, during a LifecycleScopeType period.
    hasRequirement: str
    # Every `to` Element is a specification for the `from` Element (`from` hasSpecification `to`), during a LifecycleScopeType period.
    hasSpecification: str
    # The `from` Element statically links in each `to` Element, during a LifecycleScopeType period.
    hasStaticLink: str
    # Every `to` Element is a test artifact for the `from` Element (`from` hasTest `to`), during a LifecycleScopeType period.
    hasTest: str
    # Every `to` Element is a test case for the `from` Element (`from` hasTestCase `to`).
    hasTestCase: str
    # Every `to` Element is a variant the `from` Element (`from` hasVariant `to`).
    hasVariant: str
    # The `from` Element was invoked by the `to` Agent, during a LifecycleScopeType period (for example, a Build element that describes a build step).
    invokedBy: str
    # The `from` Element is modified by each `to` Element.
    modifiedBy: str
    # Every `to` Element is related to the `from` Element where the relationship type is not described by any of the SPDX relationship types (this relationship is directionless).
    other: str
    # Every `to` Element is a packaged instance of the `from` Element (`from` packagedBy `to`).
    packagedBy: str
    # Every `to` Element is a patch for the `from` Element (`from` patchedBy `to`).
    patchedBy: str
    # Designates a `from` Vulnerability was made available for public use or reference by each `to` Agent.
    publishedBy: str
    # Designates a `from` Vulnerability was first reported to a project, vendor, or tracking database for formal identification by each `to` Agent.
    reportedBy: str
    # Designates a `from` Vulnerability's details were tracked, aggregated, and/or enriched to improve context (i.e. NVD) by each `to` Agent.
    republishedBy: str
    # The `from` SpdxDocument can be found in a serialized form in each `to` Artifact.
    serializedInArtifact: str
    # The `from` Element has been tested on the `to` Element(s).
    testedOn: str
    # The `from` Element has been trained on the `to` Element(s).
    trainedOn: str
    # The `from` Vulnerability impact is being investigated for each `to` Element. The use of the `underInvestigationFor` type is constrained to `VexUnderInvestigationVulnAssessmentRelationship` classed relationships.
    underInvestigationFor: str
    # The `from` Element uses each `to` Element as a tool, during a LifecycleScopeType period.
    usesTool: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class SpdxDocument(ElementCollection):
    """
    A collection of SPDX Elements that could potentially be serialized.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/SpdxDocument"
    COMPACT_TYPE = "SpdxDocument"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        dataLicense: Optional[Union[str, 'simplelicensing_AnyLicenseInfo']] = None,
        import_: Optional[Iterable[Union[str, 'ExternalMap']]] = None,
        namespaceMap: Optional[Iterable[Union[str, 'NamespaceMap']]] = None,
        **kwargs: Any
    ) -> None: ...
    dataLicense: Optional[Union[str, 'simplelicensing_AnyLicenseInfo']]
    import_: ListProxy[Union[str, 'ExternalMap']]
    namespaceMap: ListProxy[Union[str, 'NamespaceMap']]


class SupportType(SHACLObject):
    """
    Indicates the type of support that is associated with an artifact.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/SupportType"
    COMPACT_TYPE = "SupportType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # in addition to being supported by the supplier, the software is known to have been deployed and is in use.  For a software as a service provider, this implies the software is now available as a service.
    deployed: str
    # the artifact is in active development and is not considered ready for formal support from the supplier.
    development: str
    # there is a defined end of support for the artifact from the supplier.  This may also be referred to as end of life. There is a validUntilDate that can be used to signal when support ends for the artifact.
    endOfSupport: str
    # the artifact has been released, and there is limited support available from the supplier. There is a validUntilDate that can provide additional information about the duration of support.
    limitedSupport: str
    # no assertion about the type of support is made.   This is considered the default if no other support type is used.
    noAssertion: str
    # there is no support for the artifact from the supplier, consumer assumes any support obligations.
    noSupport: str
    # the artifact has been released, and is supported from the supplier.   There is a validUntilDate that can provide additional information about the duration of support.
    support: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class Tool(Element):
    """
    An element of hardware and/or software utilized to carry out a particular function.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Tool"
    COMPACT_TYPE = "Tool"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class dataset_ConfidentialityLevelType(SHACLObject):
    """
    Categories of confidentiality level.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Dataset/ConfidentialityLevelType"
    COMPACT_TYPE = "dataset_ConfidentialityLevelType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # Data points in the dataset can be shared only with specific organizations and their clients on a need to know basis.
    amber: str
    # Dataset may be distributed freely, without restriction.
    clear: str
    # Dataset can be shared within a community of peers and partners.
    green: str
    # Data points in the dataset are highly confidential and can only be shared with named recipients.
    red: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class dataset_DatasetAvailabilityType(SHACLObject):
    """
    Availability of dataset.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Dataset/DatasetAvailabilityType"
    COMPACT_TYPE = "dataset_DatasetAvailabilityType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # the dataset is not publicly available and can only be accessed after affirmatively accepting terms on a clickthrough webpage.
    clickthrough: str
    # the dataset is publicly available and can be downloaded directly.
    directDownload: str
    # the dataset is publicly available, but not all at once, and can only be accessed through queries which return parts of the dataset.
    query: str
    # the dataset is not publicly available and an email registration is required before accessing the dataset, although without an affirmative acceptance of terms.
    registration: str
    # the dataset provider is not making available the underlying data and the dataset must be reassembled, typically using the provided script for scraping the data.
    scrapingScript: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class dataset_DatasetType(SHACLObject):
    """
    Enumeration of dataset types.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Dataset/DatasetType"
    COMPACT_TYPE = "dataset_DatasetType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # data is audio based, such as a collection of music from the 80s.
    audio: str
    # data that is classified into a discrete number of categories, such as the eye color of a population of people.
    categorical: str
    # data is in the form of a graph where entries are somehow related to each other through edges, such a social network of friends.
    graph: str
    # data is a collection of images such as pictures of animals.
    image: str
    # data type is not known.
    noAssertion: str
    # data consists only of numeric entries.
    numeric: str
    # data is of a type not included in this list.
    other: str
    # data is recorded from a physical sensor, such as a thermometer reading or biometric device.
    sensor: str
    # data is stored in tabular format or retrieved from a relational database.
    structured: str
    # data describes the syntax or semantics of a language or text, such as a parse tree used for natural language processing.
    syntactic: str
    # data consists of unstructured text, such as a book, Wikipedia article (without images), or transcript.
    text: str
    # data is recorded in an ordered sequence of timestamped entries, such as the price of a stock over the course of a day.
    timeseries: str
    # data is recorded with a timestamp for each entry, but not necessarily ordered or at specific intervals, such as when a taxi ride starts and ends.
    timestamp: str
    # data is video based, such as a collection of movie clips featuring Tom Hanks.
    video: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class expandedlicensing_LicenseAddition(Element):
    """
    Abstract class for additional text intended to be added to a License, but
    which is not itself a standalone License.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/LicenseAddition"
    COMPACT_TYPE = "expandedlicensing_LicenseAddition"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool

    def __init__(
        self,
        *,
        expandedlicensing_additionText: Optional[str] = None,
        expandedlicensing_isDeprecatedAdditionId: Optional[bool] = None,
        expandedlicensing_licenseXml: Optional[str] = None,
        expandedlicensing_obsoletedBy: Optional[str] = None,
        expandedlicensing_seeAlso: Optional[Iterable[str]] = None,
        expandedlicensing_standardAdditionTemplate: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    expandedlicensing_additionText: Optional[str]
    expandedlicensing_isDeprecatedAdditionId: Optional[bool]
    expandedlicensing_licenseXml: Optional[str]
    expandedlicensing_obsoletedBy: Optional[str]
    expandedlicensing_seeAlso: ListProxy[str]
    expandedlicensing_standardAdditionTemplate: Optional[str]


class expandedlicensing_ListedLicenseException(expandedlicensing_LicenseAddition):
    """
    A license exception that is listed on the SPDX Exceptions list.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/ListedLicenseException"
    COMPACT_TYPE = "expandedlicensing_ListedLicenseException"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        expandedlicensing_deprecatedVersion: Optional[str] = None,
        expandedlicensing_listVersionAdded: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    expandedlicensing_deprecatedVersion: Optional[str]
    expandedlicensing_listVersionAdded: Optional[str]


class extension_CdxPropertyEntry(SHACLObject):
    """
    A property name with an associated value.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Extension/CdxPropertyEntry"
    COMPACT_TYPE = "extension_CdxPropertyEntry"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        extension_cdxPropName: Optional[str] = None,
        extension_cdxPropValue: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    extension_cdxPropName: Optional[str]
    extension_cdxPropValue: Optional[str]


class extension_Extension(SHACLExtensibleObject):
    """
    A characterization of some aspect of an Element that is associated with the Element in a generalized fashion.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Extension/Extension"
    COMPACT_TYPE = "extension_Extension"
    NODE_KIND: NodeKind
    IS_ABSTRACT: bool

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class security_CvssSeverityType(SHACLObject):
    """
    Specifies the CVSS base, temporal, threat, or environmental severity type.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/CvssSeverityType"
    COMPACT_TYPE = "security_CvssSeverityType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # When a CVSS score is between 9.0 - 10.0
    critical: str
    # When a CVSS score is between 7.0 - 8.9
    high: str
    # When a CVSS score is between 0.1 - 3.9
    low: str
    # When a CVSS score is between 4.0 - 6.9
    medium: str
    # When a CVSS score is 0.0
    none: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class security_ExploitCatalogType(SHACLObject):
    """
    Specifies the exploit catalog type.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/ExploitCatalogType"
    COMPACT_TYPE = "security_ExploitCatalogType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # CISA's Known Exploited Vulnerability (KEV) Catalog
    kev: str
    # Other exploit catalogs
    other: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class security_SsvcDecisionType(SHACLObject):
    """
    Specifies the SSVC decision type.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/SsvcDecisionType"
    COMPACT_TYPE = "security_SsvcDecisionType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # The vulnerability requires attention from the organization's internal, supervisory-level and leadership-level individuals. Necessary actions include requesting assistance or information about the vulnerability, as well as publishing a notification either internally and/or externally. Typically, internal groups would meet to determine the overall response and then execute agreed upon actions. CISA recommends remediating Act vulnerabilities as soon as possible.
    act: str
    # The vulnerability requires attention from the organization's internal, supervisory-level individuals. Necessary actions include requesting assistance or information about the vulnerability, and may involve publishing a notification either internally and/or externally. CISA recommends remediating Attend vulnerabilities sooner than standard update timelines.
    attend: str
    # The vulnerability does not require action at this time. The organization would continue to track the vulnerability and reassess it if new information becomes available. CISA recommends remediating Track vulnerabilities within standard update timelines.
    track: str
    # ("Track\*" in the SSVC spec) The vulnerability contains specific characteristics that may require closer monitoring for changes. CISA recommends remediating Track\* vulnerabilities within standard update timelines.
    trackStar: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class security_VexJustificationType(SHACLObject):
    """
    Specifies the VEX justification type.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/VexJustificationType"
    COMPACT_TYPE = "security_VexJustificationType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # The software is not affected because the vulnerable component is not in the product.
    componentNotPresent: str
    # Built-in inline controls or mitigations prevent an adversary from leveraging the vulnerability.
    inlineMitigationsAlreadyExist: str
    # The vulnerable component is present, and the component contains the vulnerable code. However, vulnerable code is used in such a way that an attacker cannot mount any anticipated attack.
    vulnerableCodeCannotBeControlledByAdversary: str
    # The affected code is not reachable through the execution of the code, including non-anticipated states of the product.
    vulnerableCodeNotInExecutePath: str
    # The product is not affected because the code underlying the vulnerability is not present in the product.
    vulnerableCodeNotPresent: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class security_VulnAssessmentRelationship(Relationship):
    """
    Abstract ancestor class for all vulnerability assessments
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/VulnAssessmentRelationship"
    COMPACT_TYPE = "security_VulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool

    def __init__(
        self,
        *,
        suppliedBy: Optional[Union[str, 'Agent']] = None,
        security_assessedElement: Optional[Union[str, 'software_SoftwareArtifact']] = None,
        security_modifiedTime: Optional[datetime] = None,
        security_publishedTime: Optional[datetime] = None,
        security_withdrawnTime: Optional[datetime] = None,
        **kwargs: Any
    ) -> None: ...
    suppliedBy: Optional[Union[str, 'Agent']]
    security_assessedElement: Optional[Union[str, 'software_SoftwareArtifact']]
    security_modifiedTime: Optional[datetime]
    security_publishedTime: Optional[datetime]
    security_withdrawnTime: Optional[datetime]


class simplelicensing_AnyLicenseInfo(Element):
    """
    Abstract class representing a license combination consisting of one or more licenses.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/SimpleLicensing/AnyLicenseInfo"
    COMPACT_TYPE = "simplelicensing_AnyLicenseInfo"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class simplelicensing_LicenseExpression(simplelicensing_AnyLicenseInfo):
    """
    An SPDX Element containing an SPDX license expression string.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/SimpleLicensing/LicenseExpression"
    COMPACT_TYPE = "simplelicensing_LicenseExpression"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        simplelicensing_customIdToUri: Optional[Iterable[Union[str, 'DictionaryEntry']]] = None,
        simplelicensing_licenseExpression: Optional[str] = None,
        simplelicensing_licenseListVersion: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    simplelicensing_customIdToUri: ListProxy[Union[str, 'DictionaryEntry']]
    simplelicensing_licenseExpression: Optional[str]
    simplelicensing_licenseListVersion: Optional[str]


class simplelicensing_SimpleLicensingText(Element):
    """
    A license or addition that is not listed on the SPDX License List.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/SimpleLicensing/SimpleLicensingText"
    COMPACT_TYPE = "simplelicensing_SimpleLicensingText"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        simplelicensing_licenseText: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    simplelicensing_licenseText: Optional[str]


class software_ContentIdentifier(IntegrityMethod):
    """
    A canonical, unique, immutable identifier
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Software/ContentIdentifier"
    COMPACT_TYPE = "software_ContentIdentifier"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        software_contentIdentifierType: Optional[str] = None,
        software_contentIdentifierValue: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    software_contentIdentifierType: Optional[str]
    software_contentIdentifierValue: Optional[str]


class software_ContentIdentifierType(SHACLObject):
    """
    Specifies the type of a content identifier.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Software/ContentIdentifierType"
    COMPACT_TYPE = "software_ContentIdentifierType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # [Gitoid](https://www.iana.org/assignments/uri-schemes/prov/gitoid), stands for [Git Object ID](https://git-scm.com/book/en/v2/Git-Internals-Git-Objects). A gitoid of type blob is a unique hash of a binary artifact. A gitoid may represent either an [Artifact Identifier](https://github.com/omnibor/spec/blob/eb1ee5c961c16215eb8709b2975d193a2007a35d/spec/SPEC.md#artifact-identifier-types) for the software artifact or an [Input Manifest Identifier](https://github.com/omnibor/spec/blob/eb1ee5c961c16215eb8709b2975d193a2007a35d/spec/SPEC.md#input-manifest-identifier) for the software artifact's associated [Artifact Input Manifest](https://github.com/omnibor/spec/blob/eb1ee5c961c16215eb8709b2975d193a2007a35d/spec/SPEC.md#artifact-input-manifest); this ambiguity exists because the Artifact Input Manifest is itself an artifact, and the gitoid of that artifact is its valid identifier. Gitoids calculated on software artifacts (Snippet, File, or Package Elements) should be recorded in the SPDX 3.0 SoftwareArtifact's contentIdentifier property. Gitoids calculated on the Artifact Input Manifest (Input Manifest Identifier) should be recorded in the SPDX 3.0 Element's externalIdentifier property. See [OmniBOR Specification](https://github.com/omnibor/spec/), a minimalistic specification for describing software [Artifact Dependency Graphs](https://github.com/omnibor/spec/blob/eb1ee5c961c16215eb8709b2975d193a2007a35d/spec/SPEC.md#artifact-dependency-graph-adg).
    gitoid: str
    # SoftWare Hash IDentifier, a persistent intrinsic identifier for digital artifacts, such as files, trees (also known as directories or folders), commits, and other objects typically found in version control systems. The format of the identifiers is defined in the [SWHID specification](https://www.swhid.org/specification/v1.1/4.Syntax) (ISO/IEC DIS 18670). They typically look like `swh:1:cnt:94a9ed024d3859793618152ea559a168bbcbb5e2`.
    swhid: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class software_FileKindType(SHACLObject):
    """
    Enumeration of the different kinds of SPDX file.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Software/FileKindType"
    COMPACT_TYPE = "software_FileKindType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # The file represents a directory and all content stored in that directory.
    directory: str
    # The file represents a single file (default).
    file: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class software_SbomType(SHACLObject):
    """
    Provides a set of values to be used to describe the common types of SBOMs that
    tools may create.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Software/SbomType"
    COMPACT_TYPE = "software_SbomType"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # SBOM generated through analysis of artifacts (e.g., executables, packages, containers, and virtual machine images) after its build. Such analysis generally requires a variety of heuristics. In some contexts, this may also be referred to as a "3rd party" SBOM.
    analyzed: str
    # SBOM generated as part of the process of building the software to create a releasable artifact (e.g., executable or package) from data such as source files, dependencies, built components, build process ephemeral data, and other SBOMs.
    build: str
    # SBOM provides an inventory of software that is present on a system. This may be an assembly of other SBOMs that combines analysis of configuration options, and examination of execution behavior in a (potentially simulated) deployment environment.
    deployed: str
    # SBOM of intended, planned software project or product with included components (some of which may not yet exist) for a new software artifact.
    design: str
    # SBOM generated through instrumenting the system running the software, to capture only components present in the system, as well as external call-outs or dynamically loaded components. In some contexts, this may also be referred to as an "Instrumented" or "Dynamic" SBOM.
    runtime: str
    # SBOM created directly from the development environment, source files, and included dependencies used to build an product artifact.
    source: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class software_SoftwarePurpose(SHACLObject):
    """
    Provides information about the primary purpose of an Element.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Software/SoftwarePurpose"
    COMPACT_TYPE = "software_SoftwarePurpose"
    NODE_KIND: NodeKind
    NAMED_INDIVIDUALS: Dict[str, str]
    # The Element is a software application.
    application: str
    # The Element is an archived collection of one or more files (.tar, .zip, etc.).
    archive: str
    # The Element is a bill of materials.
    bom: str
    # The Element is configuration data.
    configuration: str
    # The Element is a container image which can be used by a container runtime application.
    container: str
    # The Element is data.
    data: str
    # The Element refers to a chipset, processor, or electronic board.
    device: str
    # The Element represents software that controls hardware devices.
    deviceDriver: str
    # The Element refers to a disk image that can be written to a disk, booted in a VM, etc. A disk image typically contains most or all of the components necessary to boot, such as bootloaders, kernels, firmware, userspace, etc.
    diskImage: str
    # The Element is documentation.
    documentation: str
    # The Element is the evidence that a specification or requirement has been fulfilled.
    evidence: str
    # The Element is an Artifact that can be run on a computer.
    executable: str
    # The Element is a single file which can be independently distributed (configuration file, statically linked binary, Kubernetes deployment, etc.).
    file: str
    # The Element is a file system image that can be written to a disk (or virtual) partition.
    filesystemImage: str
    # The Element provides low level control over a device's hardware.
    firmware: str
    # The Element is a software framework.
    framework: str
    # The Element is used to install software on disk.
    install: str
    # The Element is a software library.
    library: str
    # The Element is a software manifest.
    manifest: str
    # The Element is a machine learning or artificial intelligence model.
    model: str
    # The Element is a module of a piece of software.
    module: str
    # The Element is an operating system.
    operatingSystem: str
    # The Element doesn't fit into any of the other categories.
    other: str
    # The Element contains a set of changes to update, fix, or improve another Element.
    patch: str
    # The Element represents a runtime environment.
    platform: str
    # The Element provides a requirement needed as input for another Element.
    requirement: str
    # The Element is a single or a collection of source files.
    source: str
    # The Element is a plan, guideline or strategy how to create, perform or analyze an application.
    specification: str
    # The Element is a test used to verify functionality on an software element.
    test: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class build_Build(Element):
    """
    Class that describes a build instance of software/artifacts.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Build/Build"
    COMPACT_TYPE = "build_Build"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        build_buildEndTime: Optional[datetime] = None,
        build_buildId: Optional[str] = None,
        build_buildStartTime: Optional[datetime] = None,
        build_buildType: Optional[str] = None,
        build_configSourceDigest: Optional[Iterable[Union[str, 'Hash']]] = None,
        build_configSourceEntrypoint: Optional[Iterable[str]] = None,
        build_configSourceUri: Optional[Iterable[str]] = None,
        build_environment: Optional[Iterable[Union[str, 'DictionaryEntry']]] = None,
        build_parameter: Optional[Iterable[Union[str, 'DictionaryEntry']]] = None,
        **kwargs: Any
    ) -> None: ...
    build_buildEndTime: Optional[datetime]
    build_buildId: Optional[str]
    build_buildStartTime: Optional[datetime]
    build_buildType: Optional[str]
    build_configSourceDigest: ListProxy[Union[str, 'Hash']]
    build_configSourceEntrypoint: ListProxy[str]
    build_configSourceUri: ListProxy[str]
    build_environment: ListProxy[Union[str, 'DictionaryEntry']]
    build_parameter: ListProxy[Union[str, 'DictionaryEntry']]


class Agent(Element):
    """
    Agent represents anything with the potential to act on a system.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Agent"
    COMPACT_TYPE = "Agent"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class Annotation(Element):
    """
    An assertion made in relation to one or more elements.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Annotation"
    COMPACT_TYPE = "Annotation"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        annotationType: Optional[str] = None,
        contentType: Optional[str] = None,
        statement: Optional[str] = None,
        subject: Optional[Union[str, 'Element']] = None,
        **kwargs: Any
    ) -> None: ...
    annotationType: Optional[str]
    contentType: Optional[str]
    statement: Optional[str]
    subject: Optional[Union[str, 'Element']]


class Artifact(Element):
    """
    A distinct article or unit within the digital domain.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Artifact"
    COMPACT_TYPE = "Artifact"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool

    def __init__(
        self,
        *,
        builtTime: Optional[datetime] = None,
        originatedBy: Optional[Iterable[Union[str, 'Agent']]] = None,
        releaseTime: Optional[datetime] = None,
        standardName: Optional[Iterable[str]] = None,
        suppliedBy: Optional[Union[str, 'Agent']] = None,
        supportLevel: Optional[Iterable[str]] = None,
        validUntilTime: Optional[datetime] = None,
        **kwargs: Any
    ) -> None: ...
    builtTime: Optional[datetime]
    originatedBy: ListProxy[Union[str, 'Agent']]
    releaseTime: Optional[datetime]
    standardName: ListProxy[str]
    suppliedBy: Optional[Union[str, 'Agent']]
    supportLevel: ListProxy[str]
    validUntilTime: Optional[datetime]


class Bundle(ElementCollection):
    """
    A collection of Elements that have a shared context.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Bundle"
    COMPACT_TYPE = "Bundle"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        context: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    context: Optional[str]


class Hash(IntegrityMethod):
    """
    A mathematically calculated representation of a grouping of data.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Hash"
    COMPACT_TYPE = "Hash"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        algorithm: Optional[str] = None,
        hashValue: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    algorithm: Optional[str]
    hashValue: Optional[str]


class LifecycleScopedRelationship(Relationship):
    """
    Provide context for a relationship that occurs in the lifecycle.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/LifecycleScopedRelationship"
    COMPACT_TYPE = "LifecycleScopedRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        scope: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    scope: Optional[str]


class Organization(Agent):
    """
    A group of people who work together in an organized way for a shared purpose.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Organization"
    COMPACT_TYPE = "Organization"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    NAMED_INDIVIDUALS: Dict[str, str]
    # An Organization representing the SPDX Project.
    SpdxOrganization: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class Person(Agent):
    """
    An individual human being.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Person"
    COMPACT_TYPE = "Person"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class SoftwareAgent(Agent):
    """
    A software agent.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/SoftwareAgent"
    COMPACT_TYPE = "SoftwareAgent"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class expandedlicensing_ConjunctiveLicenseSet(simplelicensing_AnyLicenseInfo):
    """
    Portion of an AnyLicenseInfo representing a set of licensing information
    where all elements apply.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/ConjunctiveLicenseSet"
    COMPACT_TYPE = "expandedlicensing_ConjunctiveLicenseSet"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        expandedlicensing_member: Optional[Iterable[Union[str, 'simplelicensing_AnyLicenseInfo']]] = None,
        **kwargs: Any
    ) -> None: ...
    expandedlicensing_member: ListProxy[Union[str, 'simplelicensing_AnyLicenseInfo']]


class expandedlicensing_CustomLicenseAddition(expandedlicensing_LicenseAddition):
    """
    A license addition that is not listed on the SPDX Exceptions List.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/CustomLicenseAddition"
    COMPACT_TYPE = "expandedlicensing_CustomLicenseAddition"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class expandedlicensing_DisjunctiveLicenseSet(simplelicensing_AnyLicenseInfo):
    """
    Portion of an AnyLicenseInfo representing a set of licensing information where
    only one of the elements applies.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/DisjunctiveLicenseSet"
    COMPACT_TYPE = "expandedlicensing_DisjunctiveLicenseSet"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        expandedlicensing_member: Optional[Iterable[Union[str, 'simplelicensing_AnyLicenseInfo']]] = None,
        **kwargs: Any
    ) -> None: ...
    expandedlicensing_member: ListProxy[Union[str, 'simplelicensing_AnyLicenseInfo']]


class expandedlicensing_ExtendableLicense(simplelicensing_AnyLicenseInfo):
    """
    Abstract class representing a License or an OrLaterOperator.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/ExtendableLicense"
    COMPACT_TYPE = "expandedlicensing_ExtendableLicense"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class expandedlicensing_IndividualLicensingInfo(simplelicensing_AnyLicenseInfo):
    """
    A concrete subclass of AnyLicenseInfo used by Individuals in the
    ExpandedLicensing profile.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/IndividualLicensingInfo"
    COMPACT_TYPE = "expandedlicensing_IndividualLicensingInfo"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    NAMED_INDIVIDUALS: Dict[str, str]
    # An Individual Value for License when no assertion can be made about its actual
    # value.
    NoAssertionLicense: str
    # An Individual Value for License where the SPDX data creator determines that no
    # license is present.
    NoneLicense: str

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class expandedlicensing_License(expandedlicensing_ExtendableLicense):
    """
    Abstract class for the portion of an AnyLicenseInfo representing a license.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/License"
    COMPACT_TYPE = "expandedlicensing_License"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool

    def __init__(
        self,
        *,
        expandedlicensing_isDeprecatedLicenseId: Optional[bool] = None,
        expandedlicensing_isFsfLibre: Optional[bool] = None,
        expandedlicensing_isOsiApproved: Optional[bool] = None,
        expandedlicensing_licenseXml: Optional[str] = None,
        expandedlicensing_obsoletedBy: Optional[str] = None,
        expandedlicensing_seeAlso: Optional[Iterable[str]] = None,
        expandedlicensing_standardLicenseHeader: Optional[str] = None,
        expandedlicensing_standardLicenseTemplate: Optional[str] = None,
        simplelicensing_licenseText: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    expandedlicensing_isDeprecatedLicenseId: Optional[bool]
    expandedlicensing_isFsfLibre: Optional[bool]
    expandedlicensing_isOsiApproved: Optional[bool]
    expandedlicensing_licenseXml: Optional[str]
    expandedlicensing_obsoletedBy: Optional[str]
    expandedlicensing_seeAlso: ListProxy[str]
    expandedlicensing_standardLicenseHeader: Optional[str]
    expandedlicensing_standardLicenseTemplate: Optional[str]
    simplelicensing_licenseText: Optional[str]


class expandedlicensing_ListedLicense(expandedlicensing_License):
    """
    A license that is listed on the SPDX License List.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/ListedLicense"
    COMPACT_TYPE = "expandedlicensing_ListedLicense"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        expandedlicensing_deprecatedVersion: Optional[str] = None,
        expandedlicensing_listVersionAdded: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    expandedlicensing_deprecatedVersion: Optional[str]
    expandedlicensing_listVersionAdded: Optional[str]


class expandedlicensing_OrLaterOperator(expandedlicensing_ExtendableLicense):
    """
    Portion of an AnyLicenseInfo representing this version, or any later version,
    of the indicated License.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/OrLaterOperator"
    COMPACT_TYPE = "expandedlicensing_OrLaterOperator"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        expandedlicensing_subjectLicense: Optional[Union[str, 'expandedlicensing_License']] = None,
        **kwargs: Any
    ) -> None: ...
    expandedlicensing_subjectLicense: Optional[Union[str, 'expandedlicensing_License']]


class expandedlicensing_WithAdditionOperator(simplelicensing_AnyLicenseInfo):
    """
    Portion of an AnyLicenseInfo representing a License which has additional
    text applied to it.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/WithAdditionOperator"
    COMPACT_TYPE = "expandedlicensing_WithAdditionOperator"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        expandedlicensing_subjectAddition: Optional[Union[str, 'expandedlicensing_LicenseAddition']] = None,
        expandedlicensing_subjectExtendableLicense: Optional[Union[str, 'expandedlicensing_ExtendableLicense']] = None,
        **kwargs: Any
    ) -> None: ...
    expandedlicensing_subjectAddition: Optional[Union[str, 'expandedlicensing_LicenseAddition']]
    expandedlicensing_subjectExtendableLicense: Optional[Union[str, 'expandedlicensing_ExtendableLicense']]


class extension_CdxPropertiesExtension(extension_Extension):
    """
    A type of extension consisting of a list of name value pairs.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Extension/CdxPropertiesExtension"
    COMPACT_TYPE = "extension_CdxPropertiesExtension"
    NODE_KIND: NodeKind

    def __init__(
        self,
        *,
        extension_cdxProperty: Optional[Iterable[Union[str, 'extension_CdxPropertyEntry']]] = None,
        **kwargs: Any
    ) -> None: ...
    extension_cdxProperty: ListProxy[Union[str, 'extension_CdxPropertyEntry']]


class security_CvssV2VulnAssessmentRelationship(security_VulnAssessmentRelationship):
    """
    Provides a CVSS version 2.0 assessment for a vulnerability.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/CvssV2VulnAssessmentRelationship"
    COMPACT_TYPE = "security_CvssV2VulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        security_score: Optional[float] = None,
        security_vectorString: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    security_score: Optional[float]
    security_vectorString: Optional[str]


class security_CvssV3VulnAssessmentRelationship(security_VulnAssessmentRelationship):
    """
    Provides a CVSS version 3 assessment for a vulnerability.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/CvssV3VulnAssessmentRelationship"
    COMPACT_TYPE = "security_CvssV3VulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        security_score: Optional[float] = None,
        security_severity: Optional[str] = None,
        security_vectorString: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    security_score: Optional[float]
    security_severity: Optional[str]
    security_vectorString: Optional[str]


class security_CvssV4VulnAssessmentRelationship(security_VulnAssessmentRelationship):
    """
    Provides a CVSS version 4 assessment for a vulnerability.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/CvssV4VulnAssessmentRelationship"
    COMPACT_TYPE = "security_CvssV4VulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        security_score: Optional[float] = None,
        security_severity: Optional[str] = None,
        security_vectorString: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    security_score: Optional[float]
    security_severity: Optional[str]
    security_vectorString: Optional[str]


class security_EpssVulnAssessmentRelationship(security_VulnAssessmentRelationship):
    """
    Provides an EPSS assessment for a vulnerability.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/EpssVulnAssessmentRelationship"
    COMPACT_TYPE = "security_EpssVulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        security_percentile: Optional[float] = None,
        security_probability: Optional[float] = None,
        **kwargs: Any
    ) -> None: ...
    security_percentile: Optional[float]
    security_probability: Optional[float]


class security_ExploitCatalogVulnAssessmentRelationship(security_VulnAssessmentRelationship):
    """
    Provides an exploit assessment of a vulnerability.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/ExploitCatalogVulnAssessmentRelationship"
    COMPACT_TYPE = "security_ExploitCatalogVulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        security_catalogType: Optional[str] = None,
        security_exploited: Optional[bool] = None,
        security_locator: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    security_catalogType: Optional[str]
    security_exploited: Optional[bool]
    security_locator: Optional[str]


class security_SsvcVulnAssessmentRelationship(security_VulnAssessmentRelationship):
    """
    Provides an SSVC assessment for a vulnerability.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/SsvcVulnAssessmentRelationship"
    COMPACT_TYPE = "security_SsvcVulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        security_decisionType: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    security_decisionType: Optional[str]


class security_VexVulnAssessmentRelationship(security_VulnAssessmentRelationship):
    """
    Abstract ancestor class for all VEX relationships
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/VexVulnAssessmentRelationship"
    COMPACT_TYPE = "security_VexVulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool

    def __init__(
        self,
        *,
        security_statusNotes: Optional[str] = None,
        security_vexVersion: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    security_statusNotes: Optional[str]
    security_vexVersion: Optional[str]


class security_Vulnerability(Artifact):
    """
    Specifies a vulnerability and its associated information.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/Vulnerability"
    COMPACT_TYPE = "security_Vulnerability"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        security_modifiedTime: Optional[datetime] = None,
        security_publishedTime: Optional[datetime] = None,
        security_withdrawnTime: Optional[datetime] = None,
        **kwargs: Any
    ) -> None: ...
    security_modifiedTime: Optional[datetime]
    security_publishedTime: Optional[datetime]
    security_withdrawnTime: Optional[datetime]


class software_SoftwareArtifact(Artifact):
    """
    A distinct article or unit related to Software.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Software/SoftwareArtifact"
    COMPACT_TYPE = "software_SoftwareArtifact"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]
    IS_ABSTRACT: bool

    def __init__(
        self,
        *,
        software_additionalPurpose: Optional[Iterable[str]] = None,
        software_attributionText: Optional[Iterable[str]] = None,
        software_contentIdentifier: Optional[Iterable[Union[str, 'software_ContentIdentifier']]] = None,
        software_copyrightText: Optional[str] = None,
        software_primaryPurpose: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    software_additionalPurpose: ListProxy[str]
    software_attributionText: ListProxy[str]
    software_contentIdentifier: ListProxy[Union[str, 'software_ContentIdentifier']]
    software_copyrightText: Optional[str]
    software_primaryPurpose: Optional[str]


class Bom(Bundle):
    """
    A container for a grouping of SPDX-3.0 content characterizing details
    (provenence, composition, licensing, etc.) about a product.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Core/Bom"
    COMPACT_TYPE = "Bom"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class expandedlicensing_CustomLicense(expandedlicensing_License):
    """
    A license that is not listed on the SPDX License List.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/CustomLicense"
    COMPACT_TYPE = "expandedlicensing_CustomLicense"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class security_VexAffectedVulnAssessmentRelationship(security_VexVulnAssessmentRelationship):
    """
    Connects a vulnerability and an element designating the element as a product
    affected by the vulnerability.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/VexAffectedVulnAssessmentRelationship"
    COMPACT_TYPE = "security_VexAffectedVulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        security_actionStatement: Optional[str] = None,
        security_actionStatementTime: Optional[datetime] = None,
        **kwargs: Any
    ) -> None: ...
    security_actionStatement: Optional[str]
    security_actionStatementTime: Optional[datetime]


class security_VexFixedVulnAssessmentRelationship(security_VexVulnAssessmentRelationship):
    """
    Links a vulnerability and elements representing products (in the VEX sense) where
    a fix has been applied and are no longer affected.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/VexFixedVulnAssessmentRelationship"
    COMPACT_TYPE = "security_VexFixedVulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class security_VexNotAffectedVulnAssessmentRelationship(security_VexVulnAssessmentRelationship):
    """
    Links a vulnerability and one or more elements designating the latter as products
    not affected by the vulnerability.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/VexNotAffectedVulnAssessmentRelationship"
    COMPACT_TYPE = "security_VexNotAffectedVulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        security_impactStatement: Optional[str] = None,
        security_impactStatementTime: Optional[datetime] = None,
        security_justificationType: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    security_impactStatement: Optional[str]
    security_impactStatementTime: Optional[datetime]
    security_justificationType: Optional[str]


class security_VexUnderInvestigationVulnAssessmentRelationship(security_VexVulnAssessmentRelationship):
    """
    Designates elements as products where the impact of a vulnerability is being
    investigated.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Security/VexUnderInvestigationVulnAssessmentRelationship"
    COMPACT_TYPE = "security_VexUnderInvestigationVulnAssessmentRelationship"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        **kwargs: Any
    ) -> None: ...


class software_File(software_SoftwareArtifact):
    """
    Refers to any object that stores content on a computer.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Software/File"
    COMPACT_TYPE = "software_File"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        contentType: Optional[str] = None,
        software_fileKind: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    contentType: Optional[str]
    software_fileKind: Optional[str]


class software_Package(software_SoftwareArtifact):
    """
    Refers to any unit of content that can be associated with a distribution of
    software.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Software/Package"
    COMPACT_TYPE = "software_Package"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        software_downloadLocation: Optional[str] = None,
        software_homePage: Optional[str] = None,
        software_packageUrl: Optional[str] = None,
        software_packageVersion: Optional[str] = None,
        software_sourceInfo: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    software_downloadLocation: Optional[str]
    software_homePage: Optional[str]
    software_packageUrl: Optional[str]
    software_packageVersion: Optional[str]
    software_sourceInfo: Optional[str]


class software_Sbom(Bom):
    """
    A collection of SPDX Elements describing a single package.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Software/Sbom"
    COMPACT_TYPE = "software_Sbom"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        software_sbomType: Optional[Iterable[str]] = None,
        **kwargs: Any
    ) -> None: ...
    software_sbomType: ListProxy[str]


class software_Snippet(software_SoftwareArtifact):
    """
    Describes a certain part of a file.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Software/Snippet"
    COMPACT_TYPE = "software_Snippet"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        software_byteRange: Optional[Union[str, 'PositiveIntegerRange']] = None,
        software_lineRange: Optional[Union[str, 'PositiveIntegerRange']] = None,
        software_snippetFromFile: Optional[Union[str, 'software_File']] = None,
        **kwargs: Any
    ) -> None: ...
    software_byteRange: Optional[Union[str, 'PositiveIntegerRange']]
    software_lineRange: Optional[Union[str, 'PositiveIntegerRange']]
    software_snippetFromFile: Optional[Union[str, 'software_File']]


class ai_AIPackage(software_Package):
    """
    Specifies an AI package and its associated information.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/AI/AIPackage"
    COMPACT_TYPE = "ai_AIPackage"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        ai_autonomyType: Optional[str] = None,
        ai_domain: Optional[Iterable[str]] = None,
        ai_energyConsumption: Optional[Union[str, 'ai_EnergyConsumption']] = None,
        ai_hyperparameter: Optional[Iterable[Union[str, 'DictionaryEntry']]] = None,
        ai_informationAboutApplication: Optional[str] = None,
        ai_informationAboutTraining: Optional[str] = None,
        ai_limitation: Optional[str] = None,
        ai_metric: Optional[Iterable[Union[str, 'DictionaryEntry']]] = None,
        ai_metricDecisionThreshold: Optional[Iterable[Union[str, 'DictionaryEntry']]] = None,
        ai_modelDataPreprocessing: Optional[Iterable[str]] = None,
        ai_modelExplainability: Optional[Iterable[str]] = None,
        ai_safetyRiskAssessment: Optional[str] = None,
        ai_standardCompliance: Optional[Iterable[str]] = None,
        ai_typeOfModel: Optional[Iterable[str]] = None,
        ai_useSensitivePersonalInformation: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...
    ai_autonomyType: Optional[str]
    ai_domain: ListProxy[str]
    ai_energyConsumption: Optional[Union[str, 'ai_EnergyConsumption']]
    ai_hyperparameter: ListProxy[Union[str, 'DictionaryEntry']]
    ai_informationAboutApplication: Optional[str]
    ai_informationAboutTraining: Optional[str]
    ai_limitation: Optional[str]
    ai_metric: ListProxy[Union[str, 'DictionaryEntry']]
    ai_metricDecisionThreshold: ListProxy[Union[str, 'DictionaryEntry']]
    ai_modelDataPreprocessing: ListProxy[str]
    ai_modelExplainability: ListProxy[str]
    ai_safetyRiskAssessment: Optional[str]
    ai_standardCompliance: ListProxy[str]
    ai_typeOfModel: ListProxy[str]
    ai_useSensitivePersonalInformation: Optional[str]


class dataset_DatasetPackage(software_Package):
    """
    Specifies a data package and its associated information.
    """

    TYPE = "https://spdx.org/rdf/3.0.1/terms/Dataset/DatasetPackage"
    COMPACT_TYPE = "dataset_DatasetPackage"
    NODE_KIND: NodeKind
    ID_ALIAS: Optional[str]

    def __init__(
        self,
        *,
        dataset_anonymizationMethodUsed: Optional[Iterable[str]] = None,
        dataset_confidentialityLevel: Optional[str] = None,
        dataset_dataCollectionProcess: Optional[str] = None,
        dataset_dataPreprocessing: Optional[Iterable[str]] = None,
        dataset_datasetAvailability: Optional[str] = None,
        dataset_datasetNoise: Optional[str] = None,
        dataset_datasetSize: Optional[int] = None,
        dataset_datasetType: Optional[Iterable[str]] = None,
        dataset_datasetUpdateMechanism: Optional[str] = None,
        dataset_hasSensitivePersonalInformation: Optional[str] = None,
        dataset_intendedUse: Optional[str] = None,
        dataset_knownBias: Optional[Iterable[str]] = None,
        dataset_sensor: Optional[Iterable[Union[str, 'DictionaryEntry']]] = None,
        **kwargs: Any
    ) -> None: ...
    dataset_anonymizationMethodUsed: ListProxy[str]
    dataset_confidentialityLevel: Optional[str]
    dataset_dataCollectionProcess: Optional[str]
    dataset_dataPreprocessing: ListProxy[str]
    dataset_datasetAvailability: Optional[str]
    dataset_datasetNoise: Optional[str]
    dataset_datasetSize: Optional[int]
    dataset_datasetType: ListProxy[str]
    dataset_datasetUpdateMechanism: Optional[str]
    dataset_hasSensitivePersonalInformation: Optional[str]
    dataset_intendedUse: Optional[str]
    dataset_knownBias: ListProxy[str]
    dataset_sensor: ListProxy[Union[str, 'DictionaryEntry']]


"""Format Guard"""
# fmt: on
