maleo-enums 0.0.28__tar.gz → 0.0.32__tar.gz

{maleo_enums-0.0.28 → maleo_enums-0.0.32}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: maleo-enums
-Version: 0.0.28
+Version: 0.0.32
 Summary: Enums package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: annotated-types>=0.7.0
 Requires-Dist: black>=25.1.0
 Requires-Dist: cfgv>=3.4.0
 Requires-Dist: click>=8.2.1
@@ -14,14 +15,18 @@ Requires-Dist: colorama>=0.4.6
 Requires-Dist: distlib>=0.4.0
 Requires-Dist: filelock>=3.19.1
 Requires-Dist: identify>=2.6.13
-Requires-Dist: maleo-types>=0.0.8
+Requires-Dist: maleo-types>=0.0.12
 Requires-Dist: mypy_extensions>=1.1.0
 Requires-Dist: nodeenv>=1.9.1
 Requires-Dist: packaging>=25.0
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: platformdirs>=4.4.0
 Requires-Dist: pre_commit>=4.3.0
+Requires-Dist: pydantic>=2.12.2
+Requires-Dist: pydantic_core>=2.41.4
 Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: typing-inspection>=0.4.2
+Requires-Dist: typing_extensions>=4.15.0
 Requires-Dist: virtualenv>=20.34.0
 Dynamic: license-file
 

{maleo_enums-0.0.28 → maleo_enums-0.0.32}/maleo_enums.egg-info/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: maleo-enums
-Version: 0.0.28
+Version: 0.0.32
 Summary: Enums package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: annotated-types>=0.7.0
 Requires-Dist: black>=25.1.0
 Requires-Dist: cfgv>=3.4.0
 Requires-Dist: click>=8.2.1
@@ -14,14 +15,18 @@ Requires-Dist: colorama>=0.4.6
 Requires-Dist: distlib>=0.4.0
 Requires-Dist: filelock>=3.19.1
 Requires-Dist: identify>=2.6.13
-Requires-Dist: maleo-types>=0.0.8
+Requires-Dist: maleo-types>=0.0.12
 Requires-Dist: mypy_extensions>=1.1.0
 Requires-Dist: nodeenv>=1.9.1
 Requires-Dist: packaging>=25.0
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: platformdirs>=4.4.0
 Requires-Dist: pre_commit>=4.3.0
+Requires-Dist: pydantic>=2.12.2
+Requires-Dist: pydantic_core>=2.41.4
 Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: typing-inspection>=0.4.2
+Requires-Dist: typing_extensions>=4.15.0
 Requires-Dist: virtualenv>=20.34.0
 Dynamic: license-file
 

{maleo_enums-0.0.28 → maleo_enums-0.0.32}/maleo_enums.egg-info/requires.txt

@@ -1,3 +1,4 @@
+annotated-types>=0.7.0
 black>=25.1.0
 cfgv>=3.4.0
 click>=8.2.1
@@ -5,12 +6,16 @@ colorama>=0.4.6
 distlib>=0.4.0
 filelock>=3.19.1
 identify>=2.6.13
-maleo-types>=0.0.8
+maleo-types>=0.0.12
 mypy_extensions>=1.1.0
 nodeenv>=1.9.1
 packaging>=25.0
 pathspec>=0.12.1
 platformdirs>=4.4.0
 pre_commit>=4.3.0
+pydantic>=2.12.2
+pydantic_core>=2.41.4
 PyYAML>=6.0.2
+typing-inspection>=0.4.2
+typing_extensions>=4.15.0
 virtualenv>=20.34.0

{maleo_enums-0.0.28 → maleo_enums-0.0.32}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo-enums"
-version = "0.0.28"
+version = "0.0.32"
 description = "Enums package for MaleoSuite"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }
@@ -13,6 +13,7 @@ license = { text = "Proprietary" }
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
+    "annotated-types>=0.7.0",
     "black>=25.1.0",
     "cfgv>=3.4.0",
     "click>=8.2.1",
@@ -20,14 +21,18 @@ dependencies = [
     "distlib>=0.4.0",
     "filelock>=3.19.1",
     "identify>=2.6.13",
-    "maleo-types>=0.0.8",
+    "maleo-types>=0.0.12",
     "mypy_extensions>=1.1.0",
     "nodeenv>=1.9.1",
     "packaging>=25.0",
     "pathspec>=0.12.1",
     "platformdirs>=4.4.0",
     "pre_commit>=4.3.0",
+    "pydantic>=2.12.2",
+    "pydantic_core>=2.41.4",
     "PyYAML>=6.0.2",
+    "typing-inspection>=0.4.2",
+    "typing_extensions>=4.15.0",
     "virtualenv>=20.34.0",
 ]
 

maleo_enums-0.0.32/src/cardinality.py

@@ -0,0 +1,98 @@
+from enum import StrEnum
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Sequence, TypeVar
+from maleo.types.string import ListOfStrs
+
+
+class Cardinality(StrEnum):
+    MULTIPLE = "multiple"
+    SINGLE = "single"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+
+CardinalityT = TypeVar("CardinalityT", bound=Cardinality)
+OptCardinality = Cardinality | None
+OptCardinalityT = TypeVar("OptCardinalityT", bound=OptCardinality)
+
+
+class CardinalityMixin(BaseModel, Generic[OptCardinalityT]):
+    cardinality: Annotated[OptCardinalityT, Field(..., description="Cardinality")]
+
+
+ListOfCardinalities = list[Cardinality]
+ListOfCardinalitiesT = TypeVar("ListOfCardinalitiesT", bound=ListOfCardinalities)
+OptListOfCardinalities = ListOfCardinalities | None
+OptListOfCardinalitiesT = TypeVar(
+    "OptListOfCardinalitiesT", bound=OptListOfCardinalities
+)
+
+
+class CardinalitiesMixin(BaseModel, Generic[OptListOfCardinalitiesT]):
+    cardinalities: Annotated[
+        OptListOfCardinalitiesT, Field(..., description="Cardinalities")
+    ]
+
+
+SeqOfCardinalities = Sequence[Cardinality]
+SeqOfCardinalitiesT = TypeVar("SeqOfCardinalitiesT", bound=SeqOfCardinalities)
+OptSeqOfCardinalities = SeqOfCardinalities | None
+OptSeqOfCardinalitiesT = TypeVar("OptSeqOfCardinalitiesT", bound=OptSeqOfCardinalities)
+
+
+class Relationship(StrEnum):
+    # One origin
+    ONE_TO_ONE = "one_to_one"
+    ONE_TO_OPTIONAL_ONE = "one_to_optional_one"
+    ONE_TO_MANY = "one_to_many"
+    ONE_TO_OPTIONAL_MANY = "one_to_optional_many"
+    # Opt one origin
+    OPTIONAL_ONE_TO_ONE = "optional_one_to_one"
+    OPTIONAL_ONE_TO_OPTIONAL_ONE = "optional_one_to_optional_one"
+    OPTIONAL_ONE_TO_MANY = "optional_one_to_many"
+    OPTIONAL_ONE_TO_OPTIONAL_MANY = "optional_one_to_optional_many"
+    # Many origin
+    MANY_TO_ONE = "many_to_one"
+    MANY_TO_OPTIONAL_ONE = "many_to_optional_one"
+    MANY_TO_MANY = "many_to_many"
+    MANY_TO_OPTIONAL_MANY = "many_to_optional_many"
+    # Opt many origin
+    OPTIONAL_MANY_TO_ONE = "optional_many_to_one"
+    OPTIONAL_MANY_TO_OPTIONAL_ONE = "optional_many_to_optional_one"
+    OPTIONAL_MANY_TO_MANY = "optional_many_to_many"
+    OPTIONAL_MANY_TO_OPTIONAL_MANY = "optional_many_to_optional_many"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+
+RelationshipT = TypeVar("RelationshipT", bound=Relationship)
+OptRelationship = Relationship | None
+OptRelationshipT = TypeVar("OptRelationshipT", bound=OptRelationship)
+
+
+class RelationshipMixin(BaseModel, Generic[OptRelationshipT]):
+    relationship: Annotated[OptRelationshipT, Field(..., description="Relationship")]
+
+
+ListOfRelationships = list[Relationship]
+ListOfRelationshipsT = TypeVar("ListOfRelationshipsT", bound=ListOfRelationships)
+OptListOfRelationships = ListOfRelationships | None
+OptListOfRelationshipsT = TypeVar(
+    "OptListOfRelationshipsT", bound=OptListOfRelationships
+)
+
+
+class RelationshipsMixin(BaseModel, Generic[OptListOfRelationshipsT]):
+    relationships: Annotated[
+        OptListOfRelationshipsT, Field(..., description="Relationships")
+    ]
+
+
+SeqOfRelationships = Sequence[Relationship]
+SeqOfRelationshipsT = TypeVar("SeqOfRelationshipsT", bound=SeqOfRelationships)
+OptSeqOfRelationships = SeqOfRelationships | None
+OptSeqOfRelationshipsT = TypeVar("OptSeqOfRelationshipsT", bound=OptSeqOfRelationships)

{maleo_enums-0.0.28 → maleo_enums-0.0.32}/src/connection.py

@@ -1,6 +1,7 @@
 from enum import StrEnum
-from typing import List, Optional, Sequence, TypeVar, Union
-from maleo.types.string import ListOfStrings
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Sequence, TypeVar
+from maleo.types.string import ListOfStrs
 
 
 class Scheme(StrEnum):
@@ -10,23 +11,33 @@ class Scheme(StrEnum):
     WSS = "wss"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 SchemeT = TypeVar("SchemeT", bound=Scheme)
-OptionalScheme = Optional[Scheme]
-OptionalSchemeT = TypeVar("OptionalSchemeT", bound=OptionalScheme)
-ListOfSchemes = List[Scheme]
+OptScheme = Scheme | None
+OptSchemeT = TypeVar("OptSchemeT", bound=OptScheme)
+
+
+class SchemeMixin(BaseModel, Generic[OptSchemeT]):
+    scheme: Annotated[OptSchemeT, Field(..., description="Scheme")]
+
+
+ListOfSchemes = list[Scheme]
 ListOfSchemesT = TypeVar("ListOfSchemesT", bound=ListOfSchemes)
-OptionalListOfSchemes = Optional[ListOfSchemes]
-OptionalListOfSchemesT = TypeVar("OptionalListOfSchemesT", bound=OptionalListOfSchemes)
-SequenceOfSchemes = Sequence[Scheme]
-SequenceOfSchemesT = TypeVar("SequenceOfSchemesT", bound=SequenceOfSchemes)
-OptionalSequenceOfSchemes = Optional[SequenceOfSchemes]
-OptionalSequenceOfSchemesT = TypeVar(
-    "OptionalSequenceOfSchemesT", bound=OptionalSequenceOfSchemes
-)
+OptListOfSchemes = ListOfSchemes | None
+OptListOfSchemesT = TypeVar("OptListOfSchemesT", bound=OptListOfSchemes)
+
+
+class SchemesMixin(BaseModel, Generic[OptListOfSchemesT]):
+    schemes: Annotated[OptListOfSchemesT, Field(..., description="Schemes")]
+
+
+SeqOfSchemes = Sequence[Scheme]
+SeqOfSchemesT = TypeVar("SeqOfSchemesT", bound=SeqOfSchemes)
+OptSeqOfSchemes = SeqOfSchemes | None
+OptSeqOfSchemesT = TypeVar("OptSeqOfSchemesT", bound=OptSeqOfSchemes)
 
 
 class Protocol(StrEnum):
@@ -34,11 +45,11 @@ class Protocol(StrEnum):
     WEBSOCKET = "websocket"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
     @classmethod
-    def from_scheme(cls, scheme: Union[Scheme, str]) -> "Protocol":
+    def from_scheme(cls, scheme: Scheme | str) -> "Protocol":
         # Normalize to Scheme if it's a string
         if isinstance(scheme, str):
             try:
@@ -53,6 +64,31 @@ class Protocol(StrEnum):
         raise ValueError(f"Unknown scheme: {scheme}")
 
 
+ProtocolT = TypeVar("ProtocolT", bound=Protocol)
+OptProtocol = Protocol | None
+OptProtocolT = TypeVar("OptProtocolT", bound=OptProtocol)
+
+
+class ProtocolMixin(BaseModel, Generic[OptProtocolT]):
+    method: Annotated[OptProtocolT, Field(..., description="Protocol")]
+
+
+ListOfProtocols = list[Protocol]
+ListOfProtocolsT = TypeVar("ListOfProtocolsT", bound=ListOfProtocols)
+OptListOfProtocols = ListOfProtocols | None
+OptListOfProtocolsT = TypeVar("OptListOfProtocolsT", bound=OptListOfProtocols)
+
+
+class ProtocolsMixin(BaseModel, Generic[OptListOfProtocolsT]):
+    methods: Annotated[OptListOfProtocolsT, Field(..., description="Protocols")]
+
+
+SeqOfProtocols = Sequence[Protocol]
+SeqOfProtocolsT = TypeVar("SeqOfProtocolsT", bound=SeqOfProtocols)
+OptSeqOfProtocols = SeqOfProtocols | None
+OptSeqOfProtocolsT = TypeVar("OptSeqOfProtocolsT", bound=OptSeqOfProtocols)
+
+
 class Method(StrEnum):
     GET = "GET"
     POST = "POST"
@@ -62,23 +98,33 @@ class Method(StrEnum):
     OPTIONS = "OPTIONS"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 MethodT = TypeVar("MethodT", bound=Method)
-OptionalMethod = Optional[Method]
-OptionalMethodT = TypeVar("OptionalMethodT", bound=OptionalMethod)
-ListOfMethods = List[Method]
+OptMethod = Method | None
+OptMethodT = TypeVar("OptMethodT", bound=OptMethod)
+
+
+class MethodMixin(BaseModel, Generic[OptMethodT]):
+    method: Annotated[OptMethodT, Field(..., description="Method")]
+
+
+ListOfMethods = list[Method]
 ListOfMethodsT = TypeVar("ListOfMethodsT", bound=ListOfMethods)
-OptionalListOfMethods = Optional[ListOfMethods]
-OptionalListOfMethodsT = TypeVar("OptionalListOfMethodsT", bound=OptionalListOfMethods)
-SequenceOfMethods = Sequence[Method]
-SequenceOfMethodsT = TypeVar("SequenceOfMethodsT", bound=SequenceOfMethods)
-OptionalSequenceOfMethods = Optional[SequenceOfMethods]
-OptionalSequenceOfMethodsT = TypeVar(
-    "OptionalSequenceOfMethodsT", bound=OptionalSequenceOfMethods
-)
+OptListOfMethods = ListOfMethods | None
+OptListOfMethodsT = TypeVar("OptListOfMethodsT", bound=OptListOfMethods)
+
+
+class MethodsMixin(BaseModel, Generic[OptListOfMethodsT]):
+    methods: Annotated[OptListOfMethodsT, Field(..., description="Methods")]
+
+
+SeqOfMethods = Sequence[Method]
+SeqOfMethodsT = TypeVar("SeqOfMethodsT", bound=SeqOfMethods)
+OptSeqOfMethods = SeqOfMethods | None
+OptSeqOfMethodsT = TypeVar("OptSeqOfMethodsT", bound=OptSeqOfMethods)
 
 
 class Header(StrEnum):
@@ -165,20 +211,30 @@ class Header(StrEnum):
     X_NEW_AUTHORIZATION = "x-new-authorization"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 HeaderT = TypeVar("HeaderT", bound=Header)
-OptionalHeader = Optional[Header]
-OptionalHeaderT = TypeVar("OptionalHeaderT", bound=OptionalHeader)
-ListOfHeaders = List[Header]
+OptHeader = Header | None
+OptHeaderT = TypeVar("OptHeaderT", bound=OptHeader)
+
+
+class HeaderMixin(BaseModel, Generic[OptHeaderT]):
+    header: Annotated[OptHeaderT, Field(..., description="Header")]
+
+
+ListOfHeaders = list[Header]
 ListOfHeadersT = TypeVar("ListOfHeadersT", bound=ListOfHeaders)
-OptionalListOfHeaders = Optional[ListOfHeaders]
-OptionalListOfHeadersT = TypeVar("OptionalListOfHeadersT", bound=OptionalListOfHeaders)
-SequenceOfHeaders = Sequence[Header]
-SequenceOfHeadersT = TypeVar("SequenceOfHeadersT", bound=SequenceOfHeaders)
-OptionalSequenceOfHeaders = Optional[SequenceOfHeaders]
-OptionalSequenceOfHeadersT = TypeVar(
-    "OptionalSequenceOfHeadersT", bound=OptionalSequenceOfHeaders
-)
+OptListOfHeaders = ListOfHeaders | None
+OptListOfHeadersT = TypeVar("OptListOfHeadersT", bound=OptListOfHeaders)
+
+
+class HeadersMixin(BaseModel, Generic[OptListOfHeadersT]):
+    headers: Annotated[OptListOfHeadersT, Field(..., description="Headers")]
+
+
+SeqOfHeaders = Sequence[Header]
+SeqOfHeadersT = TypeVar("SeqOfHeadersT", bound=SeqOfHeaders)
+OptSeqOfHeaders = SeqOfHeaders | None
+OptSeqOfHeadersT = TypeVar("OptSeqOfHeadersT", bound=OptSeqOfHeaders)

maleo_enums-0.0.32/src/environment.py

@@ -0,0 +1,41 @@
+from enum import StrEnum
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Sequence, TypeVar
+from maleo.types.string import ListOfStrs
+
+
+class Environment(StrEnum):
+    LOCAL = "local"
+    STAGING = "staging"
+    PRODUCTION = "production"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+
+EnvironmentT = TypeVar("EnvironmentT", bound=Environment)
+OptEnvironment = Environment | None
+OptEnvironmentT = TypeVar("OptEnvironmentT", bound=OptEnvironment)
+
+
+class EnvironmentMixin(BaseModel, Generic[OptEnvironmentT]):
+    environment: Annotated[OptEnvironmentT, Field(..., description="Environment")]
+
+
+ListOfEnvironments = list[Environment]
+ListOfEnvironmentsT = TypeVar("ListOfEnvironmentsT", bound=ListOfEnvironments)
+OptListOfEnvironments = ListOfEnvironments | None
+OptListOfEnvironmentsT = TypeVar("OptListOfEnvironmentsT", bound=OptListOfEnvironments)
+
+
+class EnvironmentsMixin(BaseModel, Generic[OptListOfEnvironmentsT]):
+    environments: Annotated[
+        OptListOfEnvironmentsT, Field(..., description="Environments")
+    ]
+
+
+SeqOfEnvironments = Sequence[Environment]
+SeqOfEnvironmentsT = TypeVar("SeqOfEnvironmentsT", bound=SeqOfEnvironments)
+OptSeqOfEnvironments = SeqOfEnvironments | None
+OptSeqOfEnvironmentsT = TypeVar("OptSeqOfEnvironmentsT", bound=OptSeqOfEnvironments)

maleo_enums-0.0.32/src/expiration.py

@@ -0,0 +1,51 @@
+from enum import IntEnum
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Sequence, TypeVar
+from maleo.types.integer import ListOfInts
+
+
+class Expiration(IntEnum):
+    EXP_15SC = int(15)
+    EXP_30SC = int(30)
+    EXP_1MN = int(1 * 60)
+    EXP_5MN = int(5 * 60)
+    EXP_10MN = int(10 * 60)
+    EXP_15MN = int(15 * 60)
+    EXP_30MN = int(30 * 60)
+    EXP_1HR = int(1 * 60 * 60)
+    EXP_6HR = int(6 * 60 * 60)
+    EXP_12HR = int(12 * 60 * 60)
+    EXP_1DY = int(1 * 24 * 60 * 60)
+    EXP_3DY = int(3 * 24 * 60 * 60)
+    EXP_1WK = int(1 * 7 * 24 * 60 * 60)
+    EXP_2WK = int(2 * 7 * 24 * 60 * 60)
+    EXP_1MO = int(1 * 30 * 24 * 60 * 60)
+
+    @classmethod
+    def choices(cls) -> ListOfInts:
+        return [e.value for e in cls]
+
+
+ExpirationT = TypeVar("ExpirationT", bound=Expiration)
+OptExpiration = Expiration | None
+OptExpirationT = TypeVar("OptExpirationT", bound=OptExpiration)
+
+
+class ExpirationMixin(BaseModel, Generic[OptExpirationT]):
+    expiration: Annotated[OptExpirationT, Field(..., description="Expiration")]
+
+
+ListOfExpirations = list[Expiration]
+ListOfExpirationsT = TypeVar("ListOfExpirationsT", bound=ListOfExpirations)
+OptListOfExpirations = ListOfExpirations | None
+OptListOfExpirationsT = TypeVar("OptListOfExpirationsT", bound=OptListOfExpirations)
+
+
+class ExpirationsMixin(BaseModel, Generic[OptListOfExpirationsT]):
+    expirations: Annotated[OptListOfExpirationsT, Field(..., description="Expirations")]
+
+
+SeqOfExpirations = Sequence[Expiration]
+SeqOfExpirationsT = TypeVar("SeqOfExpirationsT", bound=SeqOfExpirations)
+OptSeqOfExpirations = SeqOfExpirations | None
+OptSeqOfExpirationsT = TypeVar("OptSeqOfExpirationsT", bound=OptSeqOfExpirations)

maleo_enums-0.0.32/src/identity.py

@@ -0,0 +1,75 @@
+from enum import StrEnum
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Sequence, TypeVar
+from maleo.types.string import ListOfStrs
+
+
+class BloodType(StrEnum):
+    A = "a"
+    B = "b"
+    AB = "ab"
+    O = "o"  # noqa: E741
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+
+BloodTypeT = TypeVar("BloodTypeT", bound=BloodType)
+OptBloodType = BloodType | None
+OptBloodTypeT = TypeVar("OptBloodTypeT", bound=OptBloodType)
+
+
+class BloodTypeMixin(BaseModel, Generic[OptBloodTypeT]):
+    blood_type: Annotated[OptBloodTypeT, Field(..., description="Blood Type")]
+
+
+ListOfBloodTypes = list[BloodType]
+ListOfBloodTypesT = TypeVar("ListOfBloodTypesT", bound=ListOfBloodTypes)
+OptListOfBloodTypes = ListOfBloodTypes | None
+OptListOfBloodTypesT = TypeVar("OptListOfBloodTypesT", bound=OptListOfBloodTypes)
+
+
+class BloodTypesMixin(BaseModel, Generic[OptListOfBloodTypesT]):
+    blood_types: Annotated[OptListOfBloodTypesT, Field(..., description="Blood Types")]
+
+
+SeqOfBloodTypes = Sequence[BloodType]
+SeqOfBloodTypesT = TypeVar("SeqOfBloodTypesT", bound=SeqOfBloodTypes)
+OptSeqOfBloodTypes = SeqOfBloodTypes | None
+OptSeqOfBloodTypesT = TypeVar("OptSeqOfBloodTypesT", bound=OptSeqOfBloodTypes)
+
+
+class Gender(StrEnum):
+    UNDISCLOSED = "undisclosed"
+    FEMALE = "female"
+    MALE = "male"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+
+GenderT = TypeVar("GenderT", bound=Gender)
+OptGender = Gender | None
+OptGenderT = TypeVar("OptGenderT", bound=OptGender)
+
+
+class GenderMixin(BaseModel, Generic[OptGenderT]):
+    gender: Annotated[OptGenderT, Field(..., description="Gender")]
+
+
+ListOfGenders = list[Gender]
+ListOfGendersT = TypeVar("ListOfGendersT", bound=ListOfGenders)
+OptListOfGenders = ListOfGenders | None
+OptListOfGendersT = TypeVar("OptListOfGendersT", bound=OptListOfGenders)
+
+
+class GendersMixin(BaseModel, Generic[OptListOfGendersT]):
+    genders: Annotated[OptListOfGendersT, Field(..., description="Genders")]
+
+
+SeqOfGenders = Sequence[Gender]
+SeqOfGendersT = TypeVar("SeqOfGendersT", bound=SeqOfGenders)
+OptSeqOfGenders = SeqOfGenders | None
+OptSeqOfGendersT = TypeVar("OptSeqOfGendersT", bound=OptSeqOfGenders)