mixpeek 0.20.20__py3-none-any.whl → 0.21.1__py3-none-any.whl

mixpeek/models/{list_classifications_v1_entities_taxonomies_taxonomy_classifications_postop.py → list_objects_v1_buckets_bucket_identifier_objects_postop.py}

@@ -1,10 +1,7 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .listclassificationsrequest import (
-    ListClassificationsRequest,
-    ListClassificationsRequestTypedDict,
-)
+from .listobjectsrequest import ListObjectsRequest, ListObjectsRequestTypedDict
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mixpeek.utils import (
     FieldMetadata,
@@ -19,40 +16,31 @@ from typing import Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class ListClassificationsV1EntitiesTaxonomiesTaxonomyClassificationsPostRequestTypedDict(
-    TypedDict
-):
-    taxonomy: str
-    r"""The ID or name of the taxonomy"""
-    list_classifications_request: ListClassificationsRequestTypedDict
-    page: NotRequired[Nullable[int]]
-    page_size: NotRequired[int]
+class ListObjectsV1BucketsBucketIdentifierObjectsPostRequestTypedDict(TypedDict):
+    bucket_identifier: str
+    r"""Identifier of the bucket"""
+    limit: NotRequired[Nullable[int]]
+    offset: NotRequired[Nullable[int]]
     x_namespace: NotRequired[Nullable[str]]
     r"""Optional namespace for data isolation. This can be a namespace name or namespace ID. Example: 'netflix_prod' or 'ns_1234567890'. To create a namespace, use the /namespaces endpoint."""
+    list_objects_request: NotRequired[ListObjectsRequestTypedDict]
 
 
-class ListClassificationsV1EntitiesTaxonomiesTaxonomyClassificationsPostRequest(
-    BaseModel
-):
-    taxonomy: Annotated[
+class ListObjectsV1BucketsBucketIdentifierObjectsPostRequest(BaseModel):
+    bucket_identifier: Annotated[
         str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
     ]
-    r"""The ID or name of the taxonomy"""
-
-    list_classifications_request: Annotated[
-        ListClassificationsRequest,
-        FieldMetadata(request=RequestMetadata(media_type="application/json")),
-    ]
+    r"""Identifier of the bucket"""
 
-    page: Annotated[
+    limit: Annotated[
         OptionalNullable[int],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = UNSET
 
-    page_size: Annotated[
-        Optional[int],
+    offset: Annotated[
+        OptionalNullable[int],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
-    ] = 10
+    ] = UNSET
 
     x_namespace: Annotated[
         OptionalNullable[str],
@@ -61,17 +49,22 @@ class ListClassificationsV1EntitiesTaxonomiesTaxonomyClassificationsPostRequest(
     ] = UNSET
     r"""Optional namespace for data isolation. This can be a namespace name or namespace ID. Example: 'netflix_prod' or 'ns_1234567890'. To create a namespace, use the /namespaces endpoint."""
 
+    list_objects_request: Annotated[
+        Optional[ListObjectsRequest],
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ] = None
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["page", "page_size", "X-Namespace"]
-        nullable_fields = ["page", "X-Namespace"]
+        optional_fields = ["limit", "offset", "X-Namespace", "ListObjectsRequest"]
+        nullable_fields = ["limit", "offset", "X-Namespace"]
         null_default_fields = []
 
         serialized = handler(self)
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mixpeek/models/{groupbyoptionsasset.py → listbucketsrequest.py}

@@ -1,56 +1,47 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .logicaloperator_input import LogicalOperatorInput, LogicalOperatorInputTypedDict
 from .sortoption import SortOption, SortOptionTypedDict
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
 from typing_extensions import NotRequired, TypedDict
 
 
-class GroupByOptionsAssetTypedDict(TypedDict):
-    field: NotRequired[Nullable[str]]
-    r"""
-    Field to group by
+class ListBucketsRequestTypedDict(TypedDict):
+    r"""Request model for listing buckets"""
 
-    Note: We currently do not support ad-hoc grouping.
-    This means the field must be indexed separately.
-    Please contact us to add additional fields for grouping.
-
-    """
-    max_assets: NotRequired[Nullable[int]]
-    r"""Maximum number of assets to group"""
+    filters: NotRequired[Nullable[LogicalOperatorInputTypedDict]]
+    r"""Filters to apply to the bucket list"""
     sort: NotRequired[Nullable[SortOptionTypedDict]]
-    r"""Sort options for ordering the inside of the groups"""
-
+    r"""Sort options for the bucket list"""
+    search: NotRequired[Nullable[str]]
+    r"""Search term to filter buckets by name or description"""
 
-class GroupByOptionsAsset(BaseModel):
-    field: OptionalNullable[str] = UNSET
-    r"""
-    Field to group by
 
-    Note: We currently do not support ad-hoc grouping.
-    This means the field must be indexed separately.
-    Please contact us to add additional fields for grouping.
+class ListBucketsRequest(BaseModel):
+    r"""Request model for listing buckets"""
 
-    """
-
-    max_assets: OptionalNullable[int] = UNSET
-    r"""Maximum number of assets to group"""
+    filters: OptionalNullable[LogicalOperatorInput] = UNSET
+    r"""Filters to apply to the bucket list"""
 
     sort: OptionalNullable[SortOption] = UNSET
-    r"""Sort options for ordering the inside of the groups"""
+    r"""Sort options for the bucket list"""
+
+    search: OptionalNullable[str] = UNSET
+    r"""Search term to filter buckets by name or description"""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["field", "max_assets", "sort"]
-        nullable_fields = ["field", "max_assets", "sort"]
+        optional_fields = ["filters", "sort", "search"]
+        nullable_fields = ["filters", "sort", "search"]
         null_default_fields = []
 
         serialized = handler(self)
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mixpeek/models/listbucketsresponse.py

@@ -0,0 +1,23 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .bucketresponse import BucketResponse, BucketResponseTypedDict
+from .paginationresponse import PaginationResponse, PaginationResponseTypedDict
+from mixpeek.types import BaseModel
+from typing import List
+from typing_extensions import TypedDict
+
+
+class ListBucketsResponseTypedDict(TypedDict):
+    r"""Response model for listing buckets"""
+
+    results: List[BucketResponseTypedDict]
+    pagination: PaginationResponseTypedDict
+
+
+class ListBucketsResponse(BaseModel):
+    r"""Response model for listing buckets"""
+
+    results: List[BucketResponse]
+
+    pagination: PaginationResponse

mixpeek/models/{groupbyoptions.py → listobjectsrequest.py}

@@ -1,56 +1,47 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .logicaloperator_input import LogicalOperatorInput, LogicalOperatorInputTypedDict
 from .sortoption import SortOption, SortOptionTypedDict
 from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
 from typing_extensions import NotRequired, TypedDict
 
 
-class GroupByOptionsTypedDict(TypedDict):
-    field: NotRequired[Nullable[str]]
-    r"""
-    Field to group by
+class ListObjectsRequestTypedDict(TypedDict):
+    r"""Request model for listing objects in a bucket"""
 
-    Note: We currently do not support ad-hoc grouping.
-    This means the field must be indexed separately.
-    Please contact us to add additional fields for grouping.
-
-    """
-    max_features: NotRequired[Nullable[int]]
-    r"""Maximum number of features to group"""
+    filters: NotRequired[Nullable[LogicalOperatorInputTypedDict]]
+    r"""Filters to apply to the object list"""
     sort: NotRequired[Nullable[SortOptionTypedDict]]
-    r"""Sort options for ordering the inside of the groups"""
-
+    r"""Sort options for the object list"""
+    search: NotRequired[Nullable[str]]
+    r"""Search term to filter objects by key or metadata"""
 
-class GroupByOptions(BaseModel):
-    field: OptionalNullable[str] = UNSET
-    r"""
-    Field to group by
 
-    Note: We currently do not support ad-hoc grouping.
-    This means the field must be indexed separately.
-    Please contact us to add additional fields for grouping.
+class ListObjectsRequest(BaseModel):
+    r"""Request model for listing objects in a bucket"""
 
-    """
-
-    max_features: OptionalNullable[int] = UNSET
-    r"""Maximum number of features to group"""
+    filters: OptionalNullable[LogicalOperatorInput] = UNSET
+    r"""Filters to apply to the object list"""
 
     sort: OptionalNullable[SortOption] = UNSET
-    r"""Sort options for ordering the inside of the groups"""
+    r"""Sort options for the object list"""
+
+    search: OptionalNullable[str] = UNSET
+    r"""Search term to filter objects by key or metadata"""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["field", "max_features", "sort"]
-        nullable_fields = ["field", "max_features", "sort"]
+        optional_fields = ["filters", "sort", "search"]
+        nullable_fields = ["filters", "sort", "search"]
         null_default_fields = []
 
         serialized = handler(self)
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mixpeek/models/listobjectsresponse.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .objectresponse import ObjectResponse, ObjectResponseTypedDict
+from .paginationresponse import PaginationResponse, PaginationResponseTypedDict
+from mixpeek.types import BaseModel
+from typing import List
+from typing_extensions import TypedDict
+
+
+class ListObjectsResponseTypedDict(TypedDict):
+    r"""Response model for listing objects in a bucket"""
+
+    results: List[ObjectResponseTypedDict]
+    r"""List of objects matching the query"""
+    pagination: PaginationResponseTypedDict
+
+
+class ListObjectsResponse(BaseModel):
+    r"""Response model for listing objects in a bucket"""
+
+    results: List[ObjectResponse]
+    r"""List of objects matching the query"""
+
+    pagination: PaginationResponse

mixpeek/models/listtasksresponse.py

@@ -1,10 +1,7 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .db_model_paginationresponse import (
-    DbModelPaginationResponse,
-    DbModelPaginationResponseTypedDict,
-)
+from .paginationresponse import PaginationResponse, PaginationResponseTypedDict
 from .taskresponse import TaskResponse, TaskResponseTypedDict
 from mixpeek.types import BaseModel
 from typing import List
@@ -13,10 +10,10 @@ from typing_extensions import TypedDict
 
 class ListTasksResponseTypedDict(TypedDict):
     results: List[TaskResponseTypedDict]
-    pagination: DbModelPaginationResponseTypedDict
+    pagination: PaginationResponseTypedDict
 
 
 class ListTasksResponse(BaseModel):
     results: List[TaskResponse]
 
-    pagination: DbModelPaginationResponse
+    pagination: PaginationResponse

mixpeek/models/{logicaloperator.py → logicaloperator_input.py}

@@ -9,41 +9,59 @@ from typing import List, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
-class LogicalOperatorTypedDict(TypedDict):
-    case_sensitive: NotRequired[Nullable[bool]]
-    r"""Whether to perform case-sensitive matching"""
+class LogicalOperatorInputTypedDict(TypedDict):
+    r"""Represents a logical operation (AND, OR, NOT) on filter conditions.
+
+    Attributes:
+    AND: List of conditions that must all be true
+    OR: List of conditions where at least one must be true
+    NOT: List of conditions that must all be false
+    case_sensitive: Whether string comparisons are case sensitive
+    """
+
     and_: NotRequired[Nullable[List[AndTypedDict]]]
-    r"""Logical AND operation"""
+    r"""Logical AND operation - all conditions must be true"""
     or_: NotRequired[Nullable[List[OrTypedDict]]]
-    r"""Logical OR operation"""
-    nor: NotRequired[Nullable[List[NorTypedDict]]]
-    r"""Logical NOR operation"""
+    r"""Logical OR operation - at least one condition must be true"""
+    not_: NotRequired[Nullable[List[NotTypedDict]]]
+    r"""Logical NOT operation - all conditions must be false"""
+    case_sensitive: NotRequired[Nullable[bool]]
+    r"""Whether to perform case-sensitive matching"""
 
 
-class LogicalOperator(BaseModel):
-    case_sensitive: OptionalNullable[bool] = UNSET
-    r"""Whether to perform case-sensitive matching"""
+class LogicalOperatorInput(BaseModel):
+    r"""Represents a logical operation (AND, OR, NOT) on filter conditions.
+
+    Attributes:
+    AND: List of conditions that must all be true
+    OR: List of conditions where at least one must be true
+    NOT: List of conditions that must all be false
+    case_sensitive: Whether string comparisons are case sensitive
+    """
 
     and_: Annotated[OptionalNullable[List[And]], pydantic.Field(alias="AND")] = UNSET
-    r"""Logical AND operation"""
+    r"""Logical AND operation - all conditions must be true"""
 
     or_: Annotated[OptionalNullable[List[Or]], pydantic.Field(alias="OR")] = UNSET
-    r"""Logical OR operation"""
+    r"""Logical OR operation - at least one condition must be true"""
 
-    nor: Annotated[OptionalNullable[List[Nor]], pydantic.Field(alias="NOR")] = UNSET
-    r"""Logical NOR operation"""
+    not_: Annotated[OptionalNullable[List[Not]], pydantic.Field(alias="NOT")] = UNSET
+    r"""Logical NOT operation - all conditions must be false"""
+
+    case_sensitive: OptionalNullable[bool] = UNSET
+    r"""Whether to perform case-sensitive matching"""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["case_sensitive", "AND", "OR", "NOR"]
-        nullable_fields = ["case_sensitive", "AND", "OR", "NOR"]
+        optional_fields = ["AND", "OR", "NOT", "case_sensitive"]
+        nullable_fields = ["AND", "OR", "NOT", "case_sensitive"]
         null_default_fields = []
 
         serialized = handler(self)
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)
@@ -65,24 +83,24 @@ class LogicalOperator(BaseModel):
 
 
 AndTypedDict = TypeAliasType(
-    "AndTypedDict", Union[FilterConditionTypedDict, "LogicalOperatorTypedDict"]
+    "AndTypedDict", Union[FilterConditionTypedDict, "LogicalOperatorInputTypedDict"]
 )
 
 
-And = TypeAliasType("And", Union[FilterCondition, "LogicalOperator"])
+And = TypeAliasType("And", Union[FilterCondition, "LogicalOperatorInput"])
 
 
 OrTypedDict = TypeAliasType(
-    "OrTypedDict", Union[FilterConditionTypedDict, "LogicalOperatorTypedDict"]
+    "OrTypedDict", Union[FilterConditionTypedDict, "LogicalOperatorInputTypedDict"]
 )
 
 
-Or = TypeAliasType("Or", Union[FilterCondition, "LogicalOperator"])
+Or = TypeAliasType("Or", Union[FilterCondition, "LogicalOperatorInput"])
 
 
-NorTypedDict = TypeAliasType(
-    "NorTypedDict", Union[FilterConditionTypedDict, "LogicalOperatorTypedDict"]
+NotTypedDict = TypeAliasType(
+    "NotTypedDict", Union[FilterConditionTypedDict, "LogicalOperatorInputTypedDict"]
 )
 
 
-Nor = TypeAliasType("Nor", Union[FilterCondition, "LogicalOperator"])
+Not = TypeAliasType("Not", Union[FilterCondition, "LogicalOperatorInput"])

mixpeek/models/logicaloperator_output.py

@@ -0,0 +1,121 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .filtercondition import FilterCondition, FilterConditionTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import List, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+class LogicalOperatorOutputTypedDict(TypedDict):
+    r"""Represents a logical operation (AND, OR, NOT) on filter conditions.
+
+    Attributes:
+    AND: List of conditions that must all be true
+    OR: List of conditions where at least one must be true
+    NOT: List of conditions that must all be false
+    case_sensitive: Whether string comparisons are case sensitive
+    """
+
+    and_: NotRequired[Nullable[List[LogicalOperatorOutputANDTypedDict]]]
+    r"""Logical AND operation - all conditions must be true"""
+    or_: NotRequired[Nullable[List[LogicalOperatorOutputORTypedDict]]]
+    r"""Logical OR operation - at least one condition must be true"""
+    not_: NotRequired[Nullable[List[LogicalOperatorOutputNOTTypedDict]]]
+    r"""Logical NOT operation - all conditions must be false"""
+    case_sensitive: NotRequired[Nullable[bool]]
+    r"""Whether to perform case-sensitive matching"""
+
+
+class LogicalOperatorOutput(BaseModel):
+    r"""Represents a logical operation (AND, OR, NOT) on filter conditions.
+
+    Attributes:
+    AND: List of conditions that must all be true
+    OR: List of conditions where at least one must be true
+    NOT: List of conditions that must all be false
+    case_sensitive: Whether string comparisons are case sensitive
+    """
+
+    and_: Annotated[
+        OptionalNullable[List[LogicalOperatorOutputAND]], pydantic.Field(alias="AND")
+    ] = UNSET
+    r"""Logical AND operation - all conditions must be true"""
+
+    or_: Annotated[
+        OptionalNullable[List[LogicalOperatorOutputOR]], pydantic.Field(alias="OR")
+    ] = UNSET
+    r"""Logical OR operation - at least one condition must be true"""
+
+    not_: Annotated[
+        OptionalNullable[List[LogicalOperatorOutputNOT]], pydantic.Field(alias="NOT")
+    ] = UNSET
+    r"""Logical NOT operation - all conditions must be false"""
+
+    case_sensitive: OptionalNullable[bool] = UNSET
+    r"""Whether to perform case-sensitive matching"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["AND", "OR", "NOT", "case_sensitive"]
+        nullable_fields = ["AND", "OR", "NOT", "case_sensitive"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m
+
+
+LogicalOperatorOutputANDTypedDict = TypeAliasType(
+    "LogicalOperatorOutputANDTypedDict",
+    Union[FilterConditionTypedDict, "LogicalOperatorOutputTypedDict"],
+)
+
+
+LogicalOperatorOutputAND = TypeAliasType(
+    "LogicalOperatorOutputAND", Union[FilterCondition, "LogicalOperatorOutput"]
+)
+
+
+LogicalOperatorOutputORTypedDict = TypeAliasType(
+    "LogicalOperatorOutputORTypedDict",
+    Union[FilterConditionTypedDict, "LogicalOperatorOutputTypedDict"],
+)
+
+
+LogicalOperatorOutputOR = TypeAliasType(
+    "LogicalOperatorOutputOR", Union[FilterCondition, "LogicalOperatorOutput"]
+)
+
+
+LogicalOperatorOutputNOTTypedDict = TypeAliasType(
+    "LogicalOperatorOutputNOTTypedDict",
+    Union[FilterConditionTypedDict, "LogicalOperatorOutputTypedDict"],
+)
+
+
+LogicalOperatorOutputNOT = TypeAliasType(
+    "LogicalOperatorOutputNOT", Union[FilterCondition, "LogicalOperatorOutput"]
+)

mixpeek/models/multivectorindex.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .vectorindex import VectorIndex, VectorIndexTypedDict
+from mixpeek.types import BaseModel
+from typing import Dict
+from typing_extensions import TypedDict
+
+
+class MultiVectorIndexTypedDict(TypedDict):
+    r"""Configuration for multi-vector indexes"""
+
+    name: str
+    description: str
+    vectors: Dict[str, VectorIndexTypedDict]
+
+
+class MultiVectorIndex(BaseModel):
+    r"""Configuration for multi-vector indexes"""
+
+    name: str
+
+    description: str
+
+    vectors: Dict[str, VectorIndex]

mixpeek/models/namespaceresponse.py

@@ -33,7 +33,7 @@ class NamespaceResponse(BaseModel):
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mixpeek/models/namespaceusage.py

@@ -0,0 +1,45 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from datetime import datetime
+from mixpeek.types import BaseModel
+from typing_extensions import TypedDict
+
+
+class NamespaceUsageTypedDict(TypedDict):
+    r"""Usage statistics for a single namespace"""
+
+    namespace_id: str
+    r"""Namespace ID"""
+    namespace_name: str
+    r"""Namespace name"""
+    storage_used_gb: float
+    r"""Storage used in GB"""
+    api_calls_30d: int
+    r"""API calls in the last 30 days"""
+    documents_count: int
+    r"""Number of documents"""
+    last_activity: datetime
+    r"""Timestamp of last activity"""
+
+
+class NamespaceUsage(BaseModel):
+    r"""Usage statistics for a single namespace"""
+
+    namespace_id: str
+    r"""Namespace ID"""
+
+    namespace_name: str
+    r"""Namespace name"""
+
+    storage_used_gb: float
+    r"""Storage used in GB"""
+
+    api_calls_30d: int
+    r"""API calls in the last 30 days"""
+
+    documents_count: int
+    r"""Number of documents"""
+
+    last_activity: datetime
+    r"""Timestamp of last activity"""

mixpeek/models/namingmethod.py

@@ -0,0 +1,8 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class NamingMethod(str, Enum):
+    CENTROID = "centroid"