maleo-identity 0.0.85__py3-none-any.whl → 0.1.24__py3-none-any.whl

maleo/identity/mixins/organization.py

@@ -1,15 +1,75 @@
 from pydantic import BaseModel, Field
-from maleo.soma.mixins.parameter import Expand as BaseExpand
-from maleo.identity.enums.organization import ExpandableField
+from typing import Annotated, Generic, Literal, TypeGuard
+from uuid import UUID
+from maleo.schemas.mixins.identity import Identifier, Key as BaseKey, Name as BaseName
+from maleo.types.string import OptStrT
+from maleo.types.uuid import OptUUIDT
+from ..enums.organization import IdentifierType
+from ..types.organization import IdentifierValueType
 
 
-class Expand(BaseExpand[ExpandableField]):
-    pass
+class Key(BaseKey, Generic[OptStrT]):
+    key: Annotated[OptStrT, Field(..., description="Key", max_length=255)]
 
 
-class Key(BaseModel):
-    key: str = Field(..., max_length=255, description="Organization's key")
+class Name(BaseName, Generic[OptStrT]):
+    name: Annotated[OptStrT, Field(..., description="Name", max_length=255)]
 
 
-class Name(BaseModel):
-    name: str = Field(..., max_length=255, description="Organization's name")
+class Secret(BaseModel, Generic[OptUUIDT]):
+    secret: Annotated[OptUUIDT, Field(..., description="Secret")]
+
+
+class OrganizationIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    @property
+    def column_and_value(self) -> tuple[str, IdentifierValueType]:
+        return self.type.column, self.value
+
+
+class IdOrganizationIdentifier(Identifier[Literal[IdentifierType.ID], int]):
+    type: Annotated[
+        Literal[IdentifierType.ID],
+        Field(IdentifierType.ID, description="Identifier's type"),
+    ] = IdentifierType.ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
+
+
+class UUIDOrganizationIdentifier(Identifier[Literal[IdentifierType.UUID], UUID]):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
+
+
+class KeyOrganizationIdentifier(Identifier[Literal[IdentifierType.KEY], str]):
+    type: Annotated[
+        Literal[IdentifierType.KEY],
+        Field(IdentifierType.KEY, description="Identifier's type"),
+    ] = IdentifierType.KEY
+    value: Annotated[str, Field(..., description="Identifier's value", max_length=255)]
+
+
+AnyOrganizationIdentifier = (
+    OrganizationIdentifier
+    | IdOrganizationIdentifier
+    | UUIDOrganizationIdentifier
+    | KeyOrganizationIdentifier
+)
+
+
+def is_id_identifier(
+    identifier: AnyOrganizationIdentifier,
+) -> TypeGuard[IdOrganizationIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
+
+
+def is_uuid_identifier(
+    identifier: AnyOrganizationIdentifier,
+) -> TypeGuard[UUIDOrganizationIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)
+
+
+def is_key_identifier(
+    identifier: AnyOrganizationIdentifier,
+) -> TypeGuard[KeyOrganizationIdentifier]:
+    return identifier.type is IdentifierType.KEY and isinstance(identifier.value, str)

maleo/identity/mixins/organization_registration_code.py

@@ -1,19 +1,136 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
+from typing import Annotated, Generic, Literal, Self, TypeGuard
 from uuid import UUID
-from maleo.soma.types.base import OptionalInteger
+from maleo.schemas.mixins.identity import Identifier
+from maleo.types.integer import OptIntT
+from maleo.types.misc import OptIntOrStr
+from maleo.types.string import OptStrT
+from ..enums.organization_registration_code import IdentifierType
+from ..types.organization_registration_code import IdentifierValueType
 
 
-class Code(BaseModel):
-    code: UUID = Field(..., description="Registration code")
+class CodeOrLength(BaseModel):
+    code_or_length: Annotated[
+        OptIntOrStr,
+        Field(
+            None,
+            description=(
+                "Code (str) or length (int). "
+                "If code is given, the length must be between 6 and 36 inclusive. "
+                "If length is given, the value must be between 6 and 36 inclusive. "
+                "Will generate random 6 char string if omitted"
+            ),
+        ),
+    ]
 
+    @model_validator(mode="after")
+    def validate_code_or_length(self) -> Self:
+        code_or_length = self.code_or_length
+        if code_or_length is None:
+            return self
+        print(code_or_length)
+        if isinstance(code_or_length, int):
+            length = code_or_length
+        elif isinstance(code_or_length, str):
+            length = len(code_or_length)
+        else:
+            raise ValueError("Code or Length must be either int or str")
+        if length < 6 or length > 36:
+            raise ValueError("Code or Length must be between 6 and 36 inclusive")
+        return self
 
-class MaxUses(BaseModel):
-    max_uses: int = Field(1, ge=1, description="Max code uses")
 
+class Code(BaseModel, Generic[OptStrT]):
+    code: Annotated[
+        OptStrT, Field(..., description="Code", min_length=6, max_length=36)
+    ]
 
-class OptionalMaxUses(BaseModel):
-    max_uses: OptionalInteger = Field(None, ge=1, description="Max code uses")
+
+class MaxUses(BaseModel, Generic[OptIntT]):
+    max_uses: Annotated[OptIntT, Field(..., description="Max Uses", ge=1)]
 
 
 class CurrentUses(BaseModel):
-    current_uses: int = Field(0, ge=0, description="Current code uses")
+    current_uses: Annotated[int, Field(0, description="Current Uses", ge=0)] = 0
+
+
+class OrganizationRegistrationCodeIdentifier(
+    Identifier[IdentifierType, IdentifierValueType]
+):
+    @property
+    def column_and_value(self) -> tuple[str, IdentifierValueType]:
+        return self.type.column, self.value
+
+
+class IdOrganizationRegistrationCodeIdentifier(
+    Identifier[Literal[IdentifierType.ID], int]
+):
+    type: Annotated[
+        Literal[IdentifierType.ID],
+        Field(IdentifierType.ID, description="Identifier's type"),
+    ] = IdentifierType.ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
+
+
+class OrgIdOrganizationRegistrationCodeIdentifier(
+    Identifier[Literal[IdentifierType.ORGANIZATION_ID], int]
+):
+    type: Annotated[
+        Literal[IdentifierType.ORGANIZATION_ID],
+        Field(IdentifierType.ORGANIZATION_ID, description="Identifier's type"),
+    ] = IdentifierType.ORGANIZATION_ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
+
+
+class UUIDOrganizationRegistrationCodeIdentifier(
+    Identifier[Literal[IdentifierType.UUID], UUID]
+):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
+
+
+class CodeOrganizationRegistrationCodeIdentifier(
+    Identifier[Literal[IdentifierType.CODE], str]
+):
+    type: Annotated[
+        Literal[IdentifierType.CODE],
+        Field(IdentifierType.CODE, description="Identifier's type"),
+    ] = IdentifierType.CODE
+    value: Annotated[str, Field(..., description="Identifier's value", max_length=36)]
+
+
+AnyOrganizationRegistrationCodeIdentifier = (
+    OrganizationRegistrationCodeIdentifier
+    | IdOrganizationRegistrationCodeIdentifier
+    | OrgIdOrganizationRegistrationCodeIdentifier
+    | UUIDOrganizationRegistrationCodeIdentifier
+    | CodeOrganizationRegistrationCodeIdentifier
+)
+
+
+def is_id_identifier(
+    identifier: AnyOrganizationRegistrationCodeIdentifier,
+) -> TypeGuard[IdOrganizationRegistrationCodeIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
+
+
+def is_org_id_identifier(
+    identifier: AnyOrganizationRegistrationCodeIdentifier,
+) -> TypeGuard[OrgIdOrganizationRegistrationCodeIdentifier]:
+    return identifier.type is IdentifierType.ORGANIZATION_ID and isinstance(
+        identifier.value, int
+    )
+
+
+def is_uuid_identifier(
+    identifier: AnyOrganizationRegistrationCodeIdentifier,
+) -> TypeGuard[UUIDOrganizationRegistrationCodeIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)
+
+
+def is_code_identifier(
+    identifier: AnyOrganizationRegistrationCodeIdentifier,
+) -> TypeGuard[CodeOrganizationRegistrationCodeIdentifier]:
+    return identifier.type is IdentifierType.CODE and isinstance(identifier.value, str)

maleo/identity/mixins/organization_relation.py

@@ -0,0 +1,80 @@
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Literal, TypeGuard
+from uuid import UUID
+from maleo.schemas.mixins.identity import Identifier
+from maleo.types.any import ManyAny
+from maleo.types.boolean import OptBoolT
+from maleo.types.misc import OptListOfAnyOrStrToAnyDict
+from maleo.types.string import ManyStrs
+from ..enums.organization_relation import IdentifierType
+from ..types.organization_relation import CompositeIdentifierType, IdentifierValueType
+
+
+class IsBidirectional(BaseModel, Generic[OptBoolT]):
+    is_bidirectional: Annotated[OptBoolT, Field(..., description="Is Bidirectional")]
+
+
+class Meta(BaseModel):
+    meta: Annotated[OptListOfAnyOrStrToAnyDict, Field(None, description="Meta")] = None
+
+
+class OrganizationRelationIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    @property
+    def columns_and_values(self) -> tuple[ManyStrs, ManyAny]:
+        values = self.value if isinstance(self.value, tuple) else (self.value,)
+        return self.type.columns, values
+
+
+class IdOrganizationRelationIdentifier(Identifier[Literal[IdentifierType.ID], int]):
+    type: Annotated[
+        Literal[IdentifierType.ID],
+        Field(IdentifierType.ID, description="Identifier's type"),
+    ] = IdentifierType.ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
+
+
+class UUIDOrganizationRelationIdentifier(
+    Identifier[Literal[IdentifierType.UUID], UUID]
+):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
+
+
+class CompositeOrganizationRelationIdentifier(
+    Identifier[Literal[IdentifierType.COMPOSITE], CompositeIdentifierType]
+):
+    type: Annotated[
+        Literal[IdentifierType.COMPOSITE],
+        Field(IdentifierType.COMPOSITE, description="Identifier's type"),
+    ] = IdentifierType.COMPOSITE
+    value: Annotated[CompositeIdentifierType, Field(..., description="Identifier's value")]
+
+
+AnyOrganizationRelationIdentifier = (
+    OrganizationRelationIdentifier
+    | IdOrganizationRelationIdentifier
+    | UUIDOrganizationRelationIdentifier
+    | CompositeOrganizationRelationIdentifier
+)
+
+
+def is_id_identifier(
+    identifier: AnyOrganizationRelationIdentifier,
+) -> TypeGuard[IdOrganizationRelationIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
+
+
+def is_uuid_identifier(
+    identifier: AnyOrganizationRelationIdentifier,
+) -> TypeGuard[UUIDOrganizationRelationIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)
+
+
+def is_composite_identifier(
+    identifier: AnyOrganizationRelationIdentifier,
+) -> TypeGuard[CompositeOrganizationRelationIdentifier]:
+    return identifier.type is IdentifierType.COMPOSITE and isinstance(
+        identifier.value, tuple
+    )

maleo/identity/mixins/patient.py

@@ -0,0 +1,65 @@
+from pydantic import BaseModel, Field, model_validator
+from typing import Annotated, Generic, Literal, Self, TypeGuard
+from uuid import UUID
+from maleo.schemas.mixins.identity import Identifier, Passport as BasePassport
+from maleo.types.string import OptStr, OptStrT
+from ..enums.patient import IdentifierType, OptListOfExpandableFields
+from ..types.patient import IdentifierValueType
+from .common import IdCard
+
+
+class Passport(BasePassport, Generic[OptStrT]):
+    passport: Annotated[OptStrT, Field(..., description="Passport", max_length=9)]
+
+
+class PatientIdentity(
+    Passport[OptStr],
+    IdCard[OptStr],
+):
+    @model_validator(mode="after")
+    def chk_id_card_or_passport(self) -> Self:
+        if self.id_card is None and self.passport is None:
+            raise ValueError("Either ID Card or Passport must exist")
+        return self
+
+
+class Expand(BaseModel):
+    expand: Annotated[
+        OptListOfExpandableFields, Field(None, description="Expanded field(s)")
+    ] = None
+
+
+class PatientIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    @property
+    def column_and_value(self) -> tuple[str, IdentifierValueType]:
+        return self.type.column, self.value
+
+
+class IdPatientIdentifier(Identifier[Literal[IdentifierType.ID], int]):
+    type: Annotated[
+        Literal[IdentifierType.ID],
+        Field(IdentifierType.ID, description="Identifier's type"),
+    ] = IdentifierType.ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
+
+
+class UUIDPatientIdentifier(Identifier[Literal[IdentifierType.UUID], UUID]):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
+
+
+AnyPatientIdentifier = PatientIdentifier | IdPatientIdentifier | UUIDPatientIdentifier
+
+
+def is_id_identifier(
+    identifier: AnyPatientIdentifier,
+) -> TypeGuard[IdPatientIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
+
+
+def is_uuid_identifier(
+    identifier: AnyPatientIdentifier,
+) -> TypeGuard[UUIDPatientIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)

maleo/identity/mixins/user.py

@@ -1,47 +1,109 @@
 from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Literal, TypeGuard
 from uuid import UUID
-from maleo.soma.mixins.parameter import Expand as BaseExpand
-from maleo.soma.types.base import OptionalListOfStrings
-from maleo.identity.enums.user import ExpandableField
+from maleo.schemas.mixins.identity import Identifier
+from maleo.types.string import OptStrT, OptListOfStrsT
+from ..enums.user import IdentifierType
+from ..types.user import IdentifierValueType
 
 
-class Expand(BaseExpand[ExpandableField]):
-    pass
+class Username(BaseModel, Generic[OptStrT]):
+    username: Annotated[
+        OptStrT, Field(..., description="User's username", max_length=50)
+    ]
 
 
-class Username(BaseModel):
-    username: str = Field(..., max_length=50, description="User's username")
+class Usernames(BaseModel, Generic[OptListOfStrsT]):
+    usernames: Annotated[OptListOfStrsT, Field(..., description="User's Usernames")]
 
 
-class OptionalListOfUsernames(BaseModel):
-    usernames: OptionalListOfStrings = Field(None, description="Specific usernames")
+class Email(BaseModel, Generic[OptStrT]):
+    email: Annotated[OptStrT, Field(..., description="User's email", max_length=255)]
 
 
-class Email(BaseModel):
-    email: str = Field(..., max_length=255, description="User's email")
+class Emails(BaseModel, Generic[OptListOfStrsT]):
+    emails: Annotated[OptListOfStrsT, Field(..., description="User's Emails")]
 
 
-class OptionalListOfEmails(BaseModel):
-    emails: OptionalListOfStrings = Field(None, description="Specific emails")
+class Phone(BaseModel, Generic[OptStrT]):
+    phone: Annotated[OptStrT, Field(..., description="User's phone", max_length=15)]
 
 
-class Phone(BaseModel):
-    phone: str = Field(..., min_length=4, max_length=15, description="User's phone")
+class Phones(BaseModel, Generic[OptListOfStrsT]):
+    phones: Annotated[OptListOfStrsT, Field(..., description="User's Phones")]
 
 
-class OptionalListOfPhones(BaseModel):
-    phones: OptionalListOfStrings = Field(None, description="Specific phones")
+class Password(BaseModel):
+    password: Annotated[str, Field(..., description="Password", max_length=255)]
 
 
-class Password(BaseModel):
-    password: str = Field(..., max_length=255, description="User's password")
+class UserIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    @property
+    def column_and_value(self) -> tuple[str, IdentifierValueType]:
+        return self.type.column, self.value
+
+
+class IdUserIdentifier(Identifier[Literal[IdentifierType.ID], int]):
+    type: Annotated[
+        Literal[IdentifierType.ID],
+        Field(IdentifierType.ID, description="Identifier's type"),
+    ] = IdentifierType.ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
+
+
+class UUIDUserIdentifier(Identifier[Literal[IdentifierType.UUID], UUID]):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
+
+
+class UsernameUserIdentifier(Identifier[Literal[IdentifierType.USERNAME], str]):
+    type: Annotated[
+        Literal[IdentifierType.USERNAME],
+        Field(IdentifierType.USERNAME, description="Identifier's type"),
+    ] = IdentifierType.USERNAME
+    value: Annotated[str, Field(..., description="Identifier's value", max_length=50)]
+
+
+class EmailUserIdentifier(Identifier[Literal[IdentifierType.EMAIL], str]):
+    type: Annotated[
+        Literal[IdentifierType.EMAIL],
+        Field(IdentifierType.EMAIL, description="Identifier's type"),
+    ] = IdentifierType.EMAIL
+    value: Annotated[str, Field(..., description="Identifier's value", max_length=255)]
+
+
+AnyUserIdentifier = (
+    UserIdentifier
+    | IdUserIdentifier
+    | UUIDUserIdentifier
+    | UsernameUserIdentifier
+    | EmailUserIdentifier
+)
+
+
+def is_id_identifier(
+    identifier: AnyUserIdentifier,
+) -> TypeGuard[IdUserIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
+
+
+def is_uuid_identifier(
+    identifier: AnyUserIdentifier,
+) -> TypeGuard[UUIDUserIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)
 
 
-class PasswordConfirmation(BaseModel):
-    password_confirmation: str = Field(
-        ..., max_length=255, description="User's password confirmation"
+def is_username_identifier(
+    identifier: AnyUserIdentifier,
+) -> TypeGuard[UsernameUserIdentifier]:
+    return identifier.type is IdentifierType.USERNAME and isinstance(
+        identifier.value, str
     )
 
 
-class RegistrationCode(BaseModel):
-    registration_code: UUID = Field(..., description="Registration code")
+def is_email_identifier(
+    identifier: AnyUserIdentifier,
+) -> TypeGuard[EmailUserIdentifier]:
+    return identifier.type is IdentifierType.EMAIL and isinstance(identifier.value, str)

maleo/identity/mixins/user_medical_role.py

@@ -0,0 +1,68 @@
+from pydantic import Field
+from typing import Annotated, Literal, TypeGuard
+from uuid import UUID
+from maleo.schemas.mixins.identity import Identifier
+from maleo.types.any import ManyAny
+from maleo.types.string import ManyStrs
+from ..enums.user_medical_role import IdentifierType
+from ..types.user_medical_role import CompositeIdentifierType, IdentifierValueType
+
+
+class UserMedicalRoleIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    @property
+    def columns_and_values(self) -> tuple[ManyStrs, ManyAny]:
+        values = self.value if isinstance(self.value, tuple) else (self.value,)
+        return self.type.columns, values
+
+
+class IdUserMedicalRoleIdentifier(Identifier[Literal[IdentifierType.ID], int]):
+    type: Annotated[
+        Literal[IdentifierType.ID],
+        Field(IdentifierType.ID, description="Identifier's type"),
+    ] = IdentifierType.ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
+
+
+class UUIDUserMedicalRoleIdentifier(Identifier[Literal[IdentifierType.UUID], UUID]):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
+
+
+class CompositeUserMedicalRoleIdentifier(
+    Identifier[Literal[IdentifierType.COMPOSITE], CompositeIdentifierType]
+):
+    type: Annotated[
+        Literal[IdentifierType.COMPOSITE],
+        Field(IdentifierType.COMPOSITE, description="Identifier's type"),
+    ] = IdentifierType.COMPOSITE
+    value: Annotated[CompositeIdentifierType, Field(..., description="Identifier's value")]
+
+
+AnyUserMedicalRoleIdentifier = (
+    UserMedicalRoleIdentifier
+    | IdUserMedicalRoleIdentifier
+    | UUIDUserMedicalRoleIdentifier
+    | CompositeUserMedicalRoleIdentifier
+)
+
+
+def is_id_identifier(
+    identifier: AnyUserMedicalRoleIdentifier,
+) -> TypeGuard[IdUserMedicalRoleIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
+
+
+def is_uuid_identifier(
+    identifier: AnyUserMedicalRoleIdentifier,
+) -> TypeGuard[UUIDUserMedicalRoleIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)
+
+
+def is_composite_identifier(
+    identifier: AnyUserMedicalRoleIdentifier,
+) -> TypeGuard[CompositeUserMedicalRoleIdentifier]:
+    return identifier.type is IdentifierType.COMPOSITE and isinstance(
+        identifier.value, tuple
+    )

maleo/identity/mixins/user_organization_role.py

@@ -1,6 +1,70 @@
-from maleo.soma.mixins.parameter import Expand as BaseExpand
-from maleo.identity.enums.user_organization_role import ExpandableField
+from pydantic import Field
+from typing import Annotated, Literal, TypeGuard
+from uuid import UUID
+from maleo.schemas.mixins.identity import Identifier
+from maleo.types.any import ManyAny
+from maleo.types.string import ManyStrs
+from ..enums.user_organization_role import IdentifierType
+from ..types.user_organization_role import CompositeIdentifierType, IdentifierValueType
 
 
-class Expand(BaseExpand[ExpandableField]):
-    pass
+class UserOrganizationRoleIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    @property
+    def columns_and_values(self) -> tuple[ManyStrs, ManyAny]:
+        values = self.value if isinstance(self.value, tuple) else (self.value,)
+        return self.type.columns, values
+
+
+class IdUserOrganizationRoleIdentifier(Identifier[Literal[IdentifierType.ID], int]):
+    type: Annotated[
+        Literal[IdentifierType.ID],
+        Field(IdentifierType.ID, description="Identifier's type"),
+    ] = IdentifierType.ID
+    value: Annotated[int, Field(..., description="Identifier's value", ge=1)]
+
+
+class UUIDUserOrganizationRoleIdentifier(
+    Identifier[Literal[IdentifierType.UUID], UUID]
+):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
+
+
+class CompositeUserOrganizationRoleIdentifier(
+    Identifier[Literal[IdentifierType.COMPOSITE], CompositeIdentifierType]
+):
+    type: Annotated[
+        Literal[IdentifierType.COMPOSITE],
+        Field(IdentifierType.COMPOSITE, description="Identifier's type"),
+    ] = IdentifierType.COMPOSITE
+    value: Annotated[CompositeIdentifierType, Field(..., description="Identifier's value")]
+
+
+AnyUserOrganizationRoleIdentifier = (
+    UserOrganizationRoleIdentifier
+    | IdUserOrganizationRoleIdentifier
+    | UUIDUserOrganizationRoleIdentifier
+    | CompositeUserOrganizationRoleIdentifier
+)
+
+
+def is_id_identifier(
+    identifier: AnyUserOrganizationRoleIdentifier,
+) -> TypeGuard[IdUserOrganizationRoleIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
+
+
+def is_uuid_identifier(
+    identifier: AnyUserOrganizationRoleIdentifier,
+) -> TypeGuard[UUIDUserOrganizationRoleIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)
+
+
+def is_composite_identifier(
+    identifier: AnyUserOrganizationRoleIdentifier,
+) -> TypeGuard[CompositeUserOrganizationRoleIdentifier]:
+    return identifier.type is IdentifierType.COMPOSITE and isinstance(
+        identifier.value, tuple
+    )