maleo-enums 0.0.27__py3-none-any.whl → 0.0.30__py3-none-any.whl

maleo/enums/organization.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 OrganizationType(StrEnum):
@@ -17,7 +18,7 @@ class OrganizationType(StrEnum):
     INSURANCE_PROVIDER = "insurance_provider"
     INTERNAL = "internal"
     LABORATORY = "laboratory"
-    MEDICAL_GROUP = "medical_group"
+    MEDICAL_GROUP = "organization_group"
     NETWORK = "network"
     PARTNER = "partner"
     PHARMACY = "pharmacy"
@@ -32,22 +33,58 @@ class OrganizationType(StrEnum):
     VENDOR = "vendor"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 OrganizationTypeT = TypeVar("OrganizationTypeT", bound=OrganizationType)
-OptionalOrganizationType = Optional[OrganizationType]
-OptionalOrganizationTypeT = TypeVar(
-    "OptionalOrganizationTypeT", bound=OptionalOrganizationType
+OptOrganizationType = OrganizationType | None
+OptOrganizationTypeT = TypeVar("OptOrganizationTypeT", bound=OptOrganizationType)
+
+
+class SimpleOrganizationTypeMixin(BaseModel, Generic[OptOrganizationTypeT]):
+    type: Annotated[OptOrganizationTypeT, Field(..., description="Organization Type")]
+
+
+class FullOrganizationTypeMixin(BaseModel, Generic[OptOrganizationTypeT]):
+    organization_type: Annotated[
+        OptOrganizationTypeT, Field(..., description="Organization Type")
+    ]
+
+
+ListOfOrganizationTypes = list[OrganizationType]
+ListOfOrganizationTypesT = TypeVar(
+    "ListOfOrganizationTypesT", bound=ListOfOrganizationTypes
+)
+OptListOfOrganizationTypes = ListOfOrganizationTypes | None
+OptListOfOrganizationTypesT = TypeVar(
+    "OptListOfOrganizationTypesT", bound=OptListOfOrganizationTypes
+)
+
+
+class SimpleOrganizationTypesMixin(BaseModel, Generic[OptListOfOrganizationTypesT]):
+    types: Annotated[
+        OptListOfOrganizationTypesT, Field(..., description="Organization Types")
+    ]
+
+
+class FullOrganizationTypesMixin(BaseModel, Generic[OptListOfOrganizationTypesT]):
+    organization_types: Annotated[
+        OptListOfOrganizationTypesT, Field(..., description="Organization Types")
+    ]
+
+
+SeqOfOrganizationTypes = Sequence[OrganizationType]
+SeqOfOrganizationTypesT = TypeVar(
+    "SeqOfOrganizationTypesT", bound=SeqOfOrganizationTypes
+)
+OptSeqOfOrganizationTypes = SeqOfOrganizationTypes | None
+OptSeqOfOrganizationTypesT = TypeVar(
+    "OptSeqOfOrganizationTypesT", bound=OptSeqOfOrganizationTypes
 )
-ListOfOrganizationTypes = List[OrganizationType]
-OptionalListOfOrganizationTypes = Optional[ListOfOrganizationTypes]
-SequenceOfOrganizationTypes = Sequence[OrganizationType]
-OptionalSequenceOfOrganizationTypes = Optional[SequenceOfOrganizationTypes]
 
 
-class Relation(StrEnum):
+class OrganizationRelation(StrEnum):
     AFFILIATE = "affiliate"
     APPLICATION = "application"
     BRANCH = "branch"
@@ -61,33 +98,119 @@ class Relation(StrEnum):
     VENDOR = "vendor"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-RelationT = TypeVar("RelationT", bound=Relation)
-OptionalRelation = Optional[Relation]
-OptionalRelationT = TypeVar("OptionalRelationT", bound=OptionalRelation)
-ListOfRelations = List[Relation]
-OptionalListOfRelations = Optional[ListOfRelations]
-SequenceOfRelations = Sequence[Relation]
-OptionalSequenceOfRelations = Optional[SequenceOfRelations]
+OrganizationRelationT = TypeVar("OrganizationRelationT", bound=OrganizationRelation)
+OptOrganizationRelation = OrganizationRelation | None
+OptOrganizationRelationT = TypeVar(
+    "OptOrganizationRelationT", bound=OptOrganizationRelation
+)
+
+
+class SimpleOrganizationRelationMixin(BaseModel, Generic[OptOrganizationRelationT]):
+    relation: Annotated[
+        OptOrganizationRelationT, Field(..., description="Organization Relation")
+    ]
+
+
+class FullOrganizationRelationMixin(BaseModel, Generic[OptOrganizationRelationT]):
+    organization_relation: Annotated[
+        OptOrganizationRelationT, Field(..., description="Organization Relation")
+    ]
+
+
+ListOfOrganizationRelations = list[OrganizationRelation]
+ListOfOrganizationRelationsT = TypeVar(
+    "ListOfOrganizationRelationsT", bound=ListOfOrganizationRelations
+)
+OptListOfOrganizationRelations = ListOfOrganizationRelations | None
+OptListOfOrganizationRelationsT = TypeVar(
+    "OptListOfOrganizationRelationsT", bound=OptListOfOrganizationRelations
+)
+
+
+class SimpleOrganizationRelationsMixin(
+    BaseModel, Generic[OptListOfOrganizationRelationsT]
+):
+    relations: Annotated[
+        OptListOfOrganizationRelationsT,
+        Field(..., description="Organization Relations"),
+    ]
+
+
+class FullOrganizationRelationsMixin(
+    BaseModel, Generic[OptListOfOrganizationRelationsT]
+):
+    organization_relations: Annotated[
+        OptListOfOrganizationRelationsT,
+        Field(..., description="Organization Relations"),
+    ]
+
+
+SeqOfOrganizationRelations = Sequence[OrganizationRelation]
+SeqOfOrganizationRelationsT = TypeVar(
+    "SeqOfOrganizationRelationsT", bound=SeqOfOrganizationRelations
+)
+OptSeqOfOrganizationRelations = SeqOfOrganizationRelations | None
+OptSeqOfOrganizationRelationsT = TypeVar(
+    "OptSeqOfOrganizationRelationsT", bound=OptSeqOfOrganizationRelations
+)
 
 
-class Role(StrEnum):
+class OrganizationRole(StrEnum):
     OWNER = "owner"
     ADMINISTRATOR = "administrator"
     USER = "user"
 
     @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]
+OrganizationRoleT = TypeVar("OrganizationRoleT", bound=OrganizationRole)
+OptOrganizationRole = OrganizationRole | None
+OptOrganizationRoleT = TypeVar("OptOrganizationRoleT", bound=OptOrganizationRole)
+
+
+class SimpleOrganizationRoleMixin(BaseModel, Generic[OptOrganizationRoleT]):
+    role: Annotated[OptOrganizationRoleT, Field(..., description="Organization Role")]
+
+
+class FullOrganizationRoleMixin(BaseModel, Generic[OptOrganizationRoleT]):
+    organization_role: Annotated[
+        OptOrganizationRoleT, Field(..., description="Organization Role")
+    ]
+
+
+ListOfOrganizationRoles = list[OrganizationRole]
+ListOfOrganizationRolesT = TypeVar(
+    "ListOfOrganizationRolesT", bound=ListOfOrganizationRoles
+)
+OptListOfOrganizationRoles = ListOfOrganizationRoles | None
+OptListOfOrganizationRolesT = TypeVar(
+    "OptListOfOrganizationRolesT", bound=OptListOfOrganizationRoles
+)
+
+
+class SimpleOrganizationRolesMixin(BaseModel, Generic[OptListOfOrganizationRolesT]):
+    roles: Annotated[
+        OptListOfOrganizationRolesT, Field(..., description="Organization Roles")
+    ]
+
+
+class FullOrganizationRolesMixin(BaseModel, Generic[OptListOfOrganizationRolesT]):
+    organization_roles: Annotated[
+        OptListOfOrganizationRolesT, Field(..., description="Organization Roles")
+    ]
+
+
+SeqOfOrganizationRoles = Sequence[OrganizationRole]
+SeqOfOrganizationRolesT = TypeVar(
+    "SeqOfOrganizationRolesT", bound=SeqOfOrganizationRoles
+)
+OptSeqOfOrganizationRoles = SeqOfOrganizationRoles | None
+OptSeqOfOrganizationRolesT = TypeVar(
+    "OptSeqOfOrganizationRolesT", bound=OptSeqOfOrganizationRoles
+)

maleo/enums/service.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 ServiceType(StrEnum):
@@ -8,38 +9,102 @@ class ServiceType(StrEnum):
     FRONTEND = "frontend"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 ServiceTypeT = TypeVar("ServiceTypeT", bound=ServiceType)
-OptionalServiceType = Optional[ServiceType]
-OptionalServiceTypeT = TypeVar("OptionalServiceTypeT", bound=OptionalServiceType)
-ListOfServiceTypes = List[ServiceType]
-OptionalListOfServiceTypes = Optional[ListOfServiceTypes]
-SequenceOfServiceTypes = Sequence[ServiceType]
-OptionalSequenceOfServiceTypes = Optional[SequenceOfServiceTypes]
+OptServiceType = ServiceType | None
+OptServiceTypeT = TypeVar("OptServiceTypeT", bound=OptServiceType)
 
 
-class Category(StrEnum):
+class SimpleServiceTypeMixin(BaseModel, Generic[OptServiceTypeT]):
+    type: Annotated[OptServiceTypeT, Field(..., description="Service Type")]
+
+
+class FullServiceTypeMixin(BaseModel, Generic[OptServiceTypeT]):
+    service_type: Annotated[OptServiceTypeT, Field(..., description="Service Type")]
+
+
+ListOfServiceTypes = list[ServiceType]
+ListOfServiceTypesT = TypeVar("ListOfServiceTypesT", bound=ListOfServiceTypes)
+OptListOfServiceTypes = ListOfServiceTypes | None
+OptListOfServiceTypesT = TypeVar("OptListOfServiceTypesT", bound=OptListOfServiceTypes)
+
+
+class SimpleServiceTypesMixin(BaseModel, Generic[OptListOfServiceTypesT]):
+    types: Annotated[OptListOfServiceTypesT, Field(..., description="Service Types")]
+
+
+class FullServiceTypesMixin(BaseModel, Generic[OptListOfServiceTypesT]):
+    service_types: Annotated[
+        OptListOfServiceTypesT, Field(..., description="Service Types")
+    ]
+
+
+SeqOfServiceTypes = Sequence[ServiceType]
+SeqOfServiceTypesT = TypeVar("SeqOfServiceTypesT", bound=SeqOfServiceTypes)
+OptSeqOfServiceTypes = SeqOfServiceTypes | None
+OptSeqOfServiceTypesT = TypeVar("OptSeqOfServiceTypesT", bound=OptSeqOfServiceTypes)
+
+
+class ServiceCategory(StrEnum):
     CORE = "core"
     AI = "ai"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-CategoryT = TypeVar("CategoryT", bound=Category)
-OptionalCategory = Optional[Category]
-OptionalCategoryT = TypeVar("OptionalCategoryT", bound=OptionalCategory)
-ListOfCategories = List[Category]
-OptionalListOfCategories = Optional[ListOfCategories]
-SequenceOfCategories = Sequence[Category]
-OptionalSequenceOfCategories = Optional[SequenceOfCategories]
+ServiceCategoryT = TypeVar("ServiceCategoryT", bound=ServiceCategory)
+OptServiceCategory = ServiceCategory | None
+OptServiceCategoryT = TypeVar("OptServiceCategoryT", bound=OptServiceCategory)
+
+
+class SimpleServiceCategoryMixin(BaseModel, Generic[OptServiceCategoryT]):
+    category: Annotated[OptServiceCategoryT, Field(..., description="Service Category")]
+
+
+class FullServiceCategoryMixin(BaseModel, Generic[OptServiceCategoryT]):
+    service_category: Annotated[
+        OptServiceCategoryT, Field(..., description="Service Category")
+    ]
+
+
+ListOfServiceCategories = list[ServiceCategory]
+ListOfServiceCategoriesT = TypeVar(
+    "ListOfServiceCategoriesT", bound=ListOfServiceCategories
+)
+OptListOfServiceCategories = ListOfServiceCategories | None
+OptListOfServiceCategoriesT = TypeVar(
+    "OptListOfServiceCategoriesT", bound=OptListOfServiceCategories
+)
 
 
-class ShortKey(StrEnum):
+class SimpleServiceCategoriesMixin(BaseModel, Generic[OptListOfServiceCategoriesT]):
+    categories: Annotated[
+        OptListOfServiceCategoriesT, Field(..., description="Service Categories")
+    ]
+
+
+class FullServiceCategoriesMixin(BaseModel, Generic[OptListOfServiceCategoriesT]):
+    service_categories: Annotated[
+        OptListOfServiceCategoriesT, Field(..., description="Service Categories")
+    ]
+
+
+SeqOfServiceCategories = Sequence[ServiceCategory]
+SeqOfServiceCategoriesT = TypeVar(
+    "SeqOfServiceCategoriesT", bound=SeqOfServiceCategories
+)
+OptSeqOfServiceCategories = SeqOfServiceCategories | None
+OptSeqOfServiceCategoriesT = TypeVar(
+    "OptSeqOfServiceCategoriesT", bound=OptSeqOfServiceCategories
+)
+
+
+class ShortServiceKey(StrEnum):
     STUDIO = "studio"
     NEXUS = "nexus"
     TELEMETRY = "telemetry"
@@ -58,20 +123,52 @@ class ShortKey(StrEnum):
     MCU = "mcu"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-ShortKeyT = TypeVar("ShortKeyT", bound=ShortKey)
-OptionalShortKey = Optional[ShortKey]
-OptionalShortKeyT = TypeVar("OptionalShortKeyT", bound=OptionalShortKey)
-ListOfShortKeys = List[ShortKey]
-OptionalListOfShortKeys = Optional[ListOfShortKeys]
-SequenceOfShortKeys = Sequence[ShortKey]
-OptionalSequenceOfShortKeys = Optional[SequenceOfShortKeys]
+ShortServiceKeyT = TypeVar("ShortServiceKeyT", bound=ShortServiceKey)
+OptShortServiceKey = ShortServiceKey | None
+OptShortServiceKeyT = TypeVar("OptShortServiceKeyT", bound=OptShortServiceKey)
+
+
+class SimpleShortServiceKeyMixin(BaseModel, Generic[OptShortServiceKeyT]):
+    key: Annotated[OptShortServiceKeyT, Field(..., description="Service Key")]
+
+
+class FullShortServiceKeyMixin(BaseModel, Generic[OptShortServiceKeyT]):
+    service_key: Annotated[OptShortServiceKeyT, Field(..., description="Service Key")]
+
+
+ListOfShortServiceKeys = list[ShortServiceKey]
+ListOfShortServiceKeysT = TypeVar(
+    "ListOfShortServiceKeysT", bound=ListOfShortServiceKeys
+)
+OptListOfShortServiceKeys = ListOfShortServiceKeys | None
+OptListOfShortServiceKeysT = TypeVar(
+    "OptListOfShortServiceKeysT", bound=OptListOfShortServiceKeys
+)
+
+
+class SimpleShortServiceKeysMixin(BaseModel, Generic[OptListOfShortServiceKeysT]):
+    keys: Annotated[OptListOfShortServiceKeysT, Field(..., description="Service Keys")]
+
+
+class FullShortServiceKeysMixin(BaseModel, Generic[OptListOfShortServiceKeysT]):
+    service_keys: Annotated[
+        OptListOfShortServiceKeysT, Field(..., description="Service Keys")
+    ]
+
+
+SeqOfShortServiceKeys = Sequence[ShortServiceKey]
+SeqOfShortServiceKeysT = TypeVar("SeqOfShortServiceKeysT", bound=SeqOfShortServiceKeys)
+OptSeqOfShortServiceKeys = SeqOfShortServiceKeys | None
+OptSeqOfShortServiceKeysT = TypeVar(
+    "OptSeqOfShortServiceKeysT", bound=OptSeqOfShortServiceKeys
+)
 
 
-class Key(StrEnum):
+class ServiceKey(StrEnum):
     STUDIO = "maleo-studio"
     NEXUS = "maleo-nexus"
     TELEMETRY = "maleo-telemetry"
@@ -90,20 +187,46 @@ class Key(StrEnum):
     MCU = "maleo-mcu"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-KeyT = TypeVar("KeyT", bound=Key)
-OptionalKey = Optional[Key]
-OptionalKeyT = TypeVar("OptionalKeyT", bound=OptionalKey)
-ListOfKeys = List[Key]
-OptionalListOfKeys = Optional[ListOfKeys]
-SequenceOfKeys = Sequence[Key]
-OptionalSequenceOfKeys = Optional[SequenceOfKeys]
+ServiceKeyT = TypeVar("ServiceKeyT", bound=ServiceKey)
+OptServiceKey = ServiceKey | None
+OptServiceKeyT = TypeVar("OptServiceKeyT", bound=OptServiceKey)
 
 
-class ShortName(StrEnum):
+class SimpleServiceKeyMixin(BaseModel, Generic[OptServiceKeyT]):
+    key: Annotated[OptServiceKeyT, Field(..., description="Service Key")]
+
+
+class FullServiceKeyMixin(BaseModel, Generic[OptServiceKeyT]):
+    service_key: Annotated[OptServiceKeyT, Field(..., description="Service Key")]
+
+
+ListOfServiceKeys = list[ServiceKey]
+ListOfServiceKeysT = TypeVar("ListOfServiceKeysT", bound=ListOfServiceKeys)
+OptListOfServiceKeys = ListOfServiceKeys | None
+OptListOfServiceKeysT = TypeVar("OptListOfServiceKeysT", bound=OptListOfServiceKeys)
+
+
+class SimpleServiceKeysMixin(BaseModel, Generic[OptListOfServiceKeysT]):
+    keys: Annotated[OptListOfServiceKeysT, Field(..., description="Service Keys")]
+
+
+class FullServiceKeysMixin(BaseModel, Generic[OptListOfServiceKeysT]):
+    service_keys: Annotated[
+        OptListOfServiceKeysT, Field(..., description="Service Keys")
+    ]
+
+
+SeqOfServiceKeys = Sequence[ServiceKey]
+SeqOfServiceKeysT = TypeVar("SeqOfServiceKeysT", bound=SeqOfServiceKeys)
+OptSeqOfServiceKeys = SeqOfServiceKeys | None
+OptSeqOfServiceKeysT = TypeVar("OptSeqOfServiceKeysT", bound=OptSeqOfServiceKeys)
+
+
+class ShortServiceName(StrEnum):
     STUDIO = "Studio"
     NEXUS = "Nexus"
     TELEMETRY = "Telemetry"
@@ -122,20 +245,58 @@ class ShortName(StrEnum):
     MCU = "MCU"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-ShortNameT = TypeVar("ShortNameT", bound=ShortName)
-OptionalShortName = Optional[ShortName]
-OptionalShortNameT = TypeVar("OptionalShortNameT", bound=OptionalShortName)
-ListOfShortNames = List[ShortName]
-OptionalListOfShortNames = Optional[ListOfShortNames]
-SequenceOfShortNames = Sequence[ShortName]
-OptionalSequenceOfShortNames = Optional[SequenceOfShortNames]
+ShortServiceNameT = TypeVar("ShortServiceNameT", bound=ShortServiceName)
+OptShortServiceName = ShortServiceName | None
+OptShortServiceNameT = TypeVar("OptShortServiceNameT", bound=OptShortServiceName)
+
+
+class SimpleShortServiceNameMixin(BaseModel, Generic[OptShortServiceNameT]):
+    name: Annotated[OptShortServiceNameT, Field(..., description="Service Name")]
+
+
+class FullShortServiceNameMixin(BaseModel, Generic[OptShortServiceNameT]):
+    service_name: Annotated[
+        OptShortServiceNameT, Field(..., description="Service Name")
+    ]
+
+
+ListOfShortServiceNames = list[ShortServiceName]
+ListOfShortServiceNamesT = TypeVar(
+    "ListOfShortServiceNamesT", bound=ListOfShortServiceNames
+)
+OptListOfShortServiceNames = ListOfShortServiceNames | None
+OptListOfShortServiceNamesT = TypeVar(
+    "OptListOfShortServiceNamesT", bound=OptListOfShortServiceNames
+)
 
 
-class Name(StrEnum):
+class SimpleShortServiceNamesMixin(BaseModel, Generic[OptListOfShortServiceNamesT]):
+    names: Annotated[
+        OptListOfShortServiceNamesT, Field(..., description="Service Names")
+    ]
+
+
+class FullShortServiceNamesMixin(BaseModel, Generic[OptListOfShortServiceNamesT]):
+    service_names: Annotated[
+        OptListOfShortServiceNamesT, Field(..., description="Service Names")
+    ]
+
+
+SeqOfShortServiceNames = Sequence[ShortServiceName]
+SeqOfShortServiceNamesT = TypeVar(
+    "SeqOfShortServiceNamesT", bound=SeqOfShortServiceNames
+)
+OptSeqOfShortServiceNames = SeqOfShortServiceNames | None
+OptSeqOfShortServiceNamesT = TypeVar(
+    "OptSeqOfShortServiceNamesT", bound=OptSeqOfShortServiceNames
+)
+
+
+class ServiceName(StrEnum):
     STUDIO = "MaleoStudio"
     NEXUS = "MaleoNexus"
     TELEMETRY = "MaleoTelemetry"
@@ -154,14 +315,40 @@ class Name(StrEnum):
     MCU = "MaleoMCU"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
-NameT = TypeVar("NameT", bound=Name)
-OptionalName = Optional[Name]
-OptionalNameT = TypeVar("OptionalNameT", bound=OptionalName)
-ListOfNames = List[Name]
-OptionalListOfNames = Optional[ListOfNames]
-SequenceOfNames = Sequence[Name]
-OptionalSequenceOfNames = Optional[SequenceOfNames]
+ServiceNameT = TypeVar("ServiceNameT", bound=ServiceName)
+OptServiceName = ServiceName | None
+OptServiceNameT = TypeVar("OptServiceNameT", bound=OptServiceName)
+
+
+class SimpleServiceNameMixin(BaseModel, Generic[OptServiceNameT]):
+    name: Annotated[OptServiceNameT, Field(..., description="Service Name")]
+
+
+class FullServiceNameMixin(BaseModel, Generic[OptServiceNameT]):
+    service_name: Annotated[OptServiceNameT, Field(..., description="Service Name")]
+
+
+ListOfServiceNames = list[ServiceName]
+ListOfServiceNamesT = TypeVar("ListOfServiceNamesT", bound=ListOfServiceNames)
+OptListOfServiceNames = ListOfServiceNames | None
+OptListOfServiceNamesT = TypeVar("OptListOfServiceNamesT", bound=OptListOfServiceNames)
+
+
+class SimpleServiceNamesMixin(BaseModel, Generic[OptListOfServiceNamesT]):
+    names: Annotated[OptListOfServiceNamesT, Field(..., description="Service Names")]
+
+
+class FullServiceNamesMixin(BaseModel, Generic[OptListOfServiceNamesT]):
+    service_names: Annotated[
+        OptListOfServiceNamesT, Field(..., description="Service Names")
+    ]
+
+
+SeqOfServiceNames = Sequence[ServiceName]
+SeqOfServiceNamesT = TypeVar("SeqOfServiceNamesT", bound=SeqOfServiceNames)
+OptSeqOfServiceNames = SeqOfServiceNames | None
+OptSeqOfServiceNamesT = TypeVar("OptSeqOfServiceNamesT", bound=OptSeqOfServiceNames)

maleo/enums/status.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 DataStatus(StrEnum):
@@ -9,26 +10,50 @@ class DataStatus(StrEnum):
     ACTIVE = "active"
 
     @classmethod
-    def choices(cls) -> ListOfStrings:
+    def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
 
 
 DataStatusT = TypeVar("DataStatusT", bound=DataStatus)
-OptionalDataStatus = Optional[DataStatus]
-OptionalDataStatusT = TypeVar("OptionalDataStatusT", bound=OptionalDataStatus)
-ListOfDataStatuses = List[DataStatus]
-OptionalListOfDataStatuses = Optional[ListOfDataStatuses]
-SequenceOfDataStatuses = Sequence[DataStatus]
-OptionalSequenceOfDataStatuses = Optional[SequenceOfDataStatuses]
+OptDataStatus = DataStatus | None
+OptDataStatusT = TypeVar("OptDataStatusT", bound=OptDataStatus)
 
 
-FULL_DATA_STATUSES: SequenceOfDataStatuses = (
+class SimpleDataStatusMixin(BaseModel, Generic[OptDataStatusT]):
+    status: Annotated[OptDataStatusT, Field(..., description="Status")]
+
+
+class FullDataStatusMixin(BaseModel, Generic[OptDataStatusT]):
+    data_status: Annotated[OptDataStatusT, Field(..., description="Status")]
+
+
+ListOfDataStatuses = list[DataStatus]
+ListOfDataStatusesT = TypeVar("ListOfDataStatusesT", bound=ListOfDataStatuses)
+OptListOfDataStatuses = ListOfDataStatuses | None
+OptListOfDataStatusesT = TypeVar("OptListOfDataStatusesT", bound=OptListOfDataStatuses)
+
+
+class SimpleDataStatusesMixin(BaseModel, Generic[OptListOfDataStatusesT]):
+    statuses: Annotated[OptListOfDataStatusesT, Field(..., description="Statuses")]
+
+
+class FullDataStatusesMixin(BaseModel, Generic[OptListOfDataStatusesT]):
+    data_statuses: Annotated[OptListOfDataStatusesT, Field(..., description="Statuses")]
+
+
+SeqOfDataStatuses = Sequence[DataStatus]
+SeqOfDataStatusesT = TypeVar("SeqOfDataStatusesT", bound=SeqOfDataStatuses)
+OptSeqOfDataStatuses = SeqOfDataStatuses | None
+OptSeqOfDataStatusesT = TypeVar("OptSeqOfDataStatusesT", bound=OptSeqOfDataStatuses)
+
+
+FULL_DATA_STATUSES: ListOfDataStatuses = [
     DataStatus.ACTIVE,
     DataStatus.INACTIVE,
     DataStatus.DELETED,
-)
+]
 
-BASIC_DATA_STATUSES: SequenceOfDataStatuses = (
+BASIC_DATA_STATUSES: ListOfDataStatuses = [
     DataStatus.ACTIVE,
     DataStatus.INACTIVE,
-)
+]