maleo-enums 0.0.28__py3-none-any.whl → 0.0.32__py3-none-any.whl

maleo/enums/cardinality.py

@@ -1,6 +1,7 @@
 from enum import StrEnum
-from typing import List, Optional, Sequence, TypeVar
-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 Cardinality(StrEnum):
@@ -8,36 +9,46 @@ class Cardinality(StrEnum):
     SINGLE = "single"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 CardinalityT = TypeVar("CardinalityT", bound=Cardinality)
-OptionalCardinality = Optional[Cardinality]
-OptionalCardinalityT = TypeVar("OptionalCardinalityT", bound=OptionalCardinality)
-ListOfCardinalities = List[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)
-OptionalListOfCardinalities = Optional[ListOfCardinalities]
-OptionalListOfCardinalitiesT = TypeVar(
-    "OptionalListOfCardinalitiesT", bound=OptionalListOfCardinalities
-)
-SequenceOfCardinalities = Sequence[Cardinality]
-SequenceOfCardinalitiesT = TypeVar(
-    "SequenceOfCardinalitiesT", bound=SequenceOfCardinalities
-)
-OptionalSequenceOfCardinalities = Optional[SequenceOfCardinalities]
-OptionalSequenceOfCardinalitiesT = TypeVar(
-    "OptionalSequenceOfCardinalitiesT", bound=OptionalSequenceOfCardinalities
+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"
-    # Optional one origin
+    # 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"
@@ -47,31 +58,41 @@ class Relationship(StrEnum):
     MANY_TO_OPTIONAL_ONE = "many_to_optional_one"
     MANY_TO_MANY = "many_to_many"
     MANY_TO_OPTIONAL_MANY = "many_to_optional_many"
-    # Optional many origin
+    # 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) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 RelationshipT = TypeVar("RelationshipT", bound=Relationship)
-OptionalRelationship = Optional[Relationship]
-OptionalRelationshipT = TypeVar("OptionalRelationshipT", bound=OptionalRelationship)
-ListOfRelationships = List[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)
-OptionalListOfRelationships = Optional[ListOfRelationships]
-OptionalListOfRelationshipsT = TypeVar(
-    "OptionalListOfRelationshipsT", bound=OptionalListOfRelationships
-)
-SequenceOfRelationships = Sequence[Relationship]
-SequenceOfRelationshipsT = TypeVar(
-    "SequenceOfRelationshipsT", bound=SequenceOfRelationships
-)
-OptionalSequenceOfRelationships = Optional[SequenceOfRelationships]
-OptionalSequenceOfRelationshipsT = TypeVar(
-    "OptionalSequenceOfRelationshipsT", bound=OptionalSequenceOfRelationships
+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/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/environment.py

@@ -1,6 +1,7 @@
 from enum import StrEnum
-from typing import List, Optional, Sequence, TypeVar
-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 Environment(StrEnum):
@@ -9,24 +10,32 @@ class Environment(StrEnum):
     PRODUCTION = "production"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 EnvironmentT = TypeVar("EnvironmentT", bound=Environment)
-OptionalEnvironment = Optional[Environment]
-OptionalEnvironmentT = TypeVar("OptionalEnvironmentT", bound=OptionalEnvironment)
-ListOfEnvironments = List[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)
-OptionalListOfEnvironments = Optional[ListOfEnvironments]
-OptionalListOfEnvironmentsT = TypeVar(
-    "OptionalListOfEnvironmentsT", bound=OptionalListOfEnvironments
-)
-SequenceOfEnvironments = Sequence[Environment]
-SequenceOfEnvironmentsT = TypeVar(
-    "SequenceOfEnvironmentsT", bound=SequenceOfEnvironments
-)
-OptionalSequenceOfEnvironments = Optional[SequenceOfEnvironments]
-OptionalSequenceOfEnvironmentsT = TypeVar(
-    "OptionalSequenceOfEnvironmentsT", bound=OptionalSequenceOfEnvironments
-)
+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/expiration.py

@@ -1,6 +1,7 @@
 from enum import IntEnum
-from typing import List, Optional, Sequence, TypeVar
-from maleo.types.integer import ListOfIntegers
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Sequence, TypeVar
+from maleo.types.integer import ListOfInts
 
 
 class Expiration(IntEnum):
@@ -21,22 +22,30 @@ class Expiration(IntEnum):
     EXP_1MO = int(1 * 30 * 24 * 60 * 60)
 
     @classmethod
-    def choices(cls) -> ListOfIntegers:
+    def choices(cls) -> ListOfInts:
         return [e.value for e in cls]
 
 
 ExpirationT = TypeVar("ExpirationT", bound=Expiration)
-OptionalExpiration = Optional[Expiration]
-OptionalExpirationT = TypeVar("OptionalExpirationT", bound=OptionalExpiration)
-ListOfExpirations = List[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)
-OptionalListOfExpirations = Optional[ListOfExpirations]
-OptionalListOfExpirationsT = TypeVar(
-    "OptionalListOfExpirationsT", bound=OptionalListOfExpirations
-)
-SequenceOfExpirations = Sequence[Expiration]
-SequenceOfExpirationsT = TypeVar("SequenceOfExpirationsT", bound=SequenceOfExpirations)
-OptionalSequenceOfExpirations = Optional[SequenceOfExpirations]
-OptionalSequenceOfExpirationsT = TypeVar(
-    "OptionalSequenceOfExpirationsT", bound=OptionalSequenceOfExpirations
-)
+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/identity.py

@@ -1,6 +1,7 @@
 from enum import StrEnum
-from typing import List, Optional, Sequence, TypeVar
-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 BloodType(StrEnum):
@@ -10,25 +11,33 @@ class BloodType(StrEnum):
     O = "o"  # noqa: E741
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 BloodTypeT = TypeVar("BloodTypeT", bound=BloodType)
-OptionalBloodType = Optional[BloodType]
-OptionalBloodTypeT = TypeVar("OptionalBloodTypeT", bound=OptionalBloodType)
-ListOfBloodTypes = List[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)
-OptionalListOfBloodTypes = Optional[ListOfBloodTypes]
-OptionalListOfBloodTypesT = TypeVar(
-    "OptionalListOfBloodTypesT", bound=OptionalListOfBloodTypes
-)
-SequenceOfBloodTypes = Sequence[BloodType]
-SequenceOfBloodTypesT = TypeVar("SequenceOfBloodTypesT", bound=SequenceOfBloodTypes)
-OptionalSequenceOfBloodTypes = Optional[SequenceOfBloodTypes]
-OptionalSequenceOfBloodTypesT = TypeVar(
-    "OptionalSequenceOfBloodTypesT", bound=OptionalSequenceOfBloodTypes
-)
+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):
@@ -37,20 +46,30 @@ class Gender(StrEnum):
     MALE = "male"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 GenderT = TypeVar("GenderT", bound=Gender)
-OptionalGender = Optional[Gender]
-OptionalGenderT = TypeVar("OptionalGenderT", bound=OptionalGender)
-ListOfGenders = List[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)
-OptionalListOfGenders = Optional[ListOfGenders]
-OptionalListOfGendersT = TypeVar("OptionalListOfGendersT", bound=OptionalListOfGenders)
-SequenceOfGenders = Sequence[Gender]
-SequenceOfGendersT = TypeVar("SequenceOfGendersT", bound=SequenceOfGenders)
-OptionalSequenceOfGenders = Optional[SequenceOfGenders]
-OptionalSequenceOfGendersT = TypeVar(
-    "OptionalSequenceOfGendersT", bound=OptionalSequenceOfGenders
-)
+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)