mixpeek 0.11.2__py3-none-any.whl → 0.13__py3-none-any.whl

mixpeek/models/payloadindextype.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mixpeek.types import BaseModel
+from typing_extensions import TypedDict
+
+
+class PayloadIndexTypeTypedDict(TypedDict):
+    r"""Simple schema for payload index type"""
+
+    type: str
+
+
+class PayloadIndexType(BaseModel):
+    r"""Simple schema for payload index type"""
+
+    type: str

mixpeek/models/payloadschematype.py

@@ -0,0 +1,15 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class PayloadSchemaType(str, Enum):
+    KEYWORD = "keyword"
+    INTEGER = "integer"
+    FLOAT = "float"
+    BOOL = "bool"
+    GEO = "geo"
+    DATETIME = "datetime"
+    TEXT = "text"
+    UUID = "uuid"

mixpeek/models/percolaterequest.py

@@ -0,0 +1,57 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class PercolateRequestTypedDict(TypedDict):
+    enabled: NotRequired[bool]
+    r"""Whether to enable percolator matching for this request"""
+    min_score: NotRequired[Nullable[float]]
+    r"""Minimum similarity score (0-1) required for a match. Higher values mean stricter matching."""
+    max_candidates: NotRequired[Nullable[int]]
+    r"""Maximum number of matching percolators to return in the response"""
+
+
+class PercolateRequest(BaseModel):
+    enabled: Optional[bool] = True
+    r"""Whether to enable percolator matching for this request"""
+
+    min_score: OptionalNullable[float] = UNSET
+    r"""Minimum similarity score (0-1) required for a match. Higher values mean stricter matching."""
+
+    max_candidates: OptionalNullable[int] = UNSET
+    r"""Maximum number of matching percolators to return in the response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["enabled", "min_score", "max_candidates"]
+        nullable_fields = ["min_score", "max_candidates"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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

mixpeek/models/permission.py

@@ -0,0 +1,10 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class Permission(str, Enum):
+    READ = "read"
+    WRITE = "write"
+    ADMIN = "admin"

mixpeek/models/processimageurlinput.py

@@ -0,0 +1,99 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .assetupdate import AssetUpdate, AssetUpdateTypedDict
+from .imagesettings import ImageSettings, ImageSettingsTypedDict
+from .percolaterequest import PercolateRequest, PercolateRequestTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ProcessImageURLInputMetadataTypedDict(TypedDict):
+    r"""Additional metadata associated with the asset. Can include any key-value pairs relevant to the asset."""
+
+
+class ProcessImageURLInputMetadata(BaseModel):
+    r"""Additional metadata associated with the asset. Can include any key-value pairs relevant to the asset."""
+
+
+class ProcessImageURLInputTypedDict(TypedDict):
+    url: str
+    r"""The URL of the asset to be processed. Must be a valid HTTP or HTTPS URL."""
+    collection: str
+    r"""Unique identifier for the collection where the processed asset will be stored, can be the collection name or collection ID. If neither exist, the collection will be created."""
+    asset_update: NotRequired[Nullable[AssetUpdateTypedDict]]
+    r"""Controls how processing results are stored - either creating a new asset or updating an existing one."""
+    metadata: NotRequired[ProcessImageURLInputMetadataTypedDict]
+    r"""Additional metadata associated with the asset. Can include any key-value pairs relevant to the asset."""
+    percolate: NotRequired[Nullable[PercolateRequestTypedDict]]
+    r"""Settings for percolating the asset against stored queries."""
+    skip_duplicate: NotRequired[Nullable[bool]]
+    r"""Makes feature extraction idempotent. When True and a duplicate file hash is found, copies features from the existing asset instead of reprocessing. This allows the same file to be used multiple times with different metadata while avoiding redundant processing."""
+    feature_extractors: NotRequired[Nullable[ImageSettingsTypedDict]]
+    r"""Settings for image processing. Only applicable if the URL points to an image file."""
+
+
+class ProcessImageURLInput(BaseModel):
+    url: str
+    r"""The URL of the asset to be processed. Must be a valid HTTP or HTTPS URL."""
+
+    collection: str
+    r"""Unique identifier for the collection where the processed asset will be stored, can be the collection name or collection ID. If neither exist, the collection will be created."""
+
+    asset_update: OptionalNullable[AssetUpdate] = UNSET
+    r"""Controls how processing results are stored - either creating a new asset or updating an existing one."""
+
+    metadata: Optional[ProcessImageURLInputMetadata] = None
+    r"""Additional metadata associated with the asset. Can include any key-value pairs relevant to the asset."""
+
+    percolate: OptionalNullable[PercolateRequest] = UNSET
+    r"""Settings for percolating the asset against stored queries."""
+
+    skip_duplicate: OptionalNullable[bool] = UNSET
+    r"""Makes feature extraction idempotent. When True and a duplicate file hash is found, copies features from the existing asset instead of reprocessing. This allows the same file to be used multiple times with different metadata while avoiding redundant processing."""
+
+    feature_extractors: OptionalNullable[ImageSettings] = UNSET
+    r"""Settings for image processing. Only applicable if the URL points to an image file."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "asset_update",
+            "metadata",
+            "percolate",
+            "skip_duplicate",
+            "feature_extractors",
+        ]
+        nullable_fields = [
+            "asset_update",
+            "percolate",
+            "skip_duplicate",
+            "feature_extractors",
+        ]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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

mixpeek/models/processtextinput.py

@@ -0,0 +1,94 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .assetupdate import AssetUpdate, AssetUpdateTypedDict
+from .percolaterequest import PercolateRequest, PercolateRequestTypedDict
+from .textsettings import TextSettings, TextSettingsTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ProcessTextInputMetadataTypedDict(TypedDict):
+    r"""Additional metadata associated with the file. Can include any key-value pairs relevant to the file."""
+
+
+class ProcessTextInputMetadata(BaseModel):
+    r"""Additional metadata associated with the file. Can include any key-value pairs relevant to the file."""
+
+
+class ProcessTextInputTypedDict(TypedDict):
+    collection: str
+    r"""Unique identifier for the collection where the processed asset will be stored, can be the collection name or collection ID. If neither exist, the collection will be created."""
+    asset_update: NotRequired[Nullable[AssetUpdateTypedDict]]
+    r"""Controls how processing results are stored - either creating a new asset or updating an existing one."""
+    metadata: NotRequired[ProcessTextInputMetadataTypedDict]
+    r"""Additional metadata associated with the file. Can include any key-value pairs relevant to the file."""
+    feature_extractors: NotRequired[Nullable[TextSettingsTypedDict]]
+    r"""Settings for text processing."""
+    percolate: NotRequired[Nullable[PercolateRequestTypedDict]]
+    r"""Settings for percolating the asset against stored queries."""
+    skip_duplicate: NotRequired[Nullable[bool]]
+    r"""Skips processing when a duplicate hash is found and stores an error by the task_id with the existing asset_id"""
+
+
+class ProcessTextInput(BaseModel):
+    collection: str
+    r"""Unique identifier for the collection where the processed asset will be stored, can be the collection name or collection ID. If neither exist, the collection will be created."""
+
+    asset_update: OptionalNullable[AssetUpdate] = UNSET
+    r"""Controls how processing results are stored - either creating a new asset or updating an existing one."""
+
+    metadata: Optional[ProcessTextInputMetadata] = None
+    r"""Additional metadata associated with the file. Can include any key-value pairs relevant to the file."""
+
+    feature_extractors: OptionalNullable[TextSettings] = UNSET
+    r"""Settings for text processing."""
+
+    percolate: OptionalNullable[PercolateRequest] = UNSET
+    r"""Settings for percolating the asset against stored queries."""
+
+    skip_duplicate: OptionalNullable[bool] = UNSET
+    r"""Skips processing when a duplicate hash is found and stores an error by the task_id with the existing asset_id"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "asset_update",
+            "metadata",
+            "feature_extractors",
+            "percolate",
+            "skip_duplicate",
+        ]
+        nullable_fields = [
+            "asset_update",
+            "feature_extractors",
+            "percolate",
+            "skip_duplicate",
+        ]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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

mixpeek/models/processvideourlinput.py

@@ -0,0 +1,99 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .assetupdate import AssetUpdate, AssetUpdateTypedDict
+from .percolaterequest import PercolateRequest, PercolateRequestTypedDict
+from .videosettings import VideoSettings, VideoSettingsTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ProcessVideoURLInputMetadataTypedDict(TypedDict):
+    r"""Additional metadata associated with the asset. Can include any key-value pairs relevant to the asset."""
+
+
+class ProcessVideoURLInputMetadata(BaseModel):
+    r"""Additional metadata associated with the asset. Can include any key-value pairs relevant to the asset."""
+
+
+class ProcessVideoURLInputTypedDict(TypedDict):
+    url: str
+    r"""The URL of the asset to be processed. Must be a valid HTTP or HTTPS URL."""
+    collection: str
+    r"""Unique identifier for the collection where the processed asset will be stored, can be the collection name or collection ID. If neither exist, the collection will be created."""
+    asset_update: NotRequired[Nullable[AssetUpdateTypedDict]]
+    r"""Controls how processing results are stored - either creating a new asset or updating an existing one."""
+    metadata: NotRequired[ProcessVideoURLInputMetadataTypedDict]
+    r"""Additional metadata associated with the asset. Can include any key-value pairs relevant to the asset."""
+    percolate: NotRequired[Nullable[PercolateRequestTypedDict]]
+    r"""Settings for percolating the asset against stored queries."""
+    skip_duplicate: NotRequired[Nullable[bool]]
+    r"""Makes feature extraction idempotent. When True and a duplicate file hash is found, copies features from the existing asset instead of reprocessing. This allows the same file to be used multiple times with different metadata while avoiding redundant processing."""
+    feature_extractors: NotRequired[Nullable[List[VideoSettingsTypedDict]]]
+    r"""Settings for video processing. Only applicable if the URL points to a video file."""
+
+
+class ProcessVideoURLInput(BaseModel):
+    url: str
+    r"""The URL of the asset to be processed. Must be a valid HTTP or HTTPS URL."""
+
+    collection: str
+    r"""Unique identifier for the collection where the processed asset will be stored, can be the collection name or collection ID. If neither exist, the collection will be created."""
+
+    asset_update: OptionalNullable[AssetUpdate] = UNSET
+    r"""Controls how processing results are stored - either creating a new asset or updating an existing one."""
+
+    metadata: Optional[ProcessVideoURLInputMetadata] = None
+    r"""Additional metadata associated with the asset. Can include any key-value pairs relevant to the asset."""
+
+    percolate: OptionalNullable[PercolateRequest] = UNSET
+    r"""Settings for percolating the asset against stored queries."""
+
+    skip_duplicate: OptionalNullable[bool] = UNSET
+    r"""Makes feature extraction idempotent. When True and a duplicate file hash is found, copies features from the existing asset instead of reprocessing. This allows the same file to be used multiple times with different metadata while avoiding redundant processing."""
+
+    feature_extractors: OptionalNullable[List[VideoSettings]] = UNSET
+    r"""Settings for video processing. Only applicable if the URL points to a video file."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "asset_update",
+            "metadata",
+            "percolate",
+            "skip_duplicate",
+            "feature_extractors",
+        ]
+        nullable_fields = [
+            "asset_update",
+            "percolate",
+            "skip_duplicate",
+            "feature_extractors",
+        ]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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

mixpeek/models/querysettings.py

@@ -0,0 +1,56 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing_extensions import NotRequired, TypedDict
+
+
+class QuerySettingsTypedDict(TypedDict):
+    limit: NotRequired[Nullable[int]]
+    r"""Optional limit for number of results per vector index, this is overriden by ?page_size=int if a single query is provided."""
+    min_score: NotRequired[Nullable[float]]
+    r"""Optional score threshold for filtering results"""
+    modality: NotRequired[Nullable[str]]
+    r"""Optional modality override for the query, this is only used for multimodal embeddings"""
+
+
+class QuerySettings(BaseModel):
+    limit: OptionalNullable[int] = UNSET
+    r"""Optional limit for number of results per vector index, this is overriden by ?page_size=int if a single query is provided."""
+
+    min_score: OptionalNullable[float] = UNSET
+    r"""Optional score threshold for filtering results"""
+
+    modality: OptionalNullable[str] = UNSET
+    r"""Optional modality override for the query, this is only used for multimodal embeddings"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["limit", "min_score", "modality"]
+        nullable_fields = ["limit", "min_score", "modality"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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

mixpeek/models/rerankingoptions.py

@@ -0,0 +1,47 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mixpeek.types import BaseModel
+from typing import Dict, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class RerankingOptionsTypedDict(TypedDict):
+    weights: NotRequired[Dict[str, float]]
+    r"""
+    Weights to blend different ranking signals. Must sum to 1.0.
+    - feedback: Weight for feedback-based score (positive, negative)
+    - popularity: Weight for user interaction signals (clicks, views)
+
+    """
+    enable_reranking: NotRequired[bool]
+    r"""
+    Enable interaction-based score adjustments.
+    When enabled, historical interactions will influence ranking:
+    - Positive feedback and clicks boost scores
+    - Negative feedback reduces scores
+    - View duration and skip signals are considered
+    - Adjustments are weighted by recency
+
+    """
+
+
+class RerankingOptions(BaseModel):
+    weights: Optional[Dict[str, float]] = None
+    r"""
+    Weights to blend different ranking signals. Must sum to 1.0.
+    - feedback: Weight for feedback-based score (positive, negative)
+    - popularity: Weight for user interaction signals (clicks, views)
+
+    """
+
+    enable_reranking: Optional[bool] = False
+    r"""
+    Enable interaction-based score adjustments.
+    When enabled, historical interactions will influence ranking:
+    - Positive feedback and clicks boost scores
+    - Negative feedback reduces scores
+    - View duration and skip signals are considered
+    - Adjustments are weighted by recency
+
+    """

mixpeek/models/search_assets_assets_search_postop.py

@@ -0,0 +1,59 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .searchassetsrequest import SearchAssetsRequest, SearchAssetsRequestTypedDict
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mixpeek.utils import FieldMetadata, HeaderMetadata, RequestMetadata
+import pydantic
+from pydantic import model_serializer
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SearchAssetsAssetsSearchPostRequestTypedDict(TypedDict):
+    search_assets_request: SearchAssetsRequestTypedDict
+    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."""
+
+
+class SearchAssetsAssetsSearchPostRequest(BaseModel):
+    search_assets_request: Annotated[
+        SearchAssetsRequest,
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ]
+
+    x_namespace: Annotated[
+        OptionalNullable[str],
+        pydantic.Field(alias="X-Namespace"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ] = 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."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["X-Namespace"]
+        nullable_fields = ["X-Namespace"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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

mixpeek/models/search_features_features_search_postop.py

@@ -0,0 +1,96 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .searchrequestfeatures_input import (
+    SearchRequestFeaturesInput,
+    SearchRequestFeaturesInputTypedDict,
+)
+from mixpeek.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mixpeek.utils import (
+    FieldMetadata,
+    HeaderMetadata,
+    QueryParamMetadata,
+    RequestMetadata,
+)
+import pydantic
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SearchFeaturesFeaturesSearchPostRequestTypedDict(TypedDict):
+    search_request_features_input: SearchRequestFeaturesInputTypedDict
+    offset_position: NotRequired[Nullable[int]]
+    r"""The position to start returning results from. Used for pagination. Does not work with group_by"""
+    page_size: NotRequired[int]
+    r"""Number of results to return per page."""
+    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."""
+
+
+class SearchFeaturesFeaturesSearchPostRequest(BaseModel):
+    search_request_features_input: Annotated[
+        SearchRequestFeaturesInput,
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ]
+
+    offset_position: Annotated[
+        OptionalNullable[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
+    r"""The position to start returning results from. Used for pagination. Does not work with group_by"""
+
+    page_size: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 10
+    r"""Number of results to return per page."""
+
+    x_namespace: Annotated[
+        OptionalNullable[str],
+        pydantic.Field(alias="X-Namespace"),
+        FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
+    ] = 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."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["offset_position", "page_size", "X-Namespace"]
+        nullable_fields = ["offset_position", "X-Namespace"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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
+
+
+class SearchFeaturesFeaturesSearchPostResponseSearchFeaturesFeaturesSearchPostTypedDict(
+    TypedDict
+):
+    r"""Successful Response"""
+
+
+class SearchFeaturesFeaturesSearchPostResponseSearchFeaturesFeaturesSearchPost(
+    BaseModel
+):
+    r"""Successful Response"""