maleo-identity 0.1.9__tar.gz → 0.1.11__tar.gz

{maleo_identity-0.1.9 → maleo_identity-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-identity
-Version: 0.1.9
+Version: 0.1.11
 Summary: MaleoIdentity service package
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
@@ -41,13 +41,12 @@ Requires-Dist: identify>=2.6.15
 Requires-Dist: idna>=3.10
 Requires-Dist: importlib_metadata>=8.7.0
 Requires-Dist: iniconfig>=2.1.0
-Requires-Dist: maleo-crypto>=0.0.46
-Requires-Dist: maleo-enums>=0.0.46
-Requires-Dist: maleo-logging>=0.0.46
-Requires-Dist: maleo-metadata>=0.3.60
-Requires-Dist: maleo-schemas>=0.1.56
-Requires-Dist: maleo-types>=0.0.26
-Requires-Dist: maleo-utils>=0.0.46
+Requires-Dist: maleo-crypto>=0.0.50
+Requires-Dist: maleo-enums>=0.0.50
+Requires-Dist: maleo-logging>=0.0.50
+Requires-Dist: maleo-schemas>=0.1.80
+Requires-Dist: maleo-types>=0.0.50
+Requires-Dist: maleo-utils>=0.0.50
 Requires-Dist: mypy_extensions>=1.1.0
 Requires-Dist: nodeenv>=1.9.1
 Requires-Dist: opentelemetry-api>=1.37.0

{maleo_identity-0.1.9 → maleo_identity-0.1.11}/maleo_identity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-identity
-Version: 0.1.9
+Version: 0.1.11
 Summary: MaleoIdentity service package
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
@@ -41,13 +41,12 @@ Requires-Dist: identify>=2.6.15
 Requires-Dist: idna>=3.10
 Requires-Dist: importlib_metadata>=8.7.0
 Requires-Dist: iniconfig>=2.1.0
-Requires-Dist: maleo-crypto>=0.0.46
-Requires-Dist: maleo-enums>=0.0.46
-Requires-Dist: maleo-logging>=0.0.46
-Requires-Dist: maleo-metadata>=0.3.60
-Requires-Dist: maleo-schemas>=0.1.56
-Requires-Dist: maleo-types>=0.0.26
-Requires-Dist: maleo-utils>=0.0.46
+Requires-Dist: maleo-crypto>=0.0.50
+Requires-Dist: maleo-enums>=0.0.50
+Requires-Dist: maleo-logging>=0.0.50
+Requires-Dist: maleo-schemas>=0.1.80
+Requires-Dist: maleo-types>=0.0.50
+Requires-Dist: maleo-utils>=0.0.50
 Requires-Dist: mypy_extensions>=1.1.0
 Requires-Dist: nodeenv>=1.9.1
 Requires-Dist: opentelemetry-api>=1.37.0

{maleo_identity-0.1.9 → maleo_identity-0.1.11}/maleo_identity.egg-info/SOURCES.txt

@@ -38,7 +38,10 @@ src/mixins/organization_registration_code.py
 src/mixins/organization_relation.py
 src/mixins/patient.py
 src/mixins/user.py
+src/mixins/user_medical_role.py
+src/mixins/user_organization_role.py
 src/mixins/user_profile.py
+src/mixins/user_system_role.py
 src/schemas/__init__.py
 src/schemas/api_key.py
 src/schemas/common.py

{maleo_identity-0.1.9 → maleo_identity-0.1.11}/maleo_identity.egg-info/requires.txt

@@ -32,13 +32,12 @@ identify>=2.6.15
 idna>=3.10
 importlib_metadata>=8.7.0
 iniconfig>=2.1.0
-maleo-crypto>=0.0.46
-maleo-enums>=0.0.46
-maleo-logging>=0.0.46
-maleo-metadata>=0.3.60
-maleo-schemas>=0.1.56
-maleo-types>=0.0.26
-maleo-utils>=0.0.46
+maleo-crypto>=0.0.50
+maleo-enums>=0.0.50
+maleo-logging>=0.0.50
+maleo-schemas>=0.1.80
+maleo-types>=0.0.50
+maleo-utils>=0.0.50
 mypy_extensions>=1.1.0
 nodeenv>=1.9.1
 opentelemetry-api>=1.37.0

{maleo_identity-0.1.9 → maleo_identity-0.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo-identity"
-version = "0.1.9"
+version = "0.1.11"
 description = "MaleoIdentity service package"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }
@@ -47,13 +47,12 @@ dependencies = [
     "idna>=3.10",
     "importlib_metadata>=8.7.0",
     "iniconfig>=2.1.0",
-    "maleo-crypto>=0.0.46",
-    "maleo-enums>=0.0.46",
-    "maleo-logging>=0.0.46",
-    "maleo-metadata>=0.3.60",
-    "maleo-schemas>=0.1.56",
-    "maleo-types>=0.0.26",
-    "maleo-utils>=0.0.46",
+    "maleo-crypto>=0.0.50",
+    "maleo-enums>=0.0.50",
+    "maleo-logging>=0.0.50",
+    "maleo-schemas>=0.1.80",
+    "maleo-types>=0.0.50",
+    "maleo-utils>=0.0.50",
     "mypy_extensions>=1.1.0",
     "nodeenv>=1.9.1",
     "opentelemetry-api>=1.37.0",

maleo_identity-0.1.11/src/mixins/api_key.py

@@ -0,0 +1,67 @@
+from pydantic import BaseModel, Field
+from typing import Annotated, Literal, TypeGuard
+from uuid import UUID
+from maleo.schemas.mixins.identity import Identifier
+from ..enums.api_key import IdentifierType
+from ..types.api_key import CompositeIdentifier, IdentifierValueType
+
+
+class APIKey(BaseModel):
+    api_key: Annotated[str, Field(..., description="API Key", max_length=255)]
+
+
+class APIKeyIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    pass
+
+
+class IdAPIKeyIdentifier(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 UUIDAPIKeyIdentifier(Identifier[Literal[IdentifierType.UUID], UUID]):
+    type: Annotated[
+        Literal[IdentifierType.UUID],
+        Field(IdentifierType.UUID, description="Identifier's type"),
+    ] = IdentifierType.UUID
+
+
+class CompositeAPIKeyIdentifier(
+    Identifier[Literal[IdentifierType.COMPOSITE], CompositeIdentifier]
+):
+    type: Annotated[
+        Literal[IdentifierType.COMPOSITE],
+        Field(IdentifierType.COMPOSITE, description="Identifier's type"),
+    ] = IdentifierType.COMPOSITE
+    value: Annotated[CompositeIdentifier, Field(..., description="Identifier's value")]
+
+
+AnyAPIKeyIdentifier = (
+    APIKeyIdentifier
+    | IdAPIKeyIdentifier
+    | UUIDAPIKeyIdentifier
+    | CompositeAPIKeyIdentifier
+)
+
+
+def is_id_identifier(
+    identifier: AnyAPIKeyIdentifier,
+) -> TypeGuard[IdAPIKeyIdentifier]:
+    return identifier.type is IdentifierType.ID and isinstance(identifier.value, int)
+
+
+def is_uuid_identifier(
+    identifier: AnyAPIKeyIdentifier,
+) -> TypeGuard[UUIDAPIKeyIdentifier]:
+    return identifier.type is IdentifierType.UUID and isinstance(identifier.value, UUID)
+
+
+def is_composite_identifier(
+    identifier: AnyAPIKeyIdentifier,
+) -> TypeGuard[CompositeAPIKeyIdentifier]:
+    return identifier.type is IdentifierType.COMPOSITE and isinstance(
+        identifier.value, tuple
+    )

maleo_identity-0.1.11/src/mixins/organization.py

@@ -0,0 +1,73 @@
+from pydantic import BaseModel, Field
+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 Key(BaseKey, Generic[OptStrT]):
+    key: Annotated[OptStrT, Field(..., description="Key", max_length=255)]
+
+
+class Name(BaseName, Generic[OptStrT]):
+    name: Annotated[OptStrT, Field(..., description="Name", max_length=255)]
+
+
+class Secret(BaseModel, Generic[OptUUIDT]):
+    secret: Annotated[OptUUIDT, Field(..., description="Secret")]
+
+
+class OrganizationIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    pass
+
+
+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-0.1.11/src/mixins/organization_registration_code.py

@@ -0,0 +1,100 @@
+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.integer import OptIntT
+from maleo.types.string import OptStrT
+from ..enums.organization_registration_code import IdentifierType
+from ..types.organization_registration_code import IdentifierValueType
+
+
+class Code(BaseModel, Generic[OptStrT]):
+    code: Annotated[OptStrT, Field(..., description="Code", max_length=36)]
+
+
+class MaxUses(BaseModel, Generic[OptIntT]):
+    max_uses: Annotated[OptIntT, Field(..., description="Max Uses", ge=1)]
+
+
+class CurrentUses(BaseModel):
+    current_uses: Annotated[int, Field(0, description="Current Uses", ge=0)] = 0
+
+
+class OrganizationRegistrationCodeIdentifier(
+    Identifier[IdentifierType, IdentifierValueType]
+):
+    pass
+
+
+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-0.1.11/src/mixins/organization_relation.py

@@ -0,0 +1,75 @@
+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.boolean import OptBoolT
+from maleo.types.misc import OptListOfAnyOrStrToAnyDict
+from ..enums.organization_relation import IdentifierType
+from ..types.organization_relation import CompositeIdentifier, 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]):
+    pass
+
+
+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], CompositeIdentifier]
+):
+    type: Annotated[
+        Literal[IdentifierType.COMPOSITE],
+        Field(IdentifierType.COMPOSITE, description="Identifier's type"),
+    ] = IdentifierType.COMPOSITE
+    value: Annotated[CompositeIdentifier, 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-0.1.11/src/mixins/patient.py

@@ -0,0 +1,96 @@
+from pydantic import Field, model_validator
+from typing import Annotated, Generic, Literal, Self, TypeGuard
+from uuid import UUID
+from maleo.schemas.mixins.identity import Identifier
+from maleo.schemas.mixins.identity import Passport as BasePassport
+from maleo.types.string import OptStr, OptStrT
+from ..enums.patient import IdentifierType
+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 PatientIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    pass
+
+
+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
+
+
+class IdCardPatientIdentifier(Identifier[Literal[IdentifierType.ID_CARD], str]):
+    type: Annotated[
+        Literal[IdentifierType.ID_CARD],
+        Field(IdentifierType.ID_CARD, description="Identifier's type"),
+    ] = IdentifierType.ID_CARD
+    value: Annotated[str, Field(..., description="Identifier's value", max_length=16)]
+
+
+class PassportPatientIdentifier(Identifier[Literal[IdentifierType.PASSPORT], str]):
+    type: Annotated[
+        Literal[IdentifierType.PASSPORT],
+        Field(IdentifierType.PASSPORT, description="Identifier's type"),
+    ] = IdentifierType.PASSPORT
+    value: Annotated[str, Field(..., description="Identifier's value", max_length=9)]
+
+
+AnyPatientIdentifier = (
+    PatientIdentifier
+    | IdPatientIdentifier
+    | UUIDPatientIdentifier
+    | IdCardPatientIdentifier
+    | PassportPatientIdentifier
+)
+
+
+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)
+
+
+def is_id_card_identifier(
+    identifier: AnyPatientIdentifier,
+) -> TypeGuard[IdCardPatientIdentifier]:
+    return identifier.type is IdentifierType.ID_CARD and isinstance(
+        identifier.value, str
+    )
+
+
+def is_passport_identifier(
+    identifier: AnyPatientIdentifier,
+) -> TypeGuard[PassportPatientIdentifier]:
+    return identifier.type is IdentifierType.PASSPORT and isinstance(
+        identifier.value, str
+    )

maleo_identity-0.1.11/src/mixins/user.py

@@ -0,0 +1,107 @@
+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.string import OptStrT, OptListOfStrsT
+from ..enums.user import IdentifierType
+from ..types.user import IdentifierValueType
+
+
+class Username(BaseModel, Generic[OptStrT]):
+    username: Annotated[
+        OptStrT, Field(..., description="User's username", max_length=50)
+    ]
+
+
+class Usernames(BaseModel, Generic[OptListOfStrsT]):
+    usernames: Annotated[OptListOfStrsT, Field(..., description="User's Usernames")]
+
+
+class Email(BaseModel, Generic[OptStrT]):
+    email: Annotated[OptStrT, Field(..., description="User's email", max_length=255)]
+
+
+class Emails(BaseModel, Generic[OptListOfStrsT]):
+    emails: Annotated[OptListOfStrsT, Field(..., description="User's Emails")]
+
+
+class Phone(BaseModel, Generic[OptStrT]):
+    phone: Annotated[OptStrT, Field(..., description="User's phone", max_length=15)]
+
+
+class Phones(BaseModel, Generic[OptListOfStrsT]):
+    phones: Annotated[OptListOfStrsT, Field(..., description="User's Phones")]
+
+
+class Password(BaseModel):
+    password: Annotated[str, Field(..., description="Password", max_length=255)]
+
+
+class UserIdentifier(Identifier[IdentifierType, IdentifierValueType]):
+    pass
+
+
+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)
+
+
+def is_username_identifier(
+    identifier: AnyUserIdentifier,
+) -> TypeGuard[UsernameUserIdentifier]:
+    return identifier.type is IdentifierType.USERNAME and isinstance(
+        identifier.value, str
+    )
+
+
+def is_email_identifier(
+    identifier: AnyUserIdentifier,
+) -> TypeGuard[EmailUserIdentifier]:
+    return identifier.type is IdentifierType.EMAIL and isinstance(identifier.value, str)