scim2-models 0.3.7__tar.gz → 0.4.0__tar.gz

{scim2_models-0.3.7 → scim2_models-0.4.0}/.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 ---
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.12.3'
+    rev: 'v0.12.4'
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]

{scim2_models-0.3.7 → scim2_models-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scim2-models
-Version: 0.3.7
+Version: 0.4.0
 Summary: SCIM2 models serialization and validation with pydantic
 Project-URL: documentation, https://scim2-models.readthedocs.io
 Project-URL: repository, https://github.com/python-scim/scim2-models

{scim2_models-0.3.7 → scim2_models-0.4.0}/doc/changelog.rst

@@ -1,6 +1,20 @@
 Changelog
 =========
 
+[0.4.0] - 2025-07-23
+--------------------
+
+Added
+^^^^^
+- Proper path validation for :attr:`~scim2_models.SearchRequest.attributes`, :attr:`~scim2_models.SearchRequest.excluded_attributes` and :attr:`~scim2_models.SearchRequest.sort_by`.
+- Implement :meth:`~scim2_models.PatchOp.patch`
+
+Fixed
+^^^^^
+- When using ``model_dump``, ignore invalid ``attributes`` and ``excluded_attributes``
+  as suggested by RFC7644.
+- Don't normalize attributes typed with :data:`Any`. :issue:`20`
+
 [0.3.7] - 2025-07-17
 --------------------
 

{scim2_models-0.3.7 → scim2_models-0.4.0}/doc/tutorial.rst

@@ -204,9 +204,9 @@ If a response resource type cannot be found, a ``pydantic.ValidationError`` will
     >>> response = ListResponse[Union[User, Group]].model_validate(payload)
     >>> user, group = response.resources
     >>> type(user)
-    <class 'scim2_models.rfc7643.user.User'>
+    <class 'scim2_models.resources.user.User'>
     >>> type(group)
-    <class 'scim2_models.rfc7643.group.Group'>
+    <class 'scim2_models.resources.group.Group'>
 
 
 Schema extensions
@@ -403,9 +403,49 @@ This can be used by client applications that intends to dynamically discover ser
           :language: json
           :caption: schema-group.json
 
-Bulk and Patch operations
-=========================
+Patch operations
+================
+
+:class:`~scim2_models.PatchOp` allows you to apply patch operations to modify SCIM resources.
+The :meth:`~scim2_models.PatchOp.patch` method applies operations in sequence and returns whether the resource was modified. The return code is a boolean indicating whether the object have been modified by the operations.
+
+.. note::
+   :class:`~scim2_models.PatchOp` takes a type parameter that should be the class of the resource
+   that is expected to be patched.
+
+.. code-block:: python
+
+    >>> from scim2_models import User, PatchOp, PatchOperation
+    >>> user = User(user_name="john.doe", nick_name="Johnny")
+
+    >>> payload = {
+    ...   "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
+    ...   "Operations": [
+    ...     {"op": "replace", "path": "nickName", "value": "John" },
+    ...     {"op": "add", "path": "emails", "value": [{"value": "john@example.com"}]},
+    ...   ]
+    ... }
+    >>> patch = PatchOp[User].model_validate(
+    ...     payload, scim_ctx=Context.RESOURCE_PATCH_REQUEST
+    ... )
+
+    >>> modified = patch.patch(user)
+    >>> print(modified)
+    True
+    >>> print(user.nick_name)
+    John
+    >>> print(user.emails[0].value)
+    john@example.com
+
+.. warning::
+
+   Patch operations are validated in the :attr:`~scim2_models.Context.RESOURCE_PATCH_REQUEST`
+   context. Make sure to validate patch operations with the correct context to
+   ensure proper validation of mutability and required constraints.
+
+Bulk operations
+===============
 
 .. todo::
 
-   Bulk and Patch operations are not implemented yet, but any help is welcome!
+   Bulk operations are not implemented yet, but any help is welcome!

{scim2_models-0.3.7 → scim2_models-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "scim2-models"
-version = "0.3.7"
+version = "0.4.0"
 description = "SCIM2 models serialization and validation with pydantic"
 authors = [{name="Yaal Coop", email="contact@yaal.coop"}]
 license = {file = "LICENSE"}

scim2_models-0.4.0/scim2_models/__init__.py

@@ -0,0 +1,109 @@
+from .annotations import CaseExact
+from .annotations import Mutability
+from .annotations import Required
+from .annotations import Returned
+from .annotations import Uniqueness
+from .attributes import ComplexAttribute
+from .attributes import MultiValuedComplexAttribute
+from .base import BaseModel
+from .context import Context
+from .messages.bulk import BulkOperation
+from .messages.bulk import BulkRequest
+from .messages.bulk import BulkResponse
+from .messages.error import Error
+from .messages.list_response import ListResponse
+from .messages.message import Message
+from .messages.patch_op import PatchOp
+from .messages.patch_op import PatchOperation
+from .messages.search_request import SearchRequest
+from .reference import ExternalReference
+from .reference import Reference
+from .reference import URIReference
+from .resources.enterprise_user import EnterpriseUser
+from .resources.enterprise_user import Manager
+from .resources.group import Group
+from .resources.group import GroupMember
+from .resources.resource import AnyExtension
+from .resources.resource import AnyResource
+from .resources.resource import Extension
+from .resources.resource import Meta
+from .resources.resource import Resource
+from .resources.resource_type import ResourceType
+from .resources.resource_type import SchemaExtension
+from .resources.schema import Attribute
+from .resources.schema import Schema
+from .resources.service_provider_config import AuthenticationScheme
+from .resources.service_provider_config import Bulk
+from .resources.service_provider_config import ChangePassword
+from .resources.service_provider_config import ETag
+from .resources.service_provider_config import Filter
+from .resources.service_provider_config import Patch
+from .resources.service_provider_config import ServiceProviderConfig
+from .resources.service_provider_config import Sort
+from .resources.user import Address
+from .resources.user import Email
+from .resources.user import Entitlement
+from .resources.user import GroupMembership
+from .resources.user import Im
+from .resources.user import Name
+from .resources.user import PhoneNumber
+from .resources.user import Photo
+from .resources.user import Role
+from .resources.user import User
+from .resources.user import X509Certificate
+
+__all__ = [
+    "Address",
+    "AnyResource",
+    "AnyExtension",
+    "Attribute",
+    "AuthenticationScheme",
+    "BaseModel",
+    "Bulk",
+    "BulkOperation",
+    "BulkRequest",
+    "BulkResponse",
+    "CaseExact",
+    "ChangePassword",
+    "ComplexAttribute",
+    "Context",
+    "ETag",
+    "Email",
+    "EnterpriseUser",
+    "Entitlement",
+    "Error",
+    "ExternalReference",
+    "Extension",
+    "Filter",
+    "Group",
+    "GroupMember",
+    "GroupMembership",
+    "Im",
+    "ListResponse",
+    "Manager",
+    "Message",
+    "Meta",
+    "Mutability",
+    "MultiValuedComplexAttribute",
+    "Name",
+    "Patch",
+    "PatchOp",
+    "PatchOperation",
+    "PhoneNumber",
+    "Photo",
+    "Reference",
+    "Required",
+    "Resource",
+    "ResourceType",
+    "Returned",
+    "Role",
+    "Schema",
+    "SchemaExtension",
+    "SearchRequest",
+    "ServiceProviderConfig",
+    "Sort",
+    "Uniqueness",
+    "URIReference",
+    "User",
+    "X509Certificate",
+]

{scim2_models-0.3.7 → scim2_models-0.4.0}/scim2_models/attributes.py

@@ -16,7 +16,7 @@ from .reference import Reference
 class ComplexAttribute(BaseModel):
     """A complex attribute as defined in :rfc:`RFC7643 §2.3.8 <7643#section-2.3.8>`."""
 
-    attribute_urn: Optional[str] = Field(None, exclude=True)
+    _attribute_urn: Optional[str] = None
 
     def get_attribute_urn(self, field_name: str) -> str:
         """Build the full URN of the attribute.
@@ -26,7 +26,7 @@ class ComplexAttribute(BaseModel):
         alias = (
             self.__class__.model_fields[field_name].serialization_alias or field_name
         )
-        return f"{self.attribute_urn}.{alias}"
+        return f"{self._attribute_urn}.{alias}"
 
 
 class MultiValuedComplexAttribute(ComplexAttribute):

{scim2_models-0.3.7 → scim2_models-0.4.0}/scim2_models/base.py

@@ -23,13 +23,13 @@ from scim2_models.annotations import Mutability
 from scim2_models.annotations import Required
 from scim2_models.annotations import Returned
 from scim2_models.context import Context
-from scim2_models.utils import normalize_attribute_name
-from scim2_models.utils import to_camel
+from scim2_models.utils import UNION_TYPES
+from scim2_models.utils import _find_field_name
+from scim2_models.utils import _normalize_attribute_name
+from scim2_models.utils import _to_camel
 
-from .utils import UNION_TYPES
 
-
-def contains_attribute_or_subattributes(
+def _contains_attribute_or_subattributes(
     attribute_urns: list[str], attribute_urn: str
 ) -> bool:
     return attribute_urn in attribute_urns or any(
@@ -43,8 +43,8 @@ class BaseModel(PydanticBaseModel):
 
     model_config = ConfigDict(
         alias_generator=AliasGenerator(
-            validation_alias=normalize_attribute_name,
-            serialization_alias=to_camel,
+            validation_alias=_normalize_attribute_name,
+            serialization_alias=_to_camel,
         ),
         validate_assignment=True,
         populate_by_name=True,
@@ -54,7 +54,35 @@ class BaseModel(PydanticBaseModel):
 
     @classmethod
     def get_field_annotation(cls, field_name: str, annotation_type: type) -> Any:
-        """Return the annotation of type 'annotation_type' of the field 'field_name'."""
+        """Return the annotation of type 'annotation_type' of the field 'field_name'.
+
+        This method extracts SCIM-specific annotations from a field's metadata,
+        such as :class:`~scim2_models.Mutability`, :class:`~scim2_models.Required`,
+        or :class:`~scim2_models.Returned` annotations.
+
+        :return: The annotation instance if found, otherwise the annotation type's default value
+
+        >>> from scim2_models.resources.user import User
+        >>> from scim2_models.annotations import Mutability, Required
+
+        Get the mutability annotation of the 'id' field:
+
+        >>> mutability = User.get_field_annotation("id", Mutability)
+        >>> mutability
+        <Mutability.read_only: 'readOnly'>
+
+        Get the required annotation of the 'user_name' field:
+
+        >>> required = User.get_field_annotation("user_name", Required)
+        >>> required
+        <Required.true: True>
+
+        If no annotation is found, returns the default value:
+
+        >>> missing = User.get_field_annotation("display_name", Required)
+        >>> missing
+        <Required.false: False>
+        """
         field_metadata = cls.model_fields[field_name].metadata
 
         default_value = getattr(annotation_type, "_default", None)
@@ -71,8 +99,34 @@ class BaseModel(PydanticBaseModel):
     def get_field_root_type(cls, attribute_name: str) -> Optional[type]:
         """Extract the root type from a model field.
 
-        For example, return 'GroupMember' for
-        'Optional[List[GroupMember]]'
+        This method unwraps complex type annotations to find the underlying
+        type, removing Optional and List wrappers to get to the actual type
+        of the field's content.
+
+        :return: The root type of the field, or None if not found
+
+        >>> from scim2_models.resources.user import User
+        >>> from scim2_models.resources.group import Group
+
+        Simple type:
+
+        >>> User.get_field_root_type("user_name")
+        <class 'str'>
+
+        ``Optional`` type unwraps to the underlying type:
+
+        >>> User.get_field_root_type("display_name")
+        <class 'str'>
+
+        ``List`` type unwraps to the element type:
+
+        >>> User.get_field_root_type("emails")  # doctest: +ELLIPSIS
+        <class 'scim2_models.resources.user.Email'>
+
+        ``Optional[List[T]]`` unwraps to ``T``:
+
+        >>> Group.get_field_root_type("members")  # doctest: +ELLIPSIS
+        <class 'scim2_models.resources.group.GroupMember'>
         """
         attribute_type = cls.model_fields[attribute_name].annotation
 
@@ -89,7 +143,20 @@ class BaseModel(PydanticBaseModel):
 
     @classmethod
     def get_field_multiplicity(cls, attribute_name: str) -> bool:
-        """Indicate whether a field holds multiple values."""
+        """Indicate whether a field holds multiple values.
+
+        This method determines if a field is defined as a list type,
+        which indicates it can contain multiple values. It handles
+        Optional wrappers correctly.
+
+        :return: True if the field holds multiple values (is a list), False otherwise
+
+        >>> from scim2_models.resources.user import User
+        >>> User.get_field_multiplicity("user_name")
+        False
+        >>> User.get_field_multiplicity("emails")
+        True
+        """
         attribute_type = cls.model_fields[attribute_name].annotation
 
         # extract 'x' from 'Optional[x]'
@@ -104,7 +171,7 @@ class BaseModel(PydanticBaseModel):
     def check_request_attributes_mutability(
         cls, value: Any, info: ValidationInfo
     ) -> Any:
-        """Check and fix that the field mutability is expected according to the requests validation context, as defined in :rfc:`RFC7643 §7 <7653#section-7>`."""
+        """Check and fix that the field mutability is expected according to the requests validation context, as defined in :rfc:`RFC7643 §7 <7643#section-7>`."""
         if (
             not info.context
             or not info.field_name
@@ -147,20 +214,49 @@ class BaseModel(PydanticBaseModel):
     ) -> Self:
         """Normalize payload attribute names.
 
-        :rfc:`RFC7643 §2.1 <7653#section-2.1>` indicate that attribute
+        :rfc:`RFC7643 §2.1 <7643#section-2.1>` indicate that attribute
         names should be case-insensitive. Any attribute name is
         transformed in lowercase so any case is handled the same way.
         """
 
-        def normalize_value(value: Any) -> Any:
-            if isinstance(value, dict):
-                return {
-                    normalize_attribute_name(k): normalize_value(v)
-                    for k, v in value.items()
-                }
-            return value
+        def normalize_dict_keys(
+            input_dict: dict, model_class: type["BaseModel"]
+        ) -> dict:
+            """Normalize dictionary keys, preserving case for Any fields."""
+            result = {}
 
-        normalized_value = normalize_value(value)
+            for key, val in input_dict.items():
+                field_name = _find_field_name(model_class, key)
+                field_type = (
+                    model_class.get_field_root_type(field_name) if field_name else None
+                )
+
+                # Don't normalize keys for attributes typed with Any
+                # This way, agnostic dicts such as PatchOp.operations.value
+                # are preserved
+                if field_name and field_type == Any:
+                    result[key] = normalize_value(val)
+                else:
+                    result[_normalize_attribute_name(key)] = normalize_value(
+                        val, field_type
+                    )
+
+            return result
+
+        def normalize_value(
+            val: Any, model_class: Optional[type["BaseModel"]] = None
+        ) -> Any:
+            """Normalize input value based on model class."""
+            if not isinstance(val, dict):
+                return val
+
+            # If no model_class, preserve original keys
+            if not model_class:
+                return {k: normalize_value(v) for k, v in val.items()}
+
+            return normalize_dict_keys(val, model_class)
+
+        normalized_value = normalize_value(value, cls)
         obj = handler(normalized_value)
         assert isinstance(obj, cls)
         return obj
@@ -170,7 +266,7 @@ class BaseModel(PydanticBaseModel):
     def check_response_attributes_returnability(
         cls, value: Any, handler: ValidatorFunctionWrapHandler, info: ValidationInfo
     ) -> Self:
-        """Check that the fields returnability is expected according to the responses validation context, as defined in :rfc:`RFC7643 §7 <7653#section-7>`."""
+        """Check that the fields returnability is expected according to the responses validation context, as defined in :rfc:`RFC7643 §7 <7643#section-7>`."""
         obj = handler(value)
         assert isinstance(obj, cls)
 
@@ -244,7 +340,7 @@ class BaseModel(PydanticBaseModel):
         cls, value: Any, handler: ValidatorFunctionWrapHandler, info: ValidationInfo
     ) -> Self:
         """Check if 'immutable' attributes have been mutated in replacement requests."""
-        from scim2_models.rfc7643.resource import Resource
+        from scim2_models.resources.resource import Resource
 
         obj = handler(value)
         assert isinstance(obj, cls)
@@ -256,11 +352,11 @@ class BaseModel(PydanticBaseModel):
             and issubclass(cls, Resource)
             and original is not None
         ):
-            cls.check_mutability_issues(original, obj)
+            cls._check_mutability_issues(original, obj)
         return obj
 
     @classmethod
-    def check_mutability_issues(
+    def _check_mutability_issues(
         cls, original: "BaseModel", replacement: "BaseModel"
     ) -> None:
         """Compare two instances, and check for differences of values on the fields marked as immutable."""
@@ -287,18 +383,18 @@ class BaseModel(PydanticBaseModel):
                 original_val = getattr(original, field_name)
                 replacement_value = getattr(replacement, field_name)
                 if original_val is not None and replacement_value is not None:
-                    cls.check_mutability_issues(original_val, replacement_value)
+                    cls._check_mutability_issues(original_val, replacement_value)
 
-    def set_complex_attribute_urns(self) -> None:
-        """Navigate through attributes and sub-attributes of type ComplexAttribute, and mark them with a 'attribute_urn' attribute.
+    def _set_complex_attribute_urns(self) -> None:
+        """Navigate through attributes and sub-attributes of type ComplexAttribute, and mark them with a '_attribute_urn' attribute.
 
-        'attribute_urn' will later be used by 'get_attribute_urn'.
+        '_attribute_urn' will later be used by 'get_attribute_urn'.
         """
         from .attributes import ComplexAttribute
         from .attributes import is_complex_attribute
 
         if isinstance(self, ComplexAttribute):
-            main_schema = self.attribute_urn
+            main_schema = self._attribute_urn
             separator = "."
         else:
             main_schema = self.__class__.model_fields["schemas"].default[0]
@@ -314,9 +410,9 @@ class BaseModel(PydanticBaseModel):
             if attr_value := getattr(self, field_name):
                 if isinstance(attr_value, list):
                     for item in attr_value:
-                        item.attribute_urn = schema
+                        item._attribute_urn = schema
                 else:
-                    attr_value.attribute_urn = schema
+                    attr_value._attribute_urn = schema
 
     @field_serializer("*", mode="wrap")
     def scim_serializer(
@@ -330,14 +426,14 @@ class BaseModel(PydanticBaseModel):
         scim_ctx = info.context.get("scim") if info.context else None
 
         if scim_ctx and Context.is_request(scim_ctx):
-            value = self.scim_request_serializer(value, info)
+            value = self._scim_request_serializer(value, info)
 
         if scim_ctx and Context.is_response(scim_ctx):
-            value = self.scim_response_serializer(value, info)
+            value = self._scim_response_serializer(value, info)
 
         return value
 
-    def scim_request_serializer(self, value: Any, info: FieldSerializationInfo) -> Any:
+    def _scim_request_serializer(self, value: Any, info: FieldSerializationInfo) -> Any:
         """Serialize the fields according to mutability indications passed in the serialization context."""
         mutability = self.get_field_annotation(info.field_name, Mutability)
         scim_ctx = info.context.get("scim") if info.context else None
@@ -361,7 +457,9 @@ class BaseModel(PydanticBaseModel):
 
         return value
 
-    def scim_response_serializer(self, value: Any, info: FieldSerializationInfo) -> Any:
+    def _scim_response_serializer(
+        self, value: Any, info: FieldSerializationInfo
+    ) -> Any:
         """Serialize the fields according to returnability indications passed in the serialization context."""
         returnability = self.get_field_annotation(info.field_name, Returned)
         attribute_urn = self.get_attribute_urn(info.field_name)
@@ -370,9 +468,9 @@ class BaseModel(PydanticBaseModel):
             info.context.get("scim_excluded_attributes", []) if info.context else []
         )
 
-        attribute_urn = normalize_attribute_name(attribute_urn)
-        included_urns = [normalize_attribute_name(urn) for urn in included_urns]
-        excluded_urns = [normalize_attribute_name(urn) for urn in excluded_urns]
+        attribute_urn = _normalize_attribute_name(attribute_urn)
+        included_urns = [_normalize_attribute_name(urn) for urn in included_urns]
+        excluded_urns = [_normalize_attribute_name(urn) for urn in excluded_urns]
 
         if returnability == Returned.never:
             return None
@@ -380,7 +478,7 @@ class BaseModel(PydanticBaseModel):
         if returnability == Returned.default and (
             (
                 included_urns
-                and not contains_attribute_or_subattributes(
+                and not _contains_attribute_or_subattributes(
                     included_urns, attribute_urn
                 )
             )
@@ -398,7 +496,7 @@ class BaseModel(PydanticBaseModel):
         self, handler: SerializerFunctionWrapHandler, info: SerializationInfo
     ) -> dict[str, Any]:
         """Remove `None` values inserted by the :meth:`~scim2_models.base.BaseModel.scim_serializer`."""
-        self.set_complex_attribute_urns()
+        self._set_complex_attribute_urns()
         result = handler(self)
         return {key: value for key, value in result.items() if value is not None}
 
@@ -433,7 +531,7 @@ class BaseModel(PydanticBaseModel):
 
         See :rfc:`RFC7644 §3.10 <7644#section-3.10>`.
         """
-        from scim2_models.rfc7643.resource import Extension
+        from scim2_models.resources.resource import Extension
 
         main_schema = self.__class__.model_fields["schemas"].default[0]
         field = self.__class__.model_fields[field_name]

{scim2_models-0.3.7 → scim2_models-0.4.0}/scim2_models/context.py

@@ -78,7 +78,7 @@ class Context(Enum):
 
     - When used for serialization, it will not dump attributes annotated with :attr:`~scim2_models.Mutability.read_only`.
     - When used for validation, it will ignore attributes annotated with :attr:`scim2_models.Mutability.read_only` and raise a :class:`~pydantic.ValidationError`:
-        - when finding attributes annotated with :attr:`~scim2_models.Mutability.immutable` different than :paramref:`~scim2_models.BaseModel.model_validate.original`:
+        - when finding attributes annotated with :attr:`~scim2_models.Mutability.immutable` different than the ``original`` parameter passed to :meth:`~scim2_models.BaseModel.model_validate`;
         - when attributes annotated with :attr:`Required.true <scim2_models.Required.true>` are missing on null.
     """
 

{scim2_models-0.3.7/scim2_models/rfc7644 → scim2_models-0.4.0/scim2_models/messages}/bulk.py

@@ -8,7 +8,7 @@ from pydantic import PlainSerializer
 
 from ..annotations import Required
 from ..attributes import ComplexAttribute
-from ..utils import int_to_str
+from ..utils import _int_to_str
 from .message import Message
 
 
@@ -42,7 +42,7 @@ class BulkOperation(ComplexAttribute):
     response: Optional[Any] = None
     """The HTTP response body for the specified request operation."""
 
-    status: Annotated[Optional[int], PlainSerializer(int_to_str)] = None
+    status: Annotated[Optional[int], PlainSerializer(_int_to_str)] = None
     """The HTTP response status code for the requested operation."""
 
 

{scim2_models-0.3.7/scim2_models/rfc7644 → scim2_models-0.4.0/scim2_models/messages}/error.py

@@ -4,7 +4,7 @@ from typing import Optional
 from pydantic import PlainSerializer
 
 from ..annotations import Required
-from ..utils import int_to_str
+from ..utils import _int_to_str
 from .message import Message
 
 
@@ -15,7 +15,7 @@ class Error(Message):
         "urn:ietf:params:scim:api:messages:2.0:Error"
     ]
 
-    status: Annotated[Optional[int], PlainSerializer(int_to_str)] = None
+    status: Annotated[Optional[int], PlainSerializer(_int_to_str)] = None
     """The HTTP status code (see Section 6 of [RFC7231]) expressed as a JSON
     string."""
 

{scim2_models-0.3.7/scim2_models/rfc7644 → scim2_models-0.4.0/scim2_models/messages}/list_response.py

@@ -12,12 +12,12 @@ from typing_extensions import Self
 
 from ..annotations import Required
 from ..context import Context
-from ..rfc7643.resource import AnyResource
-from .message import GenericMessageMetaclass
+from ..resources.resource import AnyResource
 from .message import Message
+from .message import _GenericMessageMetaclass
 
 
-class ListResponse(Message, Generic[AnyResource], metaclass=GenericMessageMetaclass):
+class ListResponse(Message, Generic[AnyResource], metaclass=_GenericMessageMetaclass):
     schemas: Annotated[list[str], Required.true] = [
         "urn:ietf:params:scim:api:messages:2.0:ListResponse"
     ]