spdx-python-model 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

spdx_python_model/bindings/v3_0_1.py

@@ -6,6 +6,9 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
+import decimal
 import functools
 import hashlib
 import json
@@ -14,19 +17,38 @@ import sys
 import threading
 import time
 import warnings
+from abc import ABC, abstractmethod
 from contextlib import contextmanager
-from datetime import datetime, timezone, timedelta
+from datetime import datetime, timedelta, timezone
 from enum import Enum
-from abc import ABC, abstractmethod
-
-
-def check_type(obj, types):
+from typing import (
+    Any,
+    Callable,
+    Collection,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+
+
+def check_type(obj: Any, types: Union[Type[Any], Tuple[Type[Any], ...]]) -> None:
     if not isinstance(obj, types):
         if isinstance(types, (list, tuple)):
             raise TypeError(
-                f"Value must be one of type: {', '.join(t.__name__ for t in types)}. Got {type(obj)}"
+                f"Value must be one of type: {', '.join(t.__name__ for t in types)}. Got {type(obj).__name__}"
             )
-        raise TypeError(f"Value must be of type {types.__name__}. Got {type(obj)}")
+        raise TypeError(
+            f"Value must be of type {types.__name__}. Got {type(obj).__name__}"
+        )
 
 
 class Property(ABC):
@@ -35,13 +57,15 @@ class Property(ABC):
     class
     """
 
-    def __init__(self, *, pattern=None):
+    VALID_TYPES: Union[Tuple, Type] = ()
+
+    def __init__(self, *, pattern: Optional[str] = None):
         self.pattern = pattern
 
-    def init(self):
+    def init(self) -> Any:
         return None
 
-    def validate(self, value):
+    def validate(self, value) -> None:
         check_type(value, self.VALID_TYPES)
         if self.pattern is not None and not re.search(
             self.pattern, self.to_string(value)
@@ -50,37 +74,41 @@ class Property(ABC):
                 f"Value is not correctly formatted. Got '{self.to_string(value)}'"
             )
 
-    def set(self, value):
+    def set(self, value: Any) -> Any:
         return value
 
-    def check_min_count(self, value, min_count):
+    def check_min_count(self, value, min_count: int) -> bool:
         return min_count == 1
 
-    def check_max_count(self, value, max_count):
+    def check_max_count(self, value, max_count: int) -> bool:
         return max_count == 1
 
-    def elide(self, value):
+    def elide(self, value) -> bool:
         return value is None
 
-    def walk(self, value, callback, path):
+    def walk(self, value, callback: Callable, path: List[str]) -> None:
         callback(value, path)
 
-    def iter_objects(self, value, recursive, visited):
+    def iter_objects(
+        self, value, recursive: bool, visited: Set[SHACLObject]
+    ) -> Iterable[Any]:
         return []
 
-    def link_prop(self, value, objectset, missing, visited):
+    def link_prop(
+        self, value, objectset, missing: Optional[Set[str]], visited: Set[SHACLObject]
+    ):
         return value
 
-    def to_string(self, value):
+    def to_string(self, value) -> str:
         return str(value)
 
     @abstractmethod
-    def encode(self, encoder, value, state):
-        pass
+    def encode(self, encoder, value, state) -> None:
+        raise NotImplementedError("Subclasses must implement encode method")
 
     @abstractmethod
-    def decode(self, decoder, *, objectset=None):
-        pass
+    def decode(self, decoder, *, objectset: Optional[SHACLObjectSet] = None) -> Any:
+        raise NotImplementedError("Subclasses must implement decode method")
 
 
 class StringProp(Property):
@@ -90,21 +118,25 @@ class StringProp(Property):
 
     VALID_TYPES = str
 
-    def set(self, value):
+    def set(self, value) -> str:
         return str(value)
 
-    def encode(self, encoder, value, state):
+    def encode(self, encoder, value, state) -> None:
         encoder.write_string(value)
 
-    def decode(self, decoder, *, objectset=None):
+    def decode(
+        self, decoder, *, objectset: Optional[SHACLObjectSet] = None
+    ) -> Optional[str]:
         return decoder.read_string()
 
 
 class AnyURIProp(StringProp):
-    def encode(self, encoder, value, state):
+    def encode(self, encoder, value, state) -> None:
         encoder.write_iri(value)
 
-    def decode(self, decoder, *, objectset=None):
+    def decode(
+        self, decoder, *, objectset: Optional[SHACLObjectSet] = None
+    ) -> Optional[str]:
         return decoder.read_iri()
 
 
@@ -117,37 +149,52 @@ class DateTimeProp(Property):
     UTC_FORMAT_STR = "%Y-%m-%dT%H:%M:%SZ"
     REGEX = r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|[+-]\d{2}:\d{2})?$"
 
-    def set(self, value):
+    def set(self, value) -> datetime:
         return self._normalize(value)
 
-    def encode(self, encoder, value, state):
+    def encode(self, encoder, value, state) -> None:
         encoder.write_datetime(self.to_string(value))
 
-    def decode(self, decoder, *, objectset=None):
+    def decode(
+        self, decoder, *, objectset: Optional[SHACLObjectSet] = None
+    ) -> Optional[datetime]:
         s = decoder.read_datetime()
         if s is None:
             return None
+        if isinstance(s, datetime):
+            return self._normalize(s)
         v = self.from_string(s)
         return self._normalize(v)
 
-    def _normalize(self, value):
+    def _normalize(self, value: datetime) -> datetime:
         if value.utcoffset() is None:
             value = value.astimezone()
+
+        # Remove seconds from timezone offset
         offset = value.utcoffset()
-        seconds = offset % timedelta(minutes=-1 if offset.total_seconds() < 0 else 1)
-        if seconds:
-            offset = offset - seconds
-            value = value.replace(tzinfo=timezone(offset))
+        if offset is not None:
+            seconds = offset % timedelta(
+                minutes=-1 if offset.total_seconds() < 0 else 1
+            )
+            if seconds:
+                offset = offset - seconds
+                value = value.replace(tzinfo=timezone(offset))
+
+        # Convert 00:00 timezone offset to UTC
+        offset = value.utcoffset()
+        if offset is not None and offset.seconds == 0:
+            value = value.astimezone(timezone.utc)
+
         value = value.replace(microsecond=0)
         return value
 
-    def to_string(self, value):
+    def to_string(self, value: datetime) -> str:
         value = self._normalize(value)
         if value.tzinfo == timezone.utc:
             return value.strftime(self.UTC_FORMAT_STR)
         return value.isoformat()
 
-    def from_string(self, value):
+    def from_string(self, value: str) -> datetime:
         if not re.match(self.REGEX, value):
             raise ValueError(f"'{value}' is not a correctly formatted datetime")
         if "Z" in value:
@@ -172,25 +219,27 @@ class DateTimeStampProp(DateTimeProp):
 class IntegerProp(Property):
     VALID_TYPES = int
 
-    def set(self, value):
+    def set(self, value) -> int:
         return int(value)
 
-    def encode(self, encoder, value, state):
+    def encode(self, encoder, value, state) -> None:
         encoder.write_integer(value)
 
-    def decode(self, decoder, *, objectset=None):
+    def decode(
+        self, decoder, *, objectset: Optional[SHACLObjectSet] = None
+    ) -> Optional[int]:
         return decoder.read_integer()
 
 
 class PositiveIntegerProp(IntegerProp):
-    def validate(self, value):
+    def validate(self, value) -> None:
         super().validate(value)
         if value < 1:
             raise ValueError(f"Value must be >=1. Got {value}")
 
 
 class NonNegativeIntegerProp(IntegerProp):
-    def validate(self, value):
+    def validate(self, value) -> None:
         super().validate(value)
         if value < 0:
             raise ValueError(f"Value must be >= 0. Got {value}")
@@ -199,41 +248,52 @@ class NonNegativeIntegerProp(IntegerProp):
 class BooleanProp(Property):
     VALID_TYPES = bool
 
-    def set(self, value):
+    def set(self, value) -> bool:
         return bool(value)
 
-    def encode(self, encoder, value, state):
+    def encode(self, encoder, value, state) -> None:
         encoder.write_bool(value)
 
-    def decode(self, decoder, *, objectset=None):
+    def decode(
+        self, decoder, *, objectset: Optional[SHACLObjectSet] = None
+    ) -> Optional[bool]:
         return decoder.read_bool()
 
 
 class FloatProp(Property):
     VALID_TYPES = (float, int)
 
-    def set(self, value):
+    def set(self, value) -> float:
         return float(value)
 
-    def encode(self, encoder, value, state):
+    def encode(self, encoder, value, state) -> None:
         encoder.write_float(value)
 
-    def decode(self, decoder, *, objectset=None):
+    def decode(
+        self, decoder, *, objectset: Optional[SHACLObjectSet] = None
+    ) -> Optional[float]:
         return decoder.read_float()
 
 
 class IRIProp(Property):
-    def __init__(self, context=[], *, pattern=None):
+    def __init__(
+        self,
+        context: Optional[List[Tuple[str, str]]] = None,
+        *,
+        pattern: Optional[str] = None,
+    ):
+        if context is None:
+            context = []
         super().__init__(pattern=pattern)
         self.context = context
 
-    def compact(self, value):
+    def compact(self, value) -> Optional[str]:
         for iri, compact in self.context:
             if value == iri:
                 return compact
         return None
 
-    def expand(self, value):
+    def expand(self, value) -> Optional[str]:
         for iri, compact in self.context:
             if value == compact:
                 return iri
@@ -248,15 +308,19 @@ class ObjectProp(IRIProp):
     A scalar SHACL object property of a SHACL object
     """
 
-    def __init__(self, cls, required, context=[]):
+    def __init__(
+        self, cls, required: bool, context: Optional[List[Tuple[str, str]]] = None
+    ):
+        if context is None:
+            context = []
         super().__init__(context)
         self.cls = cls
         self.required = required
 
-    def validate(self, value):
+    def validate(self, value) -> None:
         check_type(value, (self.cls, str))
 
-    def walk(self, value, callback, path):
+    def walk(self, value, callback: Callable, path: List[str]) -> None:
         if value is None:
             return
 
@@ -265,7 +329,7 @@ class ObjectProp(IRIProp):
         else:
             callback(value, path)
 
-    def iter_objects(self, value, recursive, visited):
+    def iter_objects(self, value, recursive: bool, visited):
         if value is None or isinstance(value, str):
             return
 
@@ -277,7 +341,7 @@ class ObjectProp(IRIProp):
                 for c in value.iter_objects(recursive=True, visited=visited):
                     yield c
 
-    def encode(self, encoder, value, state):
+    def encode(self, encoder, value, state) -> None:
         if value is None:
             raise ValueError("Object cannot be None")
 
@@ -287,11 +351,12 @@ class ObjectProp(IRIProp):
 
         return value.encode(encoder, state)
 
-    def decode(self, decoder, *, objectset=None):
-        iri = decoder.read_iri()
-        if iri is None:
+    def decode(self, decoder, *, objectset: Optional[SHACLObjectSet] = None):
+        if decoder.is_object():
             return self.cls.decode(decoder, objectset=objectset)
 
+        iri = decoder.read_iri()
+
         iri = self.expand(iri) or iri
 
         if objectset is None:
@@ -329,41 +394,45 @@ class ObjectProp(IRIProp):
 
 
 class ListProxy(object):
-    def __init__(self, prop, data=None):
+    def __init__(self, prop: Property, data: Optional[List[Any]] = None):
         if data is None:
-            self.__data = []
+            self.__data: List[Any] = []
         else:
             self.__data = data
         self.__prop = prop
 
-    def append(self, value):
+    def append(self, value) -> None:
         self.__prop.validate(value)
         self.__data.append(self.__prop.set(value))
 
-    def insert(self, idx, value):
+    def insert(self, idx: int, value) -> None:
         self.__prop.validate(value)
         self.__data.insert(idx, self.__prop.set(value))
 
-    def extend(self, items):
+    def extend(self, items: Iterable[Any]) -> None:
         for i in items:
             self.append(i)
 
-    def sort(self, *args, **kwargs):
+    def sort(self, *args, **kwargs) -> None:
         self.__data.sort(*args, **kwargs)
 
     def __getitem__(self, key):
         return self.__data[key]
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key, value) -> None:
         if isinstance(key, slice):
             for v in value:
                 self.__prop.validate(v)
             self.__data[key] = [self.__prop.set(v) for v in value]
-        else:
+        elif isinstance(key, int):
             self.__prop.validate(value)
             self.__data[key] = self.__prop.set(value)
+        else:
+            raise TypeError(
+                f"ListProxy indices must be integers or slices. Got {type(key).__name__}"
+            )
 
-    def __delitem__(self, key):
+    def __delitem__(self, key) -> None:
         del self.__data[key]
 
     def __contains__(self, item):
@@ -372,10 +441,10 @@ class ListProxy(object):
     def __iter__(self):
         return iter(self.__data)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.__data)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.__data)
 
     def __repr__(self):
@@ -395,43 +464,43 @@ class ListProp(Property):
 
     VALID_TYPES = (list, ListProxy)
 
-    def __init__(self, prop):
+    def __init__(self, prop: Property):
         super().__init__()
         self.prop = prop
 
-    def init(self):
+    def init(self) -> ListProxy:
         return ListProxy(self.prop)
 
-    def validate(self, value):
+    def validate(self, value) -> None:
         super().validate(value)
 
         for i in value:
             self.prop.validate(i)
 
-    def set(self, value):
+    def set(self, value) -> ListProxy:
         if isinstance(value, ListProxy):
             return value
 
         return ListProxy(self.prop, [self.prop.set(d) for d in value])
 
-    def check_min_count(self, value, min_count):
+    def check_min_count(self, value, min_count: int) -> bool:
         check_type(value, ListProxy)
         return len(value) >= min_count
 
-    def check_max_count(self, value, max_count):
+    def check_max_count(self, value, max_count: int) -> bool:
         check_type(value, ListProxy)
         return len(value) <= max_count
 
-    def elide(self, value):
+    def elide(self, value) -> bool:
         check_type(value, ListProxy)
         return len(value) == 0
 
-    def walk(self, value, callback, path):
+    def walk(self, value, callback: Callable, path: List[str]) -> None:
         callback(value, path)
         for idx, v in enumerate(value):
             self.prop.walk(v, callback, path + [f"[{idx}]"])
 
-    def iter_objects(self, value, recursive, visited):
+    def iter_objects(self, value, recursive: bool, visited):
         for v in value:
             for c in self.prop.iter_objects(v, recursive, visited):
                 yield c
@@ -444,7 +513,7 @@ class ListProp(Property):
 
         return ListProxy(self.prop, data=data)
 
-    def encode(self, encoder, value, state):
+    def encode(self, encoder, value, state) -> None:
         check_type(value, ListProxy)
 
         with encoder.write_list() as list_s:
@@ -452,7 +521,9 @@ class ListProp(Property):
                 with list_s.write_list_item() as item_s:
                     self.prop.encode(item_s, v, state)
 
-    def decode(self, decoder, *, objectset=None):
+    def decode(
+        self, decoder, *, objectset: Optional[SHACLObjectSet] = None
+    ) -> ListProxy:
         data = []
         for val_d in decoder.read_list():
             v = self.prop.decode(val_d, objectset=objectset)
@@ -465,22 +536,21 @@ class ListProp(Property):
 class EnumProp(IRIProp):
     VALID_TYPES = str
 
-    def __init__(self, values, *, pattern=None):
+    def __init__(self, values, *, pattern: Optional[str] = None):
         super().__init__(values, pattern=pattern)
 
-    def validate(self, value):
+    def validate(self, value) -> None:
         super().validate(value)
 
-        valid_values = self.iri_values()
-        if value not in valid_values:
+        if value not in self.iri_values():
             raise ValueError(
-                f"'{value}' is not a valid value. Choose one of {' '.join(valid_values)}"
+                f"'{value}' is not a valid value. Choose one of {' '.join(self.iri_values())}"
             )
 
-    def encode(self, encoder, value, state):
+    def encode(self, encoder, value, state) -> None:
         encoder.write_enum(value, self, self.compact(value))
 
-    def decode(self, decoder, *, objectset=None):
+    def decode(self, decoder, *, objectset: Optional[SHACLObjectSet] = None) -> str:
         v = decoder.read_enum(self)
         return self.expand(v) or v
 
@@ -491,7 +561,7 @@ class NodeKind(Enum):
     BlankNodeOrIRI = 3
 
 
-def is_IRI(s):
+def is_IRI(s: Any) -> bool:
     if not isinstance(s, str):
         return False
     if s.startswith("_:"):
@@ -501,7 +571,7 @@ def is_IRI(s):
     return True
 
 
-def is_blank_node(s):
+def is_blank_node(s: Any) -> bool:
     if not isinstance(s, str):
         return False
     if not s.startswith("_:"):
@@ -509,19 +579,23 @@ def is_blank_node(s):
     return True
 
 
-def register(type_iri, *, compact_type=None, abstract=False):
-    def add_class(key, c):
+def register(
+    type_iri: str, *, compact_type: Optional[str] = None, abstract: bool = False
+):
+    def add_class(key: str, c: Type[SHACLObject]) -> None:
         assert (
             key not in SHACLObject.CLASSES
         ), f"{key} already registered to {SHACLObject.CLASSES[key].__name__}"
         SHACLObject.CLASSES[key] = c
 
-    def decorator(c):
+    def decorator(c: Type[SHACLObject]) -> Type[SHACLObject]:
+        """
+        Decorator to register a class as a SHACL object type.
+        The class must derive from SHACLObject.
+        """
         global NAMED_INDIVIDUALS
 
-        assert issubclass(
-            c, SHACLObject
-        ), f"{c.__name__} is not derived from SHACLObject"
+        assert issubclass(c, SHACLObject), f"{c} is not derived from SHACLObject"
 
         c._OBJ_TYPE = type_iri
         c.IS_ABSTRACT = abstract
@@ -542,16 +616,32 @@ def register(type_iri, *, compact_type=None, abstract=False):
 
 
 register_lock = threading.Lock()
-NAMED_INDIVIDUALS = set()
+NAMED_INDIVIDUALS: Set[str] = set()
+T_SHACLObject = TypeVar("T_SHACLObject", bound="SHACLObject")
 
 
 @functools.total_ordering
 class SHACLObject(object):
-    CLASSES = {}
+    CLASSES: Dict[str, Type] = {}
+    NAMED_INDIVIDUALS: Dict[str, str] = {}
     NODE_KIND = NodeKind.BlankNodeOrIRI
-    ID_ALIAS = None
-    IS_ABSTRACT = True
-    IS_DEPRECATED = False
+    ID_ALIAS: Optional[str] = None
+    IS_ABSTRACT: bool = True
+    IS_DEPRECATED: bool = False
+
+    # These will be reinitialized during registration with @register decorator,
+    # defined here first to allow visibility at class level
+    _OBJ_TYPE: str = ""
+    _OBJ_COMPACT_TYPE: Optional[str] = None
+    _OBJ_PROPERTIES: Dict[str, Tuple] = {}
+    _OBJ_IRIS: Dict[str, str] = {}
+    _OBJ_DEPRECATED: Set[str] = set()
+    _NEEDS_REG: bool = True
+
+    # Instance variables
+    _id: Optional[str]
+    _obj_data: Dict[str, Any]
+    _obj_metadata: Dict[str, Any]
 
     def __init__(self, **kwargs):
         if self._is_abstract():
@@ -560,7 +650,9 @@ class SHACLObject(object):
             )
 
         if self.__class__.IS_DEPRECATED:
-            warnings.warn(f"{self.__class__.__name__} is deprecated", DeprecationWarning)
+            warnings.warn(
+                f"{self.__class__.__name__} is deprecated", DeprecationWarning
+            )
 
         with register_lock:
             cls = self.__class__
@@ -580,24 +672,24 @@ class SHACLObject(object):
         for k, v in kwargs.items():
             setattr(self, k, v)
 
-    def _is_abstract(self):
+    def _is_abstract(self) -> bool:
         return self.__class__.IS_ABSTRACT
 
     @classmethod
-    def _register_props(cls):
+    def _register_props(cls: Type[SHACLObject]) -> None:
         cls._add_property("_id", StringProp(), iri="@id")
 
     @classmethod
     def _add_property(
-        cls,
-        pyname,
-        prop,
-        iri,
-        min_count=None,
-        max_count=None,
-        compact=None,
-        deprecated=False,
-    ):
+        cls: Type[SHACLObject],
+        pyname: str,
+        prop: Property,
+        iri: str,
+        min_count: Optional[int] = None,
+        max_count: Optional[int] = None,
+        compact: Optional[str] = None,
+        deprecated: bool = False,
+    ) -> None:
         if pyname in cls._OBJ_IRIS:
             raise KeyError(f"'{pyname}' is already defined for '{cls.__name__}'")
         if iri in cls._OBJ_PROPERTIES:
@@ -614,7 +706,7 @@ class SHACLObject(object):
         if deprecated:
             cls._OBJ_DEPRECATED.add(iri)
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value) -> None:
         if name == self.ID_ALIAS:
             self["@id"] = value
             return
@@ -627,7 +719,7 @@ class SHACLObject(object):
                 f"'{name}' is not a valid property of {self.__class__.__name__}"
             )
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str):
         if name in self._OBJ_IRIS:
             return self.__dict__["_obj_data"][self._OBJ_IRIS[name]]
 
@@ -650,7 +742,7 @@ class SHACLObject(object):
             f"'{name}' is not a valid property of {self.__class__.__name__}"
         )
 
-    def __delattr__(self, name):
+    def __delattr__(self, name: str) -> None:
         if name == self.ID_ALIAS:
             del self["@id"]
             return
@@ -663,7 +755,9 @@ class SHACLObject(object):
                 f"'{name}' is not a valid property of {self.__class__.__name__}"
             )
 
-    def __get_prop(self, iri):
+    def __get_prop(
+        self, iri: str
+    ) -> Tuple[Property, Optional[int], Optional[int], str, Optional[str]]:
         if iri not in self._OBJ_PROPERTIES:
             raise KeyError(
                 f"'{iri}' is not a valid property of {self.__class__.__name__}"
@@ -671,45 +765,51 @@ class SHACLObject(object):
 
         return self._OBJ_PROPERTIES[iri]
 
-    def __iter_props(self):
+    def __iter_props(
+        self,
+    ) -> Iterator[
+        Tuple[str, Property, Optional[int], Optional[int], str, Optional[str]]
+    ]:
         for iri, v in self._OBJ_PROPERTIES.items():
             yield iri, *v
 
-    def __getitem__(self, iri):
+    def __getitem__(self, iri: str) -> Any:
         return self.__dict__["_obj_data"][iri]
 
-    def __setitem__(self, iri, value):
+    def __setitem__(self, iri: str, value) -> None:
         if iri == "@id":
             if self.NODE_KIND == NodeKind.BlankNode:
                 if not is_blank_node(value):
                     raise ValueError(
-                        f"{self.__class__.__name__} ({id(self)}) can only have local reference. Property '{iri}' cannot be set to '{value}' and must start with '_:'"
+                        f"{self.__class__.__name__} ({id(self)}) can only have local reference. Property '{iri}' cannot be set to {value!r} and must start with '_:'"
                     )
             elif self.NODE_KIND == NodeKind.IRI:
                 if not is_IRI(value):
                     raise ValueError(
-                        f"{self.__class__.__name__} ({id(self)}) can only have an IRI value. Property '{iri}' cannot be set to '{value}'"
+                        f"{self.__class__.__name__} ({id(self)}) can only have an IRI value. Property '{iri}' cannot be set to {value!r}"
                     )
             else:
                 if not is_blank_node(value) and not is_IRI(value):
                     raise ValueError(
-                        f"{self.__class__.__name__} ({id(self)}) Has invalid Property '{iri}' '{value}'. Must be a blank node or IRI"
+                        f"{self.__class__.__name__} ({id(self)}) Has invalid Property '{iri}' {value!r}. Must be a blank node or IRI"
                     )
 
         prop, _, _, pyname, _ = self.__get_prop(iri)
         prop.validate(value)
         if iri in self._OBJ_DEPRECATED:
-            warnings.warn(f"{self.__class__.__name__}.{pyname} is deprecated", DeprecationWarning)
+            warnings.warn(
+                f"{self.__class__.__name__}.{pyname} is deprecated", DeprecationWarning
+            )
         self.__dict__["_obj_data"][iri] = prop.set(value)
 
-    def __delitem__(self, iri):
+    def __delitem__(self, iri: str) -> None:
         prop, _, _, _, _ = self.__get_prop(iri)
         self.__dict__["_obj_data"][iri] = prop.init()
 
-    def __iter__(self):
-        return self._OBJ_PROPERTIES.keys()
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._OBJ_PROPERTIES.keys())
 
-    def walk(self, callback, path=None):
+    def walk(self, callback: Callable, path: Optional[List[str]] = None) -> None:
         """
         Walk object tree, invoking the callback for each item
 
@@ -724,13 +824,13 @@ class SHACLObject(object):
             for iri, prop, _, _, _, _ in self.__iter_props():
                 prop.walk(self.__dict__["_obj_data"][iri], callback, path + [f".{iri}"])
 
-    def property_keys(self):
+    def property_keys(self) -> Iterator[Tuple[Optional[str], str, Optional[str]]]:
         for iri, _, _, _, pyname, compact in self.__iter_props():
             if iri == "@id":
                 compact = self.ID_ALIAS
             yield pyname, iri, compact
 
-    def iter_objects(self, *, recursive=False, visited=None):
+    def iter_objects(self, *, recursive: bool = False, visited=None):
         """
         Iterate of all objects that are a child of this one
         """
@@ -743,7 +843,7 @@ class SHACLObject(object):
             ):
                 yield c
 
-    def encode(self, encoder, state):
+    def encode(self, encoder, state) -> None:
         idname = self.ID_ALIAS or self._OBJ_IRIS["_id"]
         if not self._id and self.NODE_KIND == NodeKind.IRI:
             raise ValueError(
@@ -763,7 +863,7 @@ class SHACLObject(object):
         ) as obj_s:
             self._encode_properties(obj_s, state)
 
-    def _encode_properties(self, encoder, state):
+    def _encode_properties(self, encoder, state) -> None:
         for iri, prop, min_count, max_count, pyname, compact in self.__iter_props():
             value = self.__dict__["_obj_data"][iri]
             if prop.elide(value):
@@ -792,52 +892,45 @@ class SHACLObject(object):
                 prop.encode(prop_s, value, state)
 
     @classmethod
-    def _make_object(cls, typ):
+    def _make_object(cls: Type["SHACLObject"], typ: str) -> "SHACLObject":
         if typ not in cls.CLASSES:
             raise TypeError(f"Unknown type {typ}")
 
         return cls.CLASSES[typ]()
 
     @classmethod
-    def decode(cls, decoder, *, objectset=None):
+    def decode(cls, decoder, *, objectset: Optional[SHACLObjectSet] = None):
         typ, obj_d = decoder.read_object()
         if typ is None:
             raise TypeError("Unable to determine type for object")
 
         obj = cls._make_object(typ)
-        for key in (obj.ID_ALIAS, obj._OBJ_IRIS["_id"]):
-            with obj_d.read_property(key) as prop_d:
-                if prop_d is None:
-                    continue
-
-                _id = prop_d.read_iri()
-                if _id is None:
-                    raise TypeError(f"Object key '{key}' is the wrong type")
-
-                obj._id = _id
-                break
+        _id = obj_d.read_object_id(obj.ID_ALIAS)
+        if _id is not None:
+            obj._id = _id
 
         if obj.NODE_KIND == NodeKind.IRI and not obj._id:
             raise ValueError("Object is missing required IRI")
 
         if objectset is not None:
             if obj._id:
-                v = objectset.find_by_id(_id)
+                v = objectset.find_by_id(obj._id)
                 if v is not None:
                     return v
+            objectset.add_index(obj)
 
         obj._decode_properties(obj_d, objectset=objectset)
 
-        if objectset is not None:
-            objectset.add_index(obj)
         return obj
 
-    def _decode_properties(self, decoder, objectset=None):
+    def _decode_properties(
+        self, decoder, objectset: Optional[SHACLObjectSet] = None
+    ) -> None:
         for key in decoder.object_keys():
             if not self._decode_prop(decoder, key, objectset=objectset):
                 raise KeyError(f"Unknown property '{key}'")
 
-    def _decode_prop(self, decoder, key, objectset=None):
+    def _decode_prop(self, decoder, key, objectset: Optional[SHACLObjectSet] = None):
         if key in (self._OBJ_IRIS["_id"], self.ID_ALIAS):
             return True
 
@@ -857,7 +950,9 @@ class SHACLObject(object):
 
         return False
 
-    def link_helper(self, objectset, missing, visited):
+    def link_helper(
+        self, objectset: Optional[SHACLObjectSet], missing, visited
+    ) -> None:
         if self in visited:
             return
 
@@ -900,7 +995,7 @@ class SHACLObject(object):
         return sort_key(self) < sort_key(other)
 
 
-class SHACLExtensibleObject(object):
+class SHACLExtensibleObject(SHACLObject):
     CLOSED = False
 
     def __init__(self, typ=None, **kwargs):
@@ -910,7 +1005,7 @@ class SHACLExtensibleObject(object):
             self.__dict__["_obj_TYPE"] = (self._OBJ_TYPE, self._OBJ_COMPACT_TYPE)
         super().__init__(**kwargs)
 
-    def _is_abstract(self):
+    def _is_abstract(self) -> bool:
         # Unknown classes are assumed to not be abstract so that they can be
         # deserialized
         typ = self.__dict__["_obj_TYPE"][0]
@@ -928,7 +1023,9 @@ class SHACLExtensibleObject(object):
         obj = cls(typ)
         return obj
 
-    def _decode_properties(self, decoder, objectset=None):
+    def _decode_properties(
+        self, decoder, objectset: Optional[SHACLObjectSet] = None
+    ) -> None:
         def decode_value(d):
             if not d.is_list():
                 return d.read_value()
@@ -951,26 +1048,7 @@ class SHACLExtensibleObject(object):
             with decoder.read_property(key) as prop_d:
                 self.__dict__["_obj_data"][key] = decode_value(prop_d)
 
-    def _encode_properties(self, encoder, state):
-        def encode_value(encoder, v):
-            if isinstance(v, bool):
-                encoder.write_bool(v)
-            elif isinstance(v, str):
-                encoder.write_string(v)
-            elif isinstance(v, int):
-                encoder.write_integer(v)
-            elif isinstance(v, float):
-                encoder.write_float(v)
-            elif isinstance(v, list):
-                with encoder.write_list() as list_s:
-                    for i in v:
-                        with list_s.write_list_item() as item_s:
-                            encode_value(item_s, i)
-            else:
-                raise TypeError(
-                    f"Unsupported serialized type {type(v)} with value '{v}'"
-                )
-
+    def _encode_properties(self, encoder, state) -> None:
         super()._encode_properties(encoder, state)
         if self.CLOSED:
             return
@@ -980,9 +1058,27 @@ class SHACLExtensibleObject(object):
                 continue
 
             with encoder.write_property(iri) as prop_s:
-                encode_value(prop_s, value)
-
-    def __setitem__(self, iri, value):
+                if isinstance(value, list):
+                    v = value
+                else:
+                    v = [value]
+                with prop_s.write_list() as list_s:
+                    for i in v:
+                        with list_s.write_list_item() as item_s:
+                            if isinstance(i, bool):
+                                item_s.write_bool(i)
+                            elif isinstance(i, str):
+                                item_s.write_string(i)
+                            elif isinstance(i, int):
+                                item_s.write_integer(i)
+                            elif isinstance(i, float):
+                                item_s.write_float(i)
+                            else:
+                                raise TypeError(
+                                    f"Unsupported serialized type {type(i)} with value {i!r}"
+                                )
+
+    def __setitem__(self, iri: str, value) -> None:
         try:
             super().__setitem__(iri, value)
         except KeyError:
@@ -991,9 +1087,10 @@ class SHACLExtensibleObject(object):
 
             if not is_IRI(iri):
                 raise KeyError(f"Key '{iri}' must be an IRI")
+            obj_data = self.__dict__["_obj_data"]
             self.__dict__["_obj_data"][iri] = value
 
-    def __delitem__(self, iri):
+    def __delitem__(self, iri: str) -> None:
         try:
             super().__delitem__(iri)
         except KeyError:
@@ -1011,8 +1108,8 @@ class SHACLExtensibleObject(object):
             return self.__dict__["_obj_TYPE"][1]
         return super().__getattr__(name)
 
-    def property_keys(self):
-        iris = set()
+    def property_keys(self) -> Iterator[Tuple[Optional[str], str, Optional[str]]]:
+        iris: Set[str] = set()
         for pyname, iri, compact in super().property_keys():
             iris.add(iri)
             yield pyname, iri, compact
@@ -1026,16 +1123,16 @@ class SHACLExtensibleObject(object):
 
 
 class SHACLObjectSet(object):
-    def __init__(self, objects=[], *, link=False):
-        self.objects = set()
-        self.missing_ids = set()
-        for o in objects:
-            self.objects.add(o)
+    def __init__(self, objects: Collection[SHACLObject] = [], *, link: bool = False):
+        self.objects: Set[SHACLObject] = set(objects)
+        self.missing_ids: Set[str] = set()
+        self.obj_by_id: Dict[str, SHACLObject] = {}
+        self.obj_by_type: Dict[str, Set[Tuple[bool, SHACLObject]]] = {}
         self.create_index()
         if link:
             self._link()
 
-    def create_index(self):
+    def create_index(self) -> None:
         """
         (re)Create object index
 
@@ -1047,7 +1144,7 @@ class SHACLObjectSet(object):
         for o in self.foreach():
             self.add_index(o)
 
-    def add_index(self, obj):
+    def add_index(self, obj: SHACLObject) -> None:
         """
         Add object to index
 
@@ -1081,7 +1178,7 @@ class SHACLObjectSet(object):
 
         self.obj_by_id[obj._id] = obj
 
-    def add(self, obj):
+    def add(self, obj: SHACLObject) -> SHACLObject:
         """
         Add object to object set
 
@@ -1097,7 +1194,7 @@ class SHACLObjectSet(object):
             self.add_index(obj)
         return obj
 
-    def update(self, *others):
+    def update(self, *others) -> None:
         """
         Update object set adding all objects in each other iterable
         """
@@ -1105,13 +1202,13 @@ class SHACLObjectSet(object):
             for obj in o:
                 self.add(obj)
 
-    def __contains__(self, item):
+    def __contains__(self, item: SHACLObject) -> bool:
         """
         Returns True if the item is in the object set
         """
         return item in self.objects
 
-    def link(self):
+    def link(self) -> Set[str]:
         """
         Link object set
 
@@ -1127,24 +1224,24 @@ class SHACLObjectSet(object):
         self.create_index()
         return self._link()
 
-    def _link(self):
+    def _link(self) -> Set[str]:
         global NAMED_INDIVIDUALS
 
         self.missing_ids = set()
-        visited = set()
+        visited: Set[SHACLObject] = set()
 
-        new_objects = set()
+        new_objects: Set[SHACLObject] = set()
 
         for o in self.objects:
             if o._id:
-                o = self.find_by_id(o._id, o)
+                o = cast(SHACLObject, self.find_by_id(o._id, o))
             o.link_helper(self, self.missing_ids, visited)
             new_objects.add(o)
 
         self.objects = new_objects
 
         # Remove blank nodes
-        obj_by_id = {}
+        obj_by_id: Dict[str, SHACLObject] = {}
         for _id, obj in self.obj_by_id.items():
             if _id.startswith("_:"):
                 del obj._id
@@ -1157,7 +1254,9 @@ class SHACLObjectSet(object):
 
         return self.missing_ids
 
-    def find_by_id(self, _id, default=None):
+    def find_by_id(
+        self, _id: str, default: Optional[SHACLObject] = None
+    ) -> Optional[SHACLObject]:
         """
         Find object by ID
 
@@ -1168,7 +1267,7 @@ class SHACLObjectSet(object):
             return default
         return self.obj_by_id[_id]
 
-    def foreach(self):
+    def foreach(self) -> Iterable[SHACLObject]:
         """
         Iterate over every object in the object set, and all child objects
         """
@@ -1181,7 +1280,18 @@ class SHACLObjectSet(object):
             for child in o.iter_objects(recursive=True, visited=visited):
                 yield child
 
-    def foreach_type(self, typ, *, match_subclass=True):
+    @overload
+    def foreach_type(
+        self, typ: str, *, match_subclass: bool = True
+    ) -> Iterator[SHACLObject]: ...
+    @overload
+    def foreach_type(
+        self, typ: Type[T_SHACLObject], *, match_subclass: bool = True
+    ) -> Iterator[T_SHACLObject]: ...
+
+    def foreach_type(
+        self, typ: Union[str, Type[T_SHACLObject]], *, match_subclass: bool = True
+    ) -> Iterable[SHACLObject]:
         """
         Iterate over each object of a specified type (or subclass there of)
 
@@ -1190,18 +1300,20 @@ class SHACLObjectSet(object):
         returned
         """
         if not isinstance(typ, str):
-            if not issubclass(typ, SHACLObject):
+            if not isinstance(typ, type) or not issubclass(typ, SHACLObject):
                 raise TypeError(f"Type must be derived from SHACLObject, got {typ}")
-            typ = typ._OBJ_TYPE
+            # This intermediate step is necessary for pyrefly...
+            typ_class: Type[SHACLObject] = typ
+            typ = typ_class._OBJ_TYPE
 
         if typ not in self.obj_by_type:
             return
 
         for exact, o in self.obj_by_type[typ]:
             if match_subclass or exact:
-                yield o
+                yield cast(T_SHACLObject, o)
 
-    def merge(self, *objectsets):
+    def merge(self, *objectsets) -> "SHACLObjectSet":
         """
         Merge object sets
 
@@ -1215,16 +1327,59 @@ class SHACLObjectSet(object):
 
         return SHACLObjectSet(new_objects, link=True)
 
-    def encode(self, encoder, force_list=False, *, key=None):
+    def inline_blank_nodes(self) -> None:
+        """
+        Removes (inlines) blank node objects from the root object set if they
+        are referenced in only one other location besides the root.
+
+        Deserializers that do not preserve the tree-like structure of the
+        objects (e.g. RDF) should call this to ensure that blank nodes are
+        inline correctly
+        """
+        ref_counts: Dict[SHACLObject, int] = {}
+
+        def walk_callback(value: SHACLObject, path: List[str]) -> bool:
+            nonlocal ref_counts
+
+            if not isinstance(value, SHACLObject):
+                return True
+
+            ref_counts.setdefault(value, 0)
+            ref_counts[value] += 1
+            if ref_counts[value] > 1:
+                return False
+
+            return True
+
+        for o in self.objects:
+            # Note that every object in the root object set gets at least one
+            # reference
+            o.walk(walk_callback)
+
+        new_objects = set()
+        for o in self.objects:
+            if is_IRI(o._id):
+                new_objects.add(o)
+            # If the object is a blank node and is only referenced by this
+            # root list and one other location, remove it from the root list
+            #
+            # A count of 1 means the object is only referenced by the root, and
+            # therefore must be kept
+            elif ref_counts[o] != 2:
+                new_objects.add(o)
+
+        self.objects = new_objects
+
+    def encode(self, encoder, force_list: bool = False, *, key=None) -> None:
         """
         Serialize a list of objects to a serialization encoder
 
         If force_list is true, a list will always be written using the encoder.
         """
-        ref_counts = {}
+        ref_counts: Dict[SHACLObject, int] = {}
         state = EncodeState()
 
-        def walk_callback(value, path):
+        def walk_callback(value: SHACLObject, path: List[str]) -> bool:
             nonlocal state
             nonlocal ref_counts
 
@@ -1232,7 +1387,7 @@ class SHACLObjectSet(object):
                 return True
 
             # Remove blank node ID for re-assignment
-            if value._id and value._id.startswith("_:"):
+            if is_blank_node(value._id):
                 del value._id
 
             if value._id:
@@ -1290,7 +1445,7 @@ class SHACLObjectSet(object):
         self.create_index()
 
         for obj_d in decoder.read_list():
-            o = SHACLObject.decode(obj_d, objectset=self)
+            o = SHACLExtensibleObject.decode(obj_d, objectset=self)
             self.objects.add(o)
 
         self._link()
@@ -1312,13 +1467,13 @@ class EncodeState(object):
 
         return self.blank_objects[o]
 
-    def is_refed(self, o):
+    def is_refed(self, o) -> bool:
         return o in self.ref_objects
 
-    def add_refed(self, o):
+    def add_refed(self, o) -> None:
         self.ref_objects.add(o)
 
-    def is_written(self, o):
+    def is_written(self, o) -> bool:
         return o in self.written_objects
 
     def add_written(self, o):
@@ -1327,26 +1482,26 @@ class EncodeState(object):
 
 class Decoder(ABC):
     @abstractmethod
-    def read_value(self):
+    def read_value(self) -> Optional[Any]:
         """
         Consume next item
 
         Consumes the next item of any type
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_value method")
 
     @abstractmethod
-    def read_string(self):
+    def read_string(self) -> Optional[str]:
         """
         Consume the next item as a string.
 
         Returns the string value of the next item, or `None` if the next item
         is not a string
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_string method")
 
     @abstractmethod
-    def read_datetime(self):
+    def read_datetime(self) -> Optional[str]:
         """
         Consumes the next item as a date & time string
 
@@ -1357,20 +1512,20 @@ class Decoder(ABC):
         implementation can just check if the next item is a string without
         worrying about the format
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_datetime method")
 
     @abstractmethod
-    def read_integer(self):
+    def read_integer(self) -> Optional[int]:
         """
         Consumes the next item as an integer
 
         Returns the integer value of the next item, or `None` if the next item
         is not an integer
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_integer method")
 
     @abstractmethod
-    def read_iri(self):
+    def read_iri(self) -> Optional[str]:
         """
         Consumes the next item as an IRI string
 
@@ -1380,10 +1535,10 @@ class Decoder(ABC):
         The returned string should be either a fully-qualified IRI, or a blank
         node ID
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_iri method")
 
     @abstractmethod
-    def read_enum(self, e):
+    def read_enum(self, e) -> Optional[str]:
         """
         Consumes the next item as an Enum value string
 
@@ -1394,30 +1549,30 @@ class Decoder(ABC):
         actually a member of the specified Enum, so the `Decoder` does not need
         to check that, but can if it wishes
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_enum method")
 
     @abstractmethod
-    def read_bool(self):
+    def read_bool(self) -> Optional[bool]:
         """
         Consume the next item as a boolean value
 
         Returns the boolean value of the next item, or `None` if the next item
         is not a boolean
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_bool method")
 
     @abstractmethod
-    def read_float(self):
+    def read_float(self) -> Optional[float]:
         """
         Consume the next item as a float value
 
         Returns the float value of the next item, or `None` if the next item is
         not a float
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_float method")
 
     @abstractmethod
-    def read_list(self):
+    def read_list(self) -> Iterator["Decoder"]:
         """
         Consume the next item as a list generator
 
@@ -1425,19 +1580,19 @@ class Decoder(ABC):
         generated `Decoder` can be used to read the corresponding item from the
         list
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_list method")
 
     @abstractmethod
-    def is_list(self):
+    def is_list(self) -> bool:
         """
         Checks if the next item is a list
 
         Returns True if the next item is a list, or False if it is a scalar
         """
-        pass
+        raise NotImplementedError("Subclasses must implement is_list method")
 
     @abstractmethod
-    def read_object(self):
+    def read_object(self) -> Tuple[Any, "Decoder"]:
         """
         Consume next item as an object
 
@@ -1448,11 +1603,11 @@ class Decoder(ABC):
         Properties will be read out of the object using `read_property` and
         `read_object_id`
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_object method")
 
     @abstractmethod
     @contextmanager
-    def read_property(self, key):
+    def read_property(self, key) -> Iterator[Optional["Decoder"]]:
         """
         Read property from object
 
@@ -1460,19 +1615,28 @@ class Decoder(ABC):
         value of the property with the given key in current object, or `None`
         if the property does not exist in the current object.
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_property method")
+
+    @abstractmethod
+    def is_object(self) -> bool:
+        """
+        Checks if the item is an object
+
+        Returns True if the item is an object, or False if is not
+        """
+        raise NotImplementedError("Subclasses must implement is_object method")
 
     @abstractmethod
-    def object_keys(self):
+    def object_keys(self) -> Iterator[str]:
         """
         Read property keys from an object
 
         Iterates over all the serialized keys for the current object
         """
-        pass
+        raise NotImplementedError("Subclasses must implement object_keys method")
 
     @abstractmethod
-    def read_object_id(self, alias=None):
+    def read_object_id(self, alias=None) -> Optional[Any]:
         """
         Read current object ID property
 
@@ -1484,15 +1648,15 @@ class Decoder(ABC):
         If `alias` is provided, is is a hint as to another name by which the ID
         might be found, if the `Decoder` supports aliases for an ID
         """
-        pass
+        raise NotImplementedError("Subclasses must implement read_object_id method")
 
 
 class JSONLDDecoder(Decoder):
-    def __init__(self, data, root=False):
+    def __init__(self, data, root: bool = False):
         self.data = data
         self.root = root
 
-    def read_value(self):
+    def read_value(self) -> Optional[Any]:
         if isinstance(self.data, str):
             try:
                 return float(self.data)
@@ -1500,47 +1664,47 @@ class JSONLDDecoder(Decoder):
                 pass
         return self.data
 
-    def read_string(self):
+    def read_string(self) -> Optional[str]:
         if isinstance(self.data, str):
             return self.data
         return None
 
-    def read_datetime(self):
+    def read_datetime(self) -> Optional[str]:
         return self.read_string()
 
-    def read_integer(self):
+    def read_integer(self) -> Optional[int]:
         if isinstance(self.data, int):
             return self.data
         return None
 
-    def read_bool(self):
+    def read_bool(self) -> Optional[bool]:
         if isinstance(self.data, bool):
             return self.data
         return None
 
-    def read_float(self):
+    def read_float(self) -> Optional[float]:
         if isinstance(self.data, (int, float, str)):
             return float(self.data)
         return None
 
-    def read_iri(self):
+    def read_iri(self) -> Optional[str]:
         if isinstance(self.data, str):
             return self.data
         return None
 
-    def read_enum(self, e):
+    def read_enum(self, e) -> Optional[str]:
         if isinstance(self.data, str):
             return self.data
         return None
 
-    def read_list(self):
+    def read_list(self) -> Iterator["JSONLDDecoder"]:
         if self.is_list():
             for v in self.data:
                 yield self.__class__(v)
         else:
             yield self
 
-    def is_list(self):
+    def is_list(self) -> bool:
         return isinstance(self.data, (list, tuple, set))
 
     def __get_value(self, *keys):
@@ -1550,14 +1714,17 @@ class JSONLDDecoder(Decoder):
         return None
 
     @contextmanager
-    def read_property(self, key):
+    def read_property(self, key) -> Iterator[Optional["JSONLDDecoder"]]:
         v = self.__get_value(key)
         if v is not None:
             yield self.__class__(v)
         else:
             yield None
 
-    def object_keys(self):
+    def is_object(self) -> bool:
+        return isinstance(self.data, dict)
+
+    def object_keys(self) -> Iterator[str]:
         for key in self.data.keys():
             if key in ("@type", "type"):
                 continue
@@ -1565,19 +1732,19 @@ class JSONLDDecoder(Decoder):
                 continue
             yield key
 
-    def read_object(self):
+    def read_object(self) -> Tuple[Any, "JSONLDDecoder"]:
         typ = self.__get_value("@type", "type")
         if typ is not None:
             return typ, self
 
         return None, self
 
-    def read_object_id(self, alias=None):
+    def read_object_id(self, alias=None) -> Optional[Any]:
         return self.__get_value(alias, "@id")
 
 
 class JSONLDDeserializer(object):
-    def deserialize_data(self, data, objectset: SHACLObjectSet):
+    def deserialize_data(self, data, objectset: SHACLObjectSet) -> None:
         if "@graph" in data:
             h = JSONLDDecoder(data["@graph"], True)
         else:
@@ -1585,23 +1752,23 @@ class JSONLDDeserializer(object):
 
         objectset.decode(h)
 
-    def read(self, f, objectset: SHACLObjectSet):
+    def read(self, f, objectset: SHACLObjectSet) -> None:
         data = json.load(f)
         self.deserialize_data(data, objectset)
 
 
 class Encoder(ABC):
     @abstractmethod
-    def write_string(self, v):
+    def write_string(self, v) -> None:
         """
         Write a string value
 
         Encodes the value as a string in the output
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_string method")
 
     @abstractmethod
-    def write_datetime(self, v):
+    def write_datetime(self, v) -> None:
         """
         Write a date & time string
 
@@ -1609,19 +1776,19 @@ class Encoder(ABC):
 
         Note: The provided string is already correctly encoded as an ISO datetime
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_datetime method")
 
     @abstractmethod
-    def write_integer(self, v):
+    def write_integer(self, v) -> None:
         """
         Write an integer value
 
         Encodes the value as an integer in the output
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_integer method")
 
     @abstractmethod
-    def write_iri(self, v, compact=None):
+    def write_iri(self, v, compact=None) -> None:
         """
         Write IRI
 
@@ -1630,10 +1797,10 @@ class Encoder(ABC):
         the serialization supports compacted IRIs, it should be preferred to
         the full IRI
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_iri method")
 
     @abstractmethod
-    def write_enum(self, v, e, compact=None):
+    def write_enum(self, v, e, compact=None) -> None:
         """
         Write enum value IRI
 
@@ -1641,29 +1808,29 @@ class Encoder(ABC):
         qualified IRI. If `compact` is provided and the serialization supports
         compacted IRIs, it should be preferred to the full IRI.
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_enum method")
 
     @abstractmethod
-    def write_bool(self, v):
+    def write_bool(self, v) -> None:
         """
         Write boolean
 
         Encodes the value as a boolean in the output
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_bool method")
 
     @abstractmethod
-    def write_float(self, v):
+    def write_float(self, v) -> None:
         """
         Write float
 
         Encodes the value as a floating point number in the output
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_float method")
 
     @abstractmethod
     @contextmanager
-    def write_object(self, o, _id, needs_id):
+    def write_object(self, o: SHACLObject, _id: str, needs_id: bool):
         """
         Write object
 
@@ -1681,11 +1848,11 @@ class Encoder(ABC):
 
         Properties will be written the object using `write_property`
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_object method")
 
     @abstractmethod
     @contextmanager
-    def write_property(self, iri, compact=None):
+    def write_property(self, iri: str, compact: Optional[str] = None):
         """
         Write object property
 
@@ -1696,7 +1863,7 @@ class Encoder(ABC):
         the serialization supports compacted IRIs, it should be preferred to
         the full IRI.
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_property method")
 
     @abstractmethod
     @contextmanager
@@ -1709,7 +1876,7 @@ class Encoder(ABC):
 
         Each item of the list will be added using `write_list_item`
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_list method")
 
     @abstractmethod
     @contextmanager
@@ -1720,7 +1887,7 @@ class Encoder(ABC):
         A context manager that yields an `Encoder` that can be used to encode
         the value for a list item
         """
-        pass
+        raise NotImplementedError("Subclasses must implement write_list_item method")
 
 
 class JSONLDEncoder(Encoder):
@@ -1749,14 +1916,14 @@ class JSONLDEncoder(Encoder):
         self.data = str(v)
 
     @contextmanager
-    def write_property(self, iri, compact=None):
+    def write_property(self, iri: str, compact: Optional[str] = None):
         s = self.__class__(None)
         yield s
         if s.data is not None:
-            self.data[compact or iri] = s.data
+            self.data[compact or iri] = s.data  # type: ignore # within write_object() context, self.data is always dict or None
 
     @contextmanager
-    def write_object(self, o, _id, needs_id):
+    def write_object(self, o: SHACLObject, _id: str, needs_id: bool):
         self.data = {
             "type": o.COMPACT_TYPE or o.TYPE,
         }
@@ -1776,7 +1943,7 @@ class JSONLDEncoder(Encoder):
         s = self.__class__(None)
         yield s
         if s.data is not None:
-            self.data.append(s.data)
+            self.data.append(s.data)  # type: ignore # within write_list() context, self.data is always list or None
 
 
 class JSONLDSerializer(object):
@@ -1786,11 +1953,11 @@ class JSONLDSerializer(object):
     def serialize_data(
         self,
         objectset: SHACLObjectSet,
-        force_at_graph=False,
+        force_at_graph: bool = False,
     ):
         h = JSONLDEncoder()
         objectset.encode(h, force_at_graph)
-        data = {}
+        data: Dict[str, Any] = {}
         if len(CONTEXT_URLS) == 1:
             data["@context"] = CONTEXT_URLS[0]
         elif CONTEXT_URLS:
@@ -1798,9 +1965,11 @@ class JSONLDSerializer(object):
 
         if isinstance(h.data, list):
             data["@graph"] = h.data
-        else:
+        elif isinstance(h.data, dict):
             for k, v in h.data.items():
                 data[k] = v
+        # elif h.data is not None: # str, int, float, bool
+        #    data["value"] = h.data
 
         return data
 
@@ -1808,13 +1977,16 @@ class JSONLDSerializer(object):
         self,
         objectset: SHACLObjectSet,
         f,
-        force_at_graph=False,
+        force_at_graph: bool = False,
         **kwargs,
     ):
         """
         Write a SHACLObjectSet to a JSON LD file
 
         If force_at_graph is True, a @graph node will always be written
+
+        Note that f should be a file-like object that supports the `write`
+        method, and that opens in binary mode (e.g. `open("file.json", "wb")`).
         """
         data = self.serialize_data(objectset, force_at_graph)
 
@@ -1822,9 +1994,9 @@ class JSONLDSerializer(object):
 
         sha1 = hashlib.sha1()
         for chunk in json.JSONEncoder(**args).iterencode(data):
-            chunk = chunk.encode("utf-8")
-            f.write(chunk)
-            sha1.update(chunk)
+            chunk_bytes = chunk.encode("utf-8")
+            f.write(chunk_bytes)
+            sha1.update(chunk_bytes)
 
         return sha1.hexdigest()
 
@@ -1870,7 +2042,7 @@ class JSONLDInlineEncoder(Encoder):
         self.write(json.dumps(str(v)))
 
     @contextmanager
-    def write_property(self, iri, compact=None):
+    def write_property(self, iri: str, compact: Optional[str] = None):
         self._write_comma()
         self.write_string(compact or iri)
         self.write(":")
@@ -1878,7 +2050,7 @@ class JSONLDInlineEncoder(Encoder):
         self.comma = True
 
     @contextmanager
-    def write_object(self, o, _id, needs_id):
+    def write_object(self, o: SHACLObject, _id: str, needs_id: bool):
         self._write_comma()
 
         self.write("{")
@@ -1920,7 +2092,7 @@ class JSONLDInlineSerializer(object):
         self,
         objectset: SHACLObjectSet,
         f,
-        force_at_graph=False,
+        force_at_graph: bool = False,
     ):
         """
         Write a SHACLObjectSet to a JSON LD file
@@ -1946,13 +2118,256 @@ class JSONLDInlineSerializer(object):
         return sha1.hexdigest()
 
 
-def print_tree(objects, all_fields=False):
+try:
+    import rdflib
+    import rdflib.term
+    from rdflib.namespace import RDF
+
+    class RDFDecoder(Decoder):
+        def __init__(
+            self,
+            graph: rdflib.Graph,
+            subject: Optional[rdflib.term.Node] = None,
+            predicate: Optional[rdflib.term.Node] = None,
+            value: Optional[rdflib.term.Node] = None,
+        ):
+            self.graph = graph
+            self.subject = subject
+            self.predicate = predicate
+            self.value = value
+
+        def __read_node(self):
+            if self.value is not None:
+                return self.value
+            if self.predicate is None:
+                return None
+            return self.graph.value(self.subject, self.predicate)
+
+        def read_value(self) -> Optional[Any]:
+            v = self.__read_node()
+            if isinstance(v, rdflib.term.Literal):
+                return v.toPython()
+            return None
+
+        def read_string(self) -> Optional[str]:
+            v = self.read_value()
+            if isinstance(v, str):
+                return v
+            return None
+
+        def read_datetime(self) -> Optional[str]:
+            return self.read_value()
+
+        def read_integer(self) -> Optional[int]:
+            v = self.read_value()
+            if isinstance(v, (int, decimal.Decimal)):
+                return int(v)
+            return None
+
+        def read_bool(self) -> Optional[bool]:
+            v = self.read_value()
+            if isinstance(v, bool):
+                return v
+            return None
+
+        def read_float(self) -> Optional[float]:
+            v = self.read_value()
+            if isinstance(v, (int, float, str, decimal.Decimal)):
+                return float(v)
+            return None
+
+        def read_iri(self) -> Optional[str]:
+            v = self.__read_node()
+            if isinstance(v, rdflib.term.URIRef):
+                return v.toPython()
+            elif isinstance(v, rdflib.term.Literal):
+                v = v.toPython()
+                if isinstance(v, str):
+                    return v
+            elif isinstance(v, rdflib.term.BNode):
+                return v.n3()
+            return None
+
+        def read_enum(self, e) -> Optional[str]:
+            v = self.__read_node()
+            if isinstance(v, rdflib.term.URIRef):
+                return v.toPython()
+            return None
+
+        def read_list(self) -> Iterator["RDFDecoder"]:
+            if not self.subject:
+                blank_nodes = set()
+                for s in self.graph.subjects(unique=True):
+                    # type: ignore # RDF.type is dynamic
+                    if (s, RDF.type, None) not in self.graph:
+                        continue
+
+                    if isinstance(s, rdflib.term.BNode):
+                        blank_nodes.add(s)
+                        continue
+                    yield self.__class__(self.graph, s)
+
+                for s in blank_nodes:
+                    yield self.__class__(self.graph, s)
+            else:
+                for o in self.graph.objects(self.subject, self.predicate):
+                    # type: ignore # RDF.type is dynamic
+                    if (o, RDF.type, None) in self.graph:
+                        yield self.__class__(self.graph, o)
+                    else:
+                        yield self.__class__(
+                            self.graph,
+                            self.subject,
+                            self.predicate,
+                            o,
+                        )
+
+        def is_list(self) -> bool:
+            if not self.subject:
+                return True
+            if self.value is not None:
+                return False
+            return len(list(self.graph.objects(self.subject, self.predicate))) > 1
+
+        @contextmanager
+        def read_property(self, key) -> Iterator[Optional["RDFDecoder"]]:
+            if key == "@id":
+                yield self.__class__(self.graph, value=self.subject)
+            else:
+                yield self.__class__(self.graph, self.subject, rdflib.term.URIRef(key))
+
+        def is_object(self) -> bool:
+            n = self.__read_node() or self.subject
+            # type: ignore # RDF.type is dynamic
+            return (n, RDF.type, None) in self.graph
+
+        def object_keys(self) -> Iterator[str]:
+            for p in self.graph.predicates(self.subject, unique=True):
+                # type: ignore # RDF.type is dynamic
+                if p == RDF.type:
+                    continue
+
+                if not isinstance(p, rdflib.term.IdentifiedNode):
+                    raise TypeError(f"Predicate is of unknown type {type(p)}")
+
+                yield p.toPython()
+
+        def read_object(self) -> Tuple[Any, "RDFDecoder"]:
+            s = self.__read_node()
+            if s is None:
+                s = self.subject
+
+            # type: ignore # RDF.type is dynamic
+            typ = self.graph.value(s, RDF.type)
+            if typ is None:
+                return None, self
+
+            if not isinstance(typ, rdflib.term.IdentifiedNode):
+                raise TypeError(f"Type value is of unknown type {type(typ)}")
+
+            return typ.toPython(), self.__class__(self.graph, s)
+
+        def read_object_id(self, alias=None) -> Optional[Any]:
+            if isinstance(self.subject, rdflib.term.BNode):
+                return self.subject.n3()
+            if not isinstance(self.subject, rdflib.term.IdentifiedNode):
+                raise TypeError(f"Subject is of unknown type {type(self.subject)}")
+            return self.subject.toPython()
+
+    class RDFDeserializer(object):
+        def read(self, graph: rdflib.Graph, objset: SHACLObjectSet) -> None:
+            d = RDFDecoder(graph)
+            objset.decode(d)
+            objset.inline_blank_nodes()
+
+    class RDFEncoder(Encoder):
+        def __init__(
+            self,
+            graph: rdflib.Graph,
+            subject: Optional[rdflib.term.Node] = None,
+            predicate: Optional[rdflib.term.Node] = None,
+        ):
+            self.graph = graph
+            self.subject = subject
+            self.predicate = predicate
+
+        def __add_literal(self, v):
+            if self.subject is None or self.predicate is None:
+                raise TypeError()
+            self.graph.add((self.subject, self.predicate, rdflib.Literal(v)))
+
+        def __add_uriref(self, v):
+            if self.subject is None or self.predicate is None:
+                raise TypeError()
+            self.graph.add((self.subject, self.predicate, rdflib.URIRef(v)))
+
+        def write_string(self, v):
+            self.__add_literal(v)
+
+        def write_datetime(self, v):
+            self.__add_literal(v)
+
+        def write_integer(self, v):
+            self.__add_literal(v)
+
+        def write_iri(self, v, compact=None):
+            self.__add_uriref(v)
+
+        def write_enum(self, v, e, compact=None):
+            self.__add_uriref(v)
+
+        def write_bool(self, v):
+            self.__add_literal(v)
+
+        def write_float(self, v):
+            self.__add_literal(v)
+
+        @contextmanager
+        def write_property(self, iri: str, compact: Optional[str] = None):
+            yield self.__class__(self.graph, self.subject, rdflib.URIRef(iri))
+
+        @contextmanager
+        def write_object(self, o, _id, needs_id: bool):
+            obj: rdflib.term.Node
+            if _id.startswith("_:"):
+                obj = rdflib.BNode(_id[2:])
+            else:
+                obj = rdflib.URIRef(_id)
+
+            if self.subject is not None:
+                if self.predicate is None:
+                    raise TypeError()
+                self.graph.add((self.subject, self.predicate, obj))
+            self.graph.add((obj, RDF.type, rdflib.URIRef(o.TYPE)))  # type: ignore # RDF.type is dynamic
+            yield self.__class__(self.graph, obj)
+
+        @contextmanager
+        def write_list(self):
+            yield self
+
+        @contextmanager
+        def write_list_item(self):
+            yield self
+
+    class RDFSerializer(object):
+        def write(self, objset: SHACLObjectSet, g: rdflib.Graph):
+            """
+            Write a SHACLObjectSet to an RDF graph
+            """
+            e = RDFEncoder(g)
+            objset.encode(e)
+
+except ImportError:
+    pass
+
+
+def print_tree(objects, all_fields: bool = False) -> None:
     """
     Print object tree
     """
     seen = set()
 
-    def callback(value, path):
+    def callback(value, path: List[str]):
         nonlocal seen
 
         s = ("  " * (len(path) - 1)) + f"{path[-1]}"
@@ -1986,7 +2401,7 @@ def print_tree(objects, all_fields=False):
 """Format Guard"""
 
 
-CONTEXT_URLS = [
+CONTEXT_URLS: List[str] = [
     "https://spdx.org/rdf/3.0.1/spdx-context.jsonld",
 ]
 
@@ -1998,7 +2413,7 @@ CONTEXT_URLS = [
 class ai_EnergyConsumption(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2039,7 +2454,7 @@ class ai_EnergyConsumption(SHACLObject):
 class ai_EnergyConsumptionDescription(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2074,7 +2489,7 @@ class ai_EnergyConsumptionDescription(SHACLObject):
 class ai_EnergyUnitType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "kilowattHour": "https://spdx.org/rdf/3.0.1/terms/AI/EnergyUnitType/kilowattHour",
         "megajoule": "https://spdx.org/rdf/3.0.1/terms/AI/EnergyUnitType/megajoule",
         "other": "https://spdx.org/rdf/3.0.1/terms/AI/EnergyUnitType/other",
@@ -2092,7 +2507,7 @@ class ai_EnergyUnitType(SHACLObject):
 class ai_SafetyRiskAssessmentType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "high": "https://spdx.org/rdf/3.0.1/terms/AI/SafetyRiskAssessmentType/high",
         "low": "https://spdx.org/rdf/3.0.1/terms/AI/SafetyRiskAssessmentType/low",
         "medium": "https://spdx.org/rdf/3.0.1/terms/AI/SafetyRiskAssessmentType/medium",
@@ -2113,7 +2528,7 @@ class ai_SafetyRiskAssessmentType(SHACLObject):
 class AnnotationType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "other": "https://spdx.org/rdf/3.0.1/terms/Core/AnnotationType/other",
         "review": "https://spdx.org/rdf/3.0.1/terms/Core/AnnotationType/review",
     }
@@ -2128,7 +2543,7 @@ class AnnotationType(SHACLObject):
 class CreationInfo(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2188,7 +2603,7 @@ class CreationInfo(SHACLObject):
 class DictionaryEntry(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2219,7 +2634,7 @@ class Element(SHACLObject):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2310,7 +2725,7 @@ class ElementCollection(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2371,7 +2786,7 @@ class ElementCollection(Element):
 class ExternalIdentifier(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2439,7 +2854,7 @@ class ExternalIdentifier(SHACLObject):
 class ExternalIdentifierType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "cpe22": "https://spdx.org/rdf/3.0.1/terms/Core/ExternalIdentifierType/cpe22",
         "cpe23": "https://spdx.org/rdf/3.0.1/terms/Core/ExternalIdentifierType/cpe23",
         "cve": "https://spdx.org/rdf/3.0.1/terms/Core/ExternalIdentifierType/cve",
@@ -2482,7 +2897,7 @@ class ExternalIdentifierType(SHACLObject):
 class ExternalMap(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2531,7 +2946,7 @@ class ExternalMap(SHACLObject):
 class ExternalRef(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2624,7 +3039,7 @@ class ExternalRef(SHACLObject):
 class ExternalRefType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "altDownloadLocation": "https://spdx.org/rdf/3.0.1/terms/Core/ExternalRefType/altDownloadLocation",
         "altWebPage": "https://spdx.org/rdf/3.0.1/terms/Core/ExternalRefType/altWebPage",
         "binaryArtifact": "https://spdx.org/rdf/3.0.1/terms/Core/ExternalRefType/binaryArtifact",
@@ -2771,7 +3186,7 @@ class ExternalRefType(SHACLObject):
 class HashAlgorithm(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "adler32": "https://spdx.org/rdf/3.0.1/terms/Core/HashAlgorithm/adler32",
         "blake2b256": "https://spdx.org/rdf/3.0.1/terms/Core/HashAlgorithm/blake2b256",
         "blake2b384": "https://spdx.org/rdf/3.0.1/terms/Core/HashAlgorithm/blake2b384",
@@ -2848,7 +3263,7 @@ class IndividualElement(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "NoAssertionElement": "https://spdx.org/rdf/3.0.1/terms/Core/NoAssertionElement",
         "NoneElement": "https://spdx.org/rdf/3.0.1/terms/Core/NoneElement",
     }
@@ -2865,7 +3280,7 @@ class IndividualElement(Element):
 class IntegrityMethod(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2887,7 +3302,7 @@ class IntegrityMethod(SHACLObject):
 class LifecycleScopeType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "build": "https://spdx.org/rdf/3.0.1/terms/Core/LifecycleScopeType/build",
         "design": "https://spdx.org/rdf/3.0.1/terms/Core/LifecycleScopeType/design",
         "development": "https://spdx.org/rdf/3.0.1/terms/Core/LifecycleScopeType/development",
@@ -2914,7 +3329,7 @@ class LifecycleScopeType(SHACLObject):
 class NamespaceMap(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -2946,7 +3361,7 @@ class NamespaceMap(SHACLObject):
 class PackageVerificationCode(IntegrityMethod):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -3009,7 +3424,7 @@ class PackageVerificationCode(IntegrityMethod):
 class PositiveIntegerRange(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -3040,7 +3455,7 @@ class PositiveIntegerRange(SHACLObject):
 class PresenceType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "no": "https://spdx.org/rdf/3.0.1/terms/Core/PresenceType/no",
         "noAssertion": "https://spdx.org/rdf/3.0.1/terms/Core/PresenceType/noAssertion",
         "yes": "https://spdx.org/rdf/3.0.1/terms/Core/PresenceType/yes",
@@ -3058,7 +3473,7 @@ class PresenceType(SHACLObject):
 class ProfileIdentifierType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "ai": "https://spdx.org/rdf/3.0.1/terms/Core/ProfileIdentifierType/ai",
         "build": "https://spdx.org/rdf/3.0.1/terms/Core/ProfileIdentifierType/build",
         "core": "https://spdx.org/rdf/3.0.1/terms/Core/ProfileIdentifierType/core",
@@ -3098,7 +3513,7 @@ class Relationship(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -3238,7 +3653,7 @@ class Relationship(Element):
 class RelationshipCompleteness(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "complete": "https://spdx.org/rdf/3.0.1/terms/Core/RelationshipCompleteness/complete",
         "incomplete": "https://spdx.org/rdf/3.0.1/terms/Core/RelationshipCompleteness/incomplete",
         "noAssertion": "https://spdx.org/rdf/3.0.1/terms/Core/RelationshipCompleteness/noAssertion",
@@ -3256,7 +3671,7 @@ class RelationshipCompleteness(SHACLObject):
 class RelationshipType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "affects": "https://spdx.org/rdf/3.0.1/terms/Core/RelationshipType/affects",
         "amendedBy": "https://spdx.org/rdf/3.0.1/terms/Core/RelationshipType/amendedBy",
         "ancestorOf": "https://spdx.org/rdf/3.0.1/terms/Core/RelationshipType/ancestorOf",
@@ -3443,7 +3858,7 @@ class SpdxDocument(ElementCollection):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -3484,7 +3899,7 @@ class SpdxDocument(ElementCollection):
 class SupportType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "deployed": "https://spdx.org/rdf/3.0.1/terms/Core/SupportType/deployed",
         "development": "https://spdx.org/rdf/3.0.1/terms/Core/SupportType/development",
         "endOfSupport": "https://spdx.org/rdf/3.0.1/terms/Core/SupportType/endOfSupport",
@@ -3515,7 +3930,7 @@ class Tool(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -3524,7 +3939,7 @@ class Tool(Element):
 class dataset_ConfidentialityLevelType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "amber": "https://spdx.org/rdf/3.0.1/terms/Dataset/ConfidentialityLevelType/amber",
         "clear": "https://spdx.org/rdf/3.0.1/terms/Dataset/ConfidentialityLevelType/clear",
         "green": "https://spdx.org/rdf/3.0.1/terms/Dataset/ConfidentialityLevelType/green",
@@ -3545,7 +3960,7 @@ class dataset_ConfidentialityLevelType(SHACLObject):
 class dataset_DatasetAvailabilityType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "clickthrough": "https://spdx.org/rdf/3.0.1/terms/Dataset/DatasetAvailabilityType/clickthrough",
         "directDownload": "https://spdx.org/rdf/3.0.1/terms/Dataset/DatasetAvailabilityType/directDownload",
         "query": "https://spdx.org/rdf/3.0.1/terms/Dataset/DatasetAvailabilityType/query",
@@ -3569,7 +3984,7 @@ class dataset_DatasetAvailabilityType(SHACLObject):
 class dataset_DatasetType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "audio": "https://spdx.org/rdf/3.0.1/terms/Dataset/DatasetType/audio",
         "categorical": "https://spdx.org/rdf/3.0.1/terms/Dataset/DatasetType/categorical",
         "graph": "https://spdx.org/rdf/3.0.1/terms/Dataset/DatasetType/graph",
@@ -3622,7 +4037,7 @@ class expandedlicensing_LicenseAddition(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -3687,7 +4102,7 @@ class expandedlicensing_ListedLicenseException(expandedlicensing_LicenseAddition
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -3718,7 +4133,7 @@ class expandedlicensing_ListedLicenseException(expandedlicensing_LicenseAddition
 class extension_CdxPropertyEntry(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -3748,7 +4163,7 @@ class extension_CdxPropertyEntry(SHACLObject):
 class extension_Extension(SHACLExtensibleObject, SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -3757,7 +4172,7 @@ class extension_Extension(SHACLExtensibleObject, SHACLObject):
 class security_CvssSeverityType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "critical": "https://spdx.org/rdf/3.0.1/terms/Security/CvssSeverityType/critical",
         "high": "https://spdx.org/rdf/3.0.1/terms/Security/CvssSeverityType/high",
         "low": "https://spdx.org/rdf/3.0.1/terms/Security/CvssSeverityType/low",
@@ -3781,7 +4196,7 @@ class security_CvssSeverityType(SHACLObject):
 class security_ExploitCatalogType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "kev": "https://spdx.org/rdf/3.0.1/terms/Security/ExploitCatalogType/kev",
         "other": "https://spdx.org/rdf/3.0.1/terms/Security/ExploitCatalogType/other",
     }
@@ -3796,7 +4211,7 @@ class security_ExploitCatalogType(SHACLObject):
 class security_SsvcDecisionType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "act": "https://spdx.org/rdf/3.0.1/terms/Security/SsvcDecisionType/act",
         "attend": "https://spdx.org/rdf/3.0.1/terms/Security/SsvcDecisionType/attend",
         "track": "https://spdx.org/rdf/3.0.1/terms/Security/SsvcDecisionType/track",
@@ -3817,7 +4232,7 @@ class security_SsvcDecisionType(SHACLObject):
 class security_VexJustificationType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "componentNotPresent": "https://spdx.org/rdf/3.0.1/terms/Security/VexJustificationType/componentNotPresent",
         "inlineMitigationsAlreadyExist": "https://spdx.org/rdf/3.0.1/terms/Security/VexJustificationType/inlineMitigationsAlreadyExist",
         "vulnerableCodeCannotBeControlledByAdversary": "https://spdx.org/rdf/3.0.1/terms/Security/VexJustificationType/vulnerableCodeCannotBeControlledByAdversary",
@@ -3842,7 +4257,7 @@ class security_VulnAssessmentRelationship(Relationship):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -3900,7 +4315,7 @@ class simplelicensing_AnyLicenseInfo(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -3910,7 +4325,7 @@ class simplelicensing_LicenseExpression(simplelicensing_AnyLicenseInfo):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -3950,7 +4365,7 @@ class simplelicensing_SimpleLicensingText(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -3972,7 +4387,7 @@ class simplelicensing_SimpleLicensingText(Element):
 class software_ContentIdentifier(IntegrityMethod):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4006,7 +4421,7 @@ class software_ContentIdentifier(IntegrityMethod):
 class software_ContentIdentifierType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "gitoid": "https://spdx.org/rdf/3.0.1/terms/Software/ContentIdentifierType/gitoid",
         "swhid": "https://spdx.org/rdf/3.0.1/terms/Software/ContentIdentifierType/swhid",
     }
@@ -4021,7 +4436,7 @@ class software_ContentIdentifierType(SHACLObject):
 class software_FileKindType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "directory": "https://spdx.org/rdf/3.0.1/terms/Software/FileKindType/directory",
         "file": "https://spdx.org/rdf/3.0.1/terms/Software/FileKindType/file",
     }
@@ -4037,7 +4452,7 @@ class software_FileKindType(SHACLObject):
 class software_SbomType(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "analyzed": "https://spdx.org/rdf/3.0.1/terms/Software/SbomType/analyzed",
         "build": "https://spdx.org/rdf/3.0.1/terms/Software/SbomType/build",
         "deployed": "https://spdx.org/rdf/3.0.1/terms/Software/SbomType/deployed",
@@ -4064,7 +4479,7 @@ class software_SbomType(SHACLObject):
 class software_SoftwarePurpose(SHACLObject):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "application": "https://spdx.org/rdf/3.0.1/terms/Software/SoftwarePurpose/application",
         "archive": "https://spdx.org/rdf/3.0.1/terms/Software/SoftwarePurpose/archive",
         "bom": "https://spdx.org/rdf/3.0.1/terms/Software/SoftwarePurpose/bom",
@@ -4161,7 +4576,7 @@ class build_Build(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4251,7 +4666,7 @@ class Agent(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -4261,7 +4676,7 @@ class Annotation(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4318,7 +4733,7 @@ class Artifact(Element):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4402,7 +4817,7 @@ class Bundle(ElementCollection):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4424,7 +4839,7 @@ class Bundle(ElementCollection):
 class Hash(IntegrityMethod):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4479,7 +4894,7 @@ class LifecycleScopedRelationship(Relationship):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4508,7 +4923,7 @@ class Organization(Agent):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "SpdxOrganization": "https://spdx.org/rdf/3.0.1/terms/Core/SpdxOrganization",
     }
     # An Organization representing the SPDX Project.
@@ -4521,7 +4936,7 @@ class Person(Agent):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -4531,7 +4946,7 @@ class SoftwareAgent(Agent):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -4542,7 +4957,7 @@ class expandedlicensing_ConjunctiveLicenseSet(simplelicensing_AnyLicenseInfo):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4568,7 +4983,7 @@ class expandedlicensing_CustomLicenseAddition(expandedlicensing_LicenseAddition)
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -4579,7 +4994,7 @@ class expandedlicensing_DisjunctiveLicenseSet(simplelicensing_AnyLicenseInfo):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4605,7 +5020,7 @@ class expandedlicensing_ExtendableLicense(simplelicensing_AnyLicenseInfo):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -4616,7 +5031,7 @@ class expandedlicensing_IndividualLicensingInfo(simplelicensing_AnyLicenseInfo):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
         "NoAssertionLicense": "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/NoAssertionLicense",
         "NoneLicense": "https://spdx.org/rdf/3.0.1/terms/ExpandedLicensing/NoneLicense",
     }
@@ -4634,7 +5049,7 @@ class expandedlicensing_License(expandedlicensing_ExtendableLicense):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4727,7 +5142,7 @@ class expandedlicensing_ListedLicense(expandedlicensing_License):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4760,7 +5175,7 @@ class expandedlicensing_OrLaterOperator(expandedlicensing_ExtendableLicense):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4784,7 +5199,7 @@ class expandedlicensing_WithAdditionOperator(simplelicensing_AnyLicenseInfo):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4815,7 +5230,7 @@ class expandedlicensing_WithAdditionOperator(simplelicensing_AnyLicenseInfo):
 class extension_CdxPropertiesExtension(extension_Extension):
     NODE_KIND = NodeKind.BlankNodeOrIRI
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4838,7 +5253,7 @@ class security_CvssV2VulnAssessmentRelationship(security_VulnAssessmentRelations
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4870,7 +5285,7 @@ class security_CvssV3VulnAssessmentRelationship(security_VulnAssessmentRelations
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4917,7 +5332,7 @@ class security_CvssV4VulnAssessmentRelationship(security_VulnAssessmentRelations
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4964,7 +5379,7 @@ class security_EpssVulnAssessmentRelationship(security_VulnAssessmentRelationshi
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -4996,7 +5411,7 @@ class security_ExploitCatalogVulnAssessmentRelationship(security_VulnAssessmentR
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5040,7 +5455,7 @@ class security_SsvcVulnAssessmentRelationship(security_VulnAssessmentRelationshi
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5069,7 +5484,7 @@ class security_VexVulnAssessmentRelationship(security_VulnAssessmentRelationship
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5099,7 +5514,7 @@ class security_Vulnerability(Artifact):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5137,7 +5552,7 @@ class software_SoftwareArtifact(Artifact):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5255,7 +5670,7 @@ class Bom(Bundle):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -5265,7 +5680,7 @@ class expandedlicensing_CustomLicense(expandedlicensing_License):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -5276,7 +5691,7 @@ class security_VexAffectedVulnAssessmentRelationship(security_VexVulnAssessmentR
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5310,7 +5725,7 @@ class security_VexFixedVulnAssessmentRelationship(security_VexVulnAssessmentRela
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -5321,7 +5736,7 @@ class security_VexNotAffectedVulnAssessmentRelationship(security_VexVulnAssessme
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5370,7 +5785,7 @@ class security_VexUnderInvestigationVulnAssessmentRelationship(security_VexVulnA
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
 
@@ -5380,7 +5795,7 @@ class software_File(software_SoftwareArtifact):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5414,7 +5829,7 @@ class software_Package(software_SoftwareArtifact):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5472,7 +5887,7 @@ class software_Sbom(Bom):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5501,7 +5916,7 @@ class software_Snippet(software_SoftwareArtifact):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5542,7 +5957,7 @@ class ai_AIPackage(software_Package):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod
@@ -5695,7 +6110,7 @@ class dataset_DatasetPackage(software_Package):
     NODE_KIND = NodeKind.IRI
     ID_ALIAS = "spdxId"
     IS_DEPRECATED = False
-    NAMED_INDIVIDUALS = {
+    NAMED_INDIVIDUALS: Dict[str, str] = {
     }
 
     @classmethod