maleo-enums 0.0.27__py3-none-any.whl → 0.0.30__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,17 +9,37 @@ 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]
-OptionalListOfCardinalities = Optional[ListOfCardinalities]
-SequenceOfCardinalities = Sequence[Cardinality]
-OptionalSequenceOfCardinalities = Optional[SequenceOfCardinalities]
+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):
@@ -27,7 +48,7 @@ class Relationship(StrEnum):
     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"
@@ -37,21 +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]
-OptionalListOfRelationships = Optional[ListOfRelationships]
-SequenceOfRelationships = Sequence[Relationship]
-OptionalSequenceOfRelationships = Optional[SequenceOfRelationships]
+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/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,17 +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]
-OptionalListOfSchemes = Optional[ListOfSchemes]
-SequenceOfSchemes = Sequence[Scheme]
-OptionalSequenceOfSchemes = Optional[SequenceOfSchemes]
+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)
+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):
@@ -28,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:
@@ -56,17 +73,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]
-OptionalListOfMethods = Optional[ListOfMethods]
-SequenceOfMethods = Sequence[Method]
-OptionalSequenceOfMethods = Optional[SequenceOfMethods]
+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)
+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):
@@ -153,14 +186,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]
-OptionalListOfHeaders = Optional[ListOfHeaders]
-SequenceOfHeaders = Sequence[Header]
-OptionalSequenceOfHeaders = Optional[SequenceOfHeaders]
+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)
+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,14 +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]
-OptionalListOfEnvironments = Optional[ListOfEnvironments]
-SequenceOfEnvironments = Sequence[Environment]
-OptionalSequenceOfEnvironments = Optional[SequenceOfEnvironments]
+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/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,14 +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]
-OptionalListOfExpirations = Optional[ListOfExpirations]
-SequenceOfExpirations = Sequence[Expiration]
-OptionalSequenceOfExpirations = Optional[SequenceOfExpirations]
+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/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,17 +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]
-OptionalListOfBloodTypes = Optional[ListOfBloodTypes]
-SequenceOfBloodTypes = Sequence[BloodType]
-OptionalSequenceOfBloodTypes = Optional[SequenceOfBloodTypes]
+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):
@@ -29,14 +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]
-OptionalListOfGenders = Optional[ListOfGenders]
-SequenceOfGenders = Sequence[Gender]
-OptionalSequenceOfGenders = Optional[SequenceOfGenders]
+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)

maleo/enums/medical.py

@@ -1,9 +1,10 @@
 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 Role(StrEnum):
+class MedicalRole(StrEnum):
     # Level 1: Director category
     DIRECTOR = "director"
     PRESIDENT = "president"
@@ -72,34 +73,94 @@ class Role(StrEnum):
     NUTRITIONIST = "nutritionist"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-RoleT = TypeVar("RoleT", bound=Role)
-OptionalRole = Optional[Role]
-OptionalRoleT = TypeVar("OptionalRoleT", bound=OptionalRole)
-ListOfRoles = List[Role]
-OptionalListOfRoles = Optional[ListOfRoles]
-SequenceOfRoles = Sequence[Role]
-OptionalSequenceOfRoles = Optional[SequenceOfRoles]
+MedicalRoleT = TypeVar("MedicalRoleT", bound=MedicalRole)
+OptMedicalRole = MedicalRole | None
+OptMedicalRoleT = TypeVar("OptMedicalRoleT", bound=OptMedicalRole)
 
 
-class Service(StrEnum):
+class SimpleMedicalRoleMixin(BaseModel, Generic[OptMedicalRoleT]):
+    role: Annotated[OptMedicalRoleT, Field(..., description="Medical Role")]
+
+
+class FullMedicalRoleMixin(BaseModel, Generic[OptMedicalRoleT]):
+    medical_role: Annotated[OptMedicalRoleT, Field(..., description="Medical Role")]
+
+
+ListOfMedicalRoles = list[MedicalRole]
+ListOfMedicalRolesT = TypeVar("ListOfMedicalRolesT", bound=ListOfMedicalRoles)
+OptListOfMedicalRoles = ListOfMedicalRoles | None
+OptListOfMedicalRolesT = TypeVar("OptListOfMedicalRolesT", bound=OptListOfMedicalRoles)
+
+
+class SimpleMedicalRolesMixin(BaseModel, Generic[OptListOfMedicalRolesT]):
+    roles: Annotated[OptListOfMedicalRolesT, Field(..., description="Medical Roles")]
+
+
+class FullMedicalRolesMixin(BaseModel, Generic[OptListOfMedicalRolesT]):
+    medical_roles: Annotated[
+        OptListOfMedicalRolesT, Field(..., description="Medical Roles")
+    ]
+
+
+SeqOfMedicalRoles = Sequence[MedicalRole]
+SeqOfMedicalRolesT = TypeVar("SeqOfMedicalRolesT", bound=SeqOfMedicalRoles)
+OptSeqOfMedicalRoles = SeqOfMedicalRoles | None
+OptSeqOfMedicalRolesT = TypeVar("OptSeqOfMedicalRolesT", bound=OptSeqOfMedicalRoles)
+
+
+class MedicalService(StrEnum):
     EMERGENCY = "emergency"
     INPATIENT = "inpatient"
     INTENSIVE = "intensive"
     OUTPATIENT = "outpatient"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-ServiceT = TypeVar("ServiceT", bound=Service)
-OptionalService = Optional[Service]
-OptionalServiceT = TypeVar("OptionalServiceT", bound=OptionalService)
-ListOfServices = List[Service]
-OptionalListOfServices = Optional[ListOfServices]
-SequenceOfServices = Sequence[Service]
-OptionalSequenceOfServices = Optional[SequenceOfServices]
+MedicalServiceT = TypeVar("MedicalServiceT", bound=MedicalService)
+OptMedicalService = MedicalService | None
+OptMedicalServiceT = TypeVar("OptMedicalServiceT", bound=OptMedicalService)
+
+
+class SimpleMedicalServiceMixin(BaseModel, Generic[OptMedicalServiceT]):
+    service: Annotated[OptMedicalServiceT, Field(..., description="Medical Service")]
+
+
+class FullMedicalServiceMixin(BaseModel, Generic[OptMedicalServiceT]):
+    medical_service: Annotated[
+        OptMedicalServiceT, Field(..., description="Medical Service")
+    ]
+
+
+ListOfMedicalServices = list[MedicalService]
+ListOfMedicalServicesT = TypeVar("ListOfMedicalServicesT", bound=ListOfMedicalServices)
+OptListOfMedicalServices = ListOfMedicalServices | None
+OptListOfMedicalServicesT = TypeVar(
+    "OptListOfMedicalServicesT", bound=OptListOfMedicalServices
+)
+
+
+class SimpleMedicalServicesMixin(BaseModel, Generic[OptListOfMedicalServicesT]):
+    services: Annotated[
+        OptListOfMedicalServicesT, Field(..., description="Medical Services")
+    ]
+
+
+class FullMedicalServicesMixin(BaseModel, Generic[OptListOfMedicalServicesT]):
+    medical_services: Annotated[
+        OptListOfMedicalServicesT, Field(..., description="Medical Services")
+    ]
+
+
+SeqOfMedicalServices = Sequence[MedicalService]
+SeqOfMedicalServicesT = TypeVar("SeqOfMedicalServicesT", bound=SeqOfMedicalServices)
+OptSeqOfMedicalServices = SeqOfMedicalServices | None
+OptSeqOfMedicalServicesT = TypeVar(
+    "OptSeqOfMedicalServicesT", bound=OptSeqOfMedicalServices
+)

maleo/enums/order.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 Order(StrEnum):
@@ -8,14 +9,30 @@ class Order(StrEnum):
     DESC = "desc"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 OrderT = TypeVar("OrderT", bound=Order)
-OptionalOrder = Optional[Order]
-OptionalOrderT = TypeVar("OptionalOrderT", bound=OptionalOrder)
-ListOfOrders = List[Order]
-OptionalListOfOrders = Optional[ListOfOrders]
-SequenceOfOrders = Sequence[Order]
-OptionalSequenceOfOrders = Optional[SequenceOfOrders]
+OptOrder = Order | None
+OptOrderT = TypeVar("OptOrderT", bound=OptOrder)
+
+
+class OrderMixin(BaseModel, Generic[OptOrderT]):
+    order: Annotated[OptOrderT, Field(..., description="Order")]
+
+
+ListOfOrders = list[Order]
+ListOfOrdersT = TypeVar("ListOfOrdersT", bound=ListOfOrders)
+OptListOfOrders = ListOfOrders | None
+OptListOfOrdersT = TypeVar("OptListOfOrdersT", bound=OptListOfOrders)
+
+
+class OrdersMixin(BaseModel, Generic[OptListOfOrdersT]):
+    orders: Annotated[OptListOfOrdersT, Field(..., description="Orders")]
+
+
+SeqOfOrders = Sequence[Order]
+SeqOfOrdersT = TypeVar("SeqOfOrdersT", bound=SeqOfOrders)
+OptSeqOfOrders = SeqOfOrders | None
+OptSeqOfOrdersT = TypeVar("OptSeqOfOrdersT", bound=OptSeqOfOrders)