diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 9127b1b..25709d1 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "3.9.0" + ".": "3.10.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index b53bbe4..927f4f3 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 24 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-3856961a8959b60dbf0b6912d69c23390fbbca1c5e31028dd0decc85234dd285.yml -openapi_spec_hash: 988a7d6d7cef81ceb4acda3ef9f8c21e -config_hash: 7dd9730225e87663fd62814dcfe62ba7 +configured_endpoints: 26 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-c42d5f3942d6e32b6d1ed95d40bf6cca87aa8c715343444b97e0c68d44646878.yml +openapi_spec_hash: 952074229d1f810fe95aeee711db8ca4 +config_hash: fc55f26858b03415a5838ec2731c1cc3 diff --git a/CHANGELOG.md b/CHANGELOG.md index b2e591b..388705d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,20 @@ # Changelog +## 3.10.0 (2025-12-10) + +Full Changelog: [v3.9.0...v3.10.0](https://github.com/supermemoryai/python-sdk/compare/v3.9.0...v3.10.0) + +### Features + +* **api:** api update ([4b30459](https://github.com/supermemoryai/python-sdk/commit/4b3045968d0fccd106e87a1aa3f4c7c49a1475fe)) +* **api:** api update ([8225250](https://github.com/supermemoryai/python-sdk/commit/822525089de88691c334f32b8ae3bf71096894e9)) +* **api:** manual updates ([3691dfd](https://github.com/supermemoryai/python-sdk/commit/3691dfd45b9c8c15e8d318adc4b79e8c8ae9ed27)) +* **api:** manual updates ([be8efa6](https://github.com/supermemoryai/python-sdk/commit/be8efa6ea1c7fdb58428741e7938540e266cbdc2)) +* **api:** manual updates ([094162f](https://github.com/supermemoryai/python-sdk/commit/094162f52b3eba730f85176acfb5b5f34267449f)) +* **api:** manual updates ([13a8b89](https://github.com/supermemoryai/python-sdk/commit/13a8b89e35e60356537d1c59c6721043e45d7577)) +* **api:** manual updates ([acee529](https://github.com/supermemoryai/python-sdk/commit/acee529be2cdc01a6452cf3981575ece4905465a)) +* **api:** manual updates ([ca75227](https://github.com/supermemoryai/python-sdk/commit/ca75227ff922f6d25d4a12e045066fe6545454af)) + ## 3.9.0 (2025-12-09) Full Changelog: [v3.8.0...v3.9.0](https://github.com/supermemoryai/python-sdk/compare/v3.8.0...v3.9.0) diff --git a/README.md b/README.md index 23c3f8c..f634745 100644 --- a/README.md +++ b/README.md @@ -121,7 +121,7 @@ from supermemory import Supermemory client = Supermemory() -response = client.search( +response = client.search.memories( q="machine learning concepts", include={}, ) diff --git a/api.md b/api.md index aca2b3b..84da60e 100644 --- a/api.md +++ b/api.md @@ -3,14 +3,13 @@ Types: ```python -from supermemory.types import AddResponse, ProfileResponse, SearchResponse +from supermemory.types import AddResponse, ProfileResponse ``` Methods: - client.add(\*\*params) -> AddResponse - client.profile(\*\*params) -> ProfileResponse -- client.search(\*\*params) -> SearchResponse # Memories @@ -48,8 +47,10 @@ from supermemory.types import ( DocumentUpdateResponse, DocumentListResponse, DocumentAddResponse, + DocumentBatchAddResponse, DocumentDeleteBulkResponse, DocumentGetResponse, + DocumentListProcessingResponse, DocumentUploadFileResponse, ) ``` @@ -60,8 +61,10 @@ Methods: - client.documents.list(\*\*params) -> DocumentListResponse - client.documents.delete(id) -> None - client.documents.add(\*\*params) -> DocumentAddResponse +- client.documents.batch_add(\*\*params) -> DocumentBatchAddResponse - client.documents.delete_bulk(\*\*params) -> DocumentDeleteBulkResponse - client.documents.get(id) -> DocumentGetResponse +- client.documents.list_processing() -> DocumentListProcessingResponse - client.documents.upload_file(\*\*params) -> DocumentUploadFileResponse # Search diff --git a/pyproject.toml b/pyproject.toml index 8cf1641..7b1807b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "supermemory" -version = "3.9.0" +version = "3.10.0" description = "The official Python library for the supermemory API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/supermemory/_client.py b/src/supermemory/_client.py index 044da7d..e9070a3 100644 --- a/src/supermemory/_client.py +++ b/src/supermemory/_client.py @@ -10,7 +10,7 @@ from . import _exceptions from ._qs import Querystring -from .types import client_add_params, client_search_params, client_profile_params +from .types import client_add_params, client_profile_params from ._types import ( Body, Omit, @@ -48,7 +48,6 @@ make_request_options, ) from .types.add_response import AddResponse -from .types.search_response import SearchResponse from .types.profile_response import ProfileResponse __all__ = [ @@ -305,76 +304,6 @@ def profile( cast_to=ProfileResponse, ) - def search( - self, - *, - q: str, - container_tag: str | Omit = omit, - filters: client_search_params.Filters | Omit = omit, - include: client_search_params.Include | Omit = omit, - limit: int | Omit = omit, - rerank: bool | Omit = omit, - rewrite_query: bool | Omit = omit, - threshold: float | Omit = omit, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> SearchResponse: - """ - Search memory entries - Low latency for conversational - - Args: - q: Search query string - - container_tag: Optional tag this search should be containerized by. This can be an ID for your - user, a project ID, or any other identifier you wish to use to filter memories. - - filters: Optional filters to apply to the search. Can be a JSON string or Query object. - - limit: Maximum number of results to return - - rerank: If true, rerank the results based on the query. This is helpful if you want to - ensure the most relevant results are returned. - - rewrite_query: If true, rewrites the query to make it easier to find documents. This increases - the latency by about 400ms - - threshold: Threshold / sensitivity for memories selection. 0 is least sensitive (returns - most memories, more results), 1 is most sensitive (returns lesser memories, - accurate results) - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - return self.post( - "/v4/search", - body=maybe_transform( - { - "q": q, - "container_tag": container_tag, - "filters": filters, - "include": include, - "limit": limit, - "rerank": rerank, - "rewrite_query": rewrite_query, - "threshold": threshold, - }, - client_search_params.ClientSearchParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=SearchResponse, - ) - @override def _make_status_error( self, @@ -651,76 +580,6 @@ async def profile( cast_to=ProfileResponse, ) - async def search( - self, - *, - q: str, - container_tag: str | Omit = omit, - filters: client_search_params.Filters | Omit = omit, - include: client_search_params.Include | Omit = omit, - limit: int | Omit = omit, - rerank: bool | Omit = omit, - rewrite_query: bool | Omit = omit, - threshold: float | Omit = omit, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> SearchResponse: - """ - Search memory entries - Low latency for conversational - - Args: - q: Search query string - - container_tag: Optional tag this search should be containerized by. This can be an ID for your - user, a project ID, or any other identifier you wish to use to filter memories. - - filters: Optional filters to apply to the search. Can be a JSON string or Query object. - - limit: Maximum number of results to return - - rerank: If true, rerank the results based on the query. This is helpful if you want to - ensure the most relevant results are returned. - - rewrite_query: If true, rewrites the query to make it easier to find documents. This increases - the latency by about 400ms - - threshold: Threshold / sensitivity for memories selection. 0 is least sensitive (returns - most memories, more results), 1 is most sensitive (returns lesser memories, - accurate results) - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - return await self.post( - "/v4/search", - body=await async_maybe_transform( - { - "q": q, - "container_tag": container_tag, - "filters": filters, - "include": include, - "limit": limit, - "rerank": rerank, - "rewrite_query": rewrite_query, - "threshold": threshold, - }, - client_search_params.ClientSearchParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=SearchResponse, - ) - @override def _make_status_error( self, @@ -769,9 +628,6 @@ def __init__(self, client: Supermemory) -> None: self.profile = to_raw_response_wrapper( client.profile, ) - self.search = to_raw_response_wrapper( - client.search, - ) class AsyncSupermemoryWithRawResponse: @@ -788,9 +644,6 @@ def __init__(self, client: AsyncSupermemory) -> None: self.profile = async_to_raw_response_wrapper( client.profile, ) - self.search = async_to_raw_response_wrapper( - client.search, - ) class SupermemoryWithStreamedResponse: @@ -807,9 +660,6 @@ def __init__(self, client: Supermemory) -> None: self.profile = to_streamed_response_wrapper( client.profile, ) - self.search = to_streamed_response_wrapper( - client.search, - ) class AsyncSupermemoryWithStreamedResponse: @@ -826,9 +676,6 @@ def __init__(self, client: AsyncSupermemory) -> None: self.profile = async_to_streamed_response_wrapper( client.profile, ) - self.search = async_to_streamed_response_wrapper( - client.search, - ) Client = Supermemory diff --git a/src/supermemory/_version.py b/src/supermemory/_version.py index 8afdf66..e8b946f 100644 --- a/src/supermemory/_version.py +++ b/src/supermemory/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "supermemory" -__version__ = "3.9.0" # x-release-please-version +__version__ = "3.10.0" # x-release-please-version diff --git a/src/supermemory/resources/documents.py b/src/supermemory/resources/documents.py index 6ae976a..c99a3a5 100644 --- a/src/supermemory/resources/documents.py +++ b/src/supermemory/resources/documents.py @@ -2,7 +2,7 @@ from __future__ import annotations -from typing import Dict, Union, Mapping, cast +from typing import Dict, Union, Mapping, Iterable, cast from typing_extensions import Literal import httpx @@ -11,6 +11,7 @@ document_add_params, document_list_params, document_update_params, + document_batch_add_params, document_delete_bulk_params, document_upload_file_params, ) @@ -29,8 +30,10 @@ from ..types.document_get_response import DocumentGetResponse from ..types.document_list_response import DocumentListResponse from ..types.document_update_response import DocumentUpdateResponse +from ..types.document_batch_add_response import DocumentBatchAddResponse from ..types.document_delete_bulk_response import DocumentDeleteBulkResponse from ..types.document_upload_file_response import DocumentUploadFileResponse +from ..types.document_list_processing_response import DocumentListProcessingResponse __all__ = ["DocumentsResource", "AsyncDocumentsResource"] @@ -285,6 +288,67 @@ def add( cast_to=DocumentAddResponse, ) + def batch_add( + self, + *, + documents: Union[Iterable[document_batch_add_params.DocumentsUnionMember0], SequenceNotStr[str]], + container_tag: str | Omit = omit, + container_tags: SequenceNotStr[str] | Omit = omit, + content: None | Omit = omit, + metadata: Dict[str, Union[str, float, bool, SequenceNotStr[str]]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> DocumentBatchAddResponse: + """Add multiple documents in a single request. + + Each document can have any content + type (text, url, file, etc.) and metadata + + Args: + container_tag: Optional tag this document should be containerized by. This can be an ID for + your user, a project ID, or any other identifier you wish to use to group + documents. + + container_tags: (DEPRECATED: Use containerTag instead) Optional tags this document should be + containerized by. This can be an ID for your user, a project ID, or any other + identifier you wish to use to group documents. + + metadata: Optional metadata for the document. This is used to store additional information + about the document. You can use this to store any additional information you + need about the document. Metadata can be filtered through. Keys must be strings + and are case sensitive. Values can be strings, numbers, or booleans. You cannot + nest objects. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v3/documents/batch", + body=maybe_transform( + { + "documents": documents, + "container_tag": container_tag, + "container_tags": container_tags, + "content": content, + "metadata": metadata, + }, + document_batch_add_params.DocumentBatchAddParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DocumentBatchAddResponse, + ) + def delete_bulk( self, *, @@ -361,6 +425,25 @@ def get( cast_to=DocumentGetResponse, ) + def list_processing( + self, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> DocumentListProcessingResponse: + """Get documents that are currently being processed""" + return self._get( + "/v3/documents/processing", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DocumentListProcessingResponse, + ) + def upload_file( self, *, @@ -681,6 +764,67 @@ async def add( cast_to=DocumentAddResponse, ) + async def batch_add( + self, + *, + documents: Union[Iterable[document_batch_add_params.DocumentsUnionMember0], SequenceNotStr[str]], + container_tag: str | Omit = omit, + container_tags: SequenceNotStr[str] | Omit = omit, + content: None | Omit = omit, + metadata: Dict[str, Union[str, float, bool, SequenceNotStr[str]]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> DocumentBatchAddResponse: + """Add multiple documents in a single request. + + Each document can have any content + type (text, url, file, etc.) and metadata + + Args: + container_tag: Optional tag this document should be containerized by. This can be an ID for + your user, a project ID, or any other identifier you wish to use to group + documents. + + container_tags: (DEPRECATED: Use containerTag instead) Optional tags this document should be + containerized by. This can be an ID for your user, a project ID, or any other + identifier you wish to use to group documents. + + metadata: Optional metadata for the document. This is used to store additional information + about the document. You can use this to store any additional information you + need about the document. Metadata can be filtered through. Keys must be strings + and are case sensitive. Values can be strings, numbers, or booleans. You cannot + nest objects. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v3/documents/batch", + body=await async_maybe_transform( + { + "documents": documents, + "container_tag": container_tag, + "container_tags": container_tags, + "content": content, + "metadata": metadata, + }, + document_batch_add_params.DocumentBatchAddParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DocumentBatchAddResponse, + ) + async def delete_bulk( self, *, @@ -757,6 +901,25 @@ async def get( cast_to=DocumentGetResponse, ) + async def list_processing( + self, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> DocumentListProcessingResponse: + """Get documents that are currently being processed""" + return await self._get( + "/v3/documents/processing", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DocumentListProcessingResponse, + ) + async def upload_file( self, *, @@ -843,12 +1006,18 @@ def __init__(self, documents: DocumentsResource) -> None: self.add = to_raw_response_wrapper( documents.add, ) + self.batch_add = to_raw_response_wrapper( + documents.batch_add, + ) self.delete_bulk = to_raw_response_wrapper( documents.delete_bulk, ) self.get = to_raw_response_wrapper( documents.get, ) + self.list_processing = to_raw_response_wrapper( + documents.list_processing, + ) self.upload_file = to_raw_response_wrapper( documents.upload_file, ) @@ -870,12 +1039,18 @@ def __init__(self, documents: AsyncDocumentsResource) -> None: self.add = async_to_raw_response_wrapper( documents.add, ) + self.batch_add = async_to_raw_response_wrapper( + documents.batch_add, + ) self.delete_bulk = async_to_raw_response_wrapper( documents.delete_bulk, ) self.get = async_to_raw_response_wrapper( documents.get, ) + self.list_processing = async_to_raw_response_wrapper( + documents.list_processing, + ) self.upload_file = async_to_raw_response_wrapper( documents.upload_file, ) @@ -897,12 +1072,18 @@ def __init__(self, documents: DocumentsResource) -> None: self.add = to_streamed_response_wrapper( documents.add, ) + self.batch_add = to_streamed_response_wrapper( + documents.batch_add, + ) self.delete_bulk = to_streamed_response_wrapper( documents.delete_bulk, ) self.get = to_streamed_response_wrapper( documents.get, ) + self.list_processing = to_streamed_response_wrapper( + documents.list_processing, + ) self.upload_file = to_streamed_response_wrapper( documents.upload_file, ) @@ -924,12 +1105,18 @@ def __init__(self, documents: AsyncDocumentsResource) -> None: self.add = async_to_streamed_response_wrapper( documents.add, ) + self.batch_add = async_to_streamed_response_wrapper( + documents.batch_add, + ) self.delete_bulk = async_to_streamed_response_wrapper( documents.delete_bulk, ) self.get = async_to_streamed_response_wrapper( documents.get, ) + self.list_processing = async_to_streamed_response_wrapper( + documents.list_processing, + ) self.upload_file = async_to_streamed_response_wrapper( documents.upload_file, ) diff --git a/src/supermemory/types/__init__.py b/src/supermemory/types/__init__.py index a60c46c..0cdef25 100644 --- a/src/supermemory/types/__init__.py +++ b/src/supermemory/types/__init__.py @@ -3,7 +3,6 @@ from __future__ import annotations from .add_response import AddResponse as AddResponse -from .search_response import SearchResponse as SearchResponse from .profile_response import ProfileResponse as ProfileResponse from .client_add_params import ClientAddParams as ClientAddParams from .memory_add_params import MemoryAddParams as MemoryAddParams @@ -11,7 +10,6 @@ from .document_add_params import DocumentAddParams as DocumentAddParams from .memory_add_response import MemoryAddResponse as MemoryAddResponse from .memory_get_response import MemoryGetResponse as MemoryGetResponse -from .client_search_params import ClientSearchParams as ClientSearchParams from .document_list_params import DocumentListParams as DocumentListParams from .memory_forget_params import MemoryForgetParams as MemoryForgetParams from .memory_list_response import MemoryListResponse as MemoryListResponse @@ -36,12 +34,14 @@ from .connection_list_response import ConnectionListResponse as ConnectionListResponse from .document_update_response import DocumentUpdateResponse as DocumentUpdateResponse from .search_memories_response import SearchMemoriesResponse as SearchMemoriesResponse +from .document_batch_add_params import DocumentBatchAddParams as DocumentBatchAddParams from .memory_upload_file_params import MemoryUploadFileParams as MemoryUploadFileParams from .search_documents_response import SearchDocumentsResponse as SearchDocumentsResponse from .connection_create_response import ConnectionCreateResponse as ConnectionCreateResponse from .connection_import_response import ConnectionImportResponse as ConnectionImportResponse from .connection_configure_params import ConnectionConfigureParams as ConnectionConfigureParams from .connection_resources_params import ConnectionResourcesParams as ConnectionResourcesParams +from .document_batch_add_response import DocumentBatchAddResponse as DocumentBatchAddResponse from .document_delete_bulk_params import DocumentDeleteBulkParams as DocumentDeleteBulkParams from .document_upload_file_params import DocumentUploadFileParams as DocumentUploadFileParams from .memory_update_memory_params import MemoryUpdateMemoryParams as MemoryUpdateMemoryParams @@ -56,6 +56,7 @@ from .connection_get_by_tag_response import ConnectionGetByTagResponse as ConnectionGetByTagResponse from .connection_delete_by_id_response import ConnectionDeleteByIDResponse as ConnectionDeleteByIDResponse from .connection_list_documents_params import ConnectionListDocumentsParams as ConnectionListDocumentsParams +from .document_list_processing_response import DocumentListProcessingResponse as DocumentListProcessingResponse from .connection_list_documents_response import ConnectionListDocumentsResponse as ConnectionListDocumentsResponse from .connection_delete_by_provider_params import ConnectionDeleteByProviderParams as ConnectionDeleteByProviderParams from .connection_delete_by_provider_response import ( diff --git a/src/supermemory/types/client_search_params.py b/src/supermemory/types/client_search_params.py deleted file mode 100644 index fbc5e24..0000000 --- a/src/supermemory/types/client_search_params.py +++ /dev/null @@ -1,85 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union, Iterable -from typing_extensions import Required, Annotated, TypeAlias, TypedDict - -from .._utils import PropertyInfo - -__all__ = ["ClientSearchParams", "Filters", "FiltersOr", "FiltersAnd", "Include"] - - -class ClientSearchParams(TypedDict, total=False): - q: Required[str] - """Search query string""" - - container_tag: Annotated[str, PropertyInfo(alias="containerTag")] - """Optional tag this search should be containerized by. - - This can be an ID for your user, a project ID, or any other identifier you wish - to use to filter memories. - """ - - filters: Filters - """Optional filters to apply to the search. Can be a JSON string or Query object.""" - - include: Include - - limit: int - """Maximum number of results to return""" - - rerank: bool - """If true, rerank the results based on the query. - - This is helpful if you want to ensure the most relevant results are returned. - """ - - rewrite_query: Annotated[bool, PropertyInfo(alias="rewriteQuery")] - """If true, rewrites the query to make it easier to find documents. - - This increases the latency by about 400ms - """ - - threshold: float - """Threshold / sensitivity for memories selection. - - 0 is least sensitive (returns most memories, more results), 1 is most sensitive - (returns lesser memories, accurate results) - """ - - -class FiltersOr(TypedDict, total=False): - """OR""" - - or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] - - -class FiltersAnd(TypedDict, total=False): - """AND""" - - and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] - - -Filters: TypeAlias = Union[FiltersOr, FiltersAnd] - - -class Include(TypedDict, total=False): - chunks: bool - """ - If true, fetch and return chunks from documents associated with the found - memories. Performs vector search on chunks within those documents. - """ - - documents: bool - - forgotten_memories: Annotated[bool, PropertyInfo(alias="forgottenMemories")] - """If true, include forgotten memories in search results. - - Forgotten memories are memories that have been explicitly forgotten or have - passed their expiration date. - """ - - related_memories: Annotated[bool, PropertyInfo(alias="relatedMemories")] - - summaries: bool diff --git a/src/supermemory/types/document_batch_add_params.py b/src/supermemory/types/document_batch_add_params.py new file mode 100644 index 0000000..4a35fe8 --- /dev/null +++ b/src/supermemory/types/document_batch_add_params.py @@ -0,0 +1,84 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Iterable +from typing_extensions import Required, Annotated, TypedDict + +from .._types import SequenceNotStr +from .._utils import PropertyInfo + +__all__ = ["DocumentBatchAddParams", "DocumentsUnionMember0"] + + +class DocumentBatchAddParams(TypedDict, total=False): + documents: Required[Union[Iterable[DocumentsUnionMember0], SequenceNotStr[str]]] + + container_tag: Annotated[str, PropertyInfo(alias="containerTag")] + """Optional tag this document should be containerized by. + + This can be an ID for your user, a project ID, or any other identifier you wish + to use to group documents. + """ + + container_tags: Annotated[SequenceNotStr[str], PropertyInfo(alias="containerTags")] + """ + (DEPRECATED: Use containerTag instead) Optional tags this document should be + containerized by. This can be an ID for your user, a project ID, or any other + identifier you wish to use to group documents. + """ + + content: None + + metadata: Dict[str, Union[str, float, bool, SequenceNotStr[str]]] + """Optional metadata for the document. + + This is used to store additional information about the document. You can use + this to store any additional information you need about the document. Metadata + can be filtered through. Keys must be strings and are case sensitive. Values can + be strings, numbers, or booleans. You cannot nest objects. + """ + + +class DocumentsUnionMember0(TypedDict, total=False): + content: Required[str] + """The content to extract and process into a document. + + This can be a URL to a website, a PDF, an image, or a video. + + Plaintext: Any plaintext format + + URL: A URL to a website, PDF, image, or video + + We automatically detect the content type from the url's response format. + """ + + container_tag: Annotated[str, PropertyInfo(alias="containerTag")] + """Optional tag this document should be containerized by. + + This can be an ID for your user, a project ID, or any other identifier you wish + to use to group documents. + """ + + container_tags: Annotated[SequenceNotStr[str], PropertyInfo(alias="containerTags")] + """ + (DEPRECATED: Use containerTag instead) Optional tags this document should be + containerized by. This can be an ID for your user, a project ID, or any other + identifier you wish to use to group documents. + """ + + custom_id: Annotated[str, PropertyInfo(alias="customId")] + """Optional custom ID of the document. + + This could be an ID from your database that will uniquely identify this + document. + """ + + metadata: Dict[str, Union[str, float, bool, SequenceNotStr[str]]] + """Optional metadata for the document. + + This is used to store additional information about the document. You can use + this to store any additional information you need about the document. Metadata + can be filtered through. Keys must be strings and are case sensitive. Values can + be strings, numbers, or booleans. You cannot nest objects. + """ diff --git a/src/supermemory/types/document_batch_add_response.py b/src/supermemory/types/document_batch_add_response.py new file mode 100644 index 0000000..f5a3bda --- /dev/null +++ b/src/supermemory/types/document_batch_add_response.py @@ -0,0 +1,19 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .._models import BaseModel + +__all__ = ["DocumentBatchAddResponse", "DocumentBatchAddResponseItem"] + + +class DocumentBatchAddResponseItem(BaseModel): + id: str + """Unique identifier of the document""" + + status: str + """Status of the document""" + + +DocumentBatchAddResponse: TypeAlias = List[DocumentBatchAddResponseItem] diff --git a/src/supermemory/types/document_list_params.py b/src/supermemory/types/document_list_params.py index c3aab05..d37a0e3 100644 --- a/src/supermemory/types/document_list_params.py +++ b/src/supermemory/types/document_list_params.py @@ -8,7 +8,324 @@ from .._types import SequenceNotStr from .._utils import PropertyInfo -__all__ = ["DocumentListParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = [ + "DocumentListParams", + "Filters", + "FiltersOr", + "FiltersOrOr", + "FiltersOrOrUnionMember0", + "FiltersOrOrOr", + "FiltersOrOrOrOr", + "FiltersOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOr", + "FiltersOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrOrOrOrOrAndAndOr", + "FiltersOrOrOrOrOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrOrOrAndAndOr", + "FiltersOrOrOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0", + "FiltersOrOrOrOrOrOrAndAndOrOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrAnd", + "FiltersOrOrOrOrOrOrAndAndOrOrAndAnd", + "FiltersOrOrOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0", + "FiltersOrOrOrOrOrOrAndAndAndAndOr", + "FiltersOrOrOrOrOrOrAndAndAndAndOrOr", + "FiltersOrOrOrOrOrOrAndAndAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAndAndAnd", + "FiltersOrOrOrOrAnd", + "FiltersOrOrOrOrAndAnd", + "FiltersOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrAndAndOr", + "FiltersOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrAndAndOrOrUnionMember0", + "FiltersOrOrOrOrAndAndOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0", + "FiltersOrOrOrOrAndAndOrOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrAnd", + "FiltersOrOrOrOrAndAndOrOrOrOrAndAnd", + "FiltersOrOrOrOrAndAndOrOrAnd", + "FiltersOrOrOrOrAndAndOrOrAndAnd", + "FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0", + "FiltersOrOrOrOrAndAndOrOrAndAndOr", + "FiltersOrOrOrOrAndAndOrOrAndAndOrOr", + "FiltersOrOrOrOrAndAndOrOrAndAndAnd", + "FiltersOrOrOrOrAndAndOrOrAndAndAndAnd", + "FiltersOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndUnionMember0", + "FiltersOrOrOrOrAndAndAndAndOr", + "FiltersOrOrOrOrAndAndAndAndOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0", + "FiltersOrOrOrOrAndAndAndAndOrOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrAnd", + "FiltersOrOrOrOrAndAndAndAndOrOrAndAnd", + "FiltersOrOrOrOrAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0", + "FiltersOrOrOrOrAndAndAndAndAndAndOr", + "FiltersOrOrOrOrAndAndAndAndAndAndOrOr", + "FiltersOrOrOrOrAndAndAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAndAndAnd", + "FiltersOrOrAnd", + "FiltersOrOrAndAnd", + "FiltersOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOr", + "FiltersOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOr", + "FiltersOrOrAndAndOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrAnd", + "FiltersOrOrAndAndOrOrOrOrOrOrAndAnd", + "FiltersOrOrAndAndOrOrOrOrAnd", + "FiltersOrOrAndAndOrOrOrOrAndAnd", + "FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOrOrOrOrAndAndOr", + "FiltersOrOrAndAndOrOrOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrOrOrAndAndAnd", + "FiltersOrOrAndAndOrOrOrOrAndAndAndAnd", + "FiltersOrOrAndAndOrOrAnd", + "FiltersOrOrAndAndOrOrAndAnd", + "FiltersOrOrAndAndOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOrOrAndAndOr", + "FiltersOrOrAndAndOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0", + "FiltersOrOrAndAndOrOrAndAndOrOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrAnd", + "FiltersOrOrAndAndOrOrAndAndOrOrAndAnd", + "FiltersOrOrAndAndOrOrAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0", + "FiltersOrOrAndAndOrOrAndAndAndAndOr", + "FiltersOrOrAndAndOrOrAndAndAndAndOrOr", + "FiltersOrOrAndAndOrOrAndAndAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAndAndAnd", + "FiltersOrOrAndAndAnd", + "FiltersOrOrAndAndAndAnd", + "FiltersOrOrAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndOr", + "FiltersOrOrAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndOrOrUnionMember0", + "FiltersOrOrAndAndAndAndOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0", + "FiltersOrOrAndAndAndAndOrOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrAnd", + "FiltersOrOrAndAndAndAndOrOrOrOrAndAnd", + "FiltersOrOrAndAndAndAndOrOrAnd", + "FiltersOrOrAndAndAndAndOrOrAndAnd", + "FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0", + "FiltersOrOrAndAndAndAndOrOrAndAndOr", + "FiltersOrOrAndAndAndAndOrOrAndAndOrOr", + "FiltersOrOrAndAndAndAndOrOrAndAndAnd", + "FiltersOrOrAndAndAndAndOrOrAndAndAndAnd", + "FiltersOrOrAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndAndAndOr", + "FiltersOrOrAndAndAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0", + "FiltersOrOrAndAndAndAndAndAndOrOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrAnd", + "FiltersOrOrAndAndAndAndAndAndOrOrAndAnd", + "FiltersOrOrAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndAndAndAndAndOr", + "FiltersOrOrAndAndAndAndAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAndAndAnd", + "FiltersAnd", + "FiltersAndAnd", + "FiltersAndAndUnionMember0", + "FiltersAndAndOr", + "FiltersAndAndOrOr", + "FiltersAndAndOrOrUnionMember0", + "FiltersAndAndOrOrOr", + "FiltersAndAndOrOrOrOr", + "FiltersAndAndOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0", + "FiltersAndAndOrOrOrOrOrOrAndAndOr", + "FiltersAndAndOrOrOrOrOrOrAndAndOrOr", + "FiltersAndAndOrOrOrOrOrOrAndAndAnd", + "FiltersAndAndOrOrOrOrOrOrAndAndAndAnd", + "FiltersAndAndOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrAndAndUnionMember0", + "FiltersAndAndOrOrOrOrAndAndOr", + "FiltersAndAndOrOrOrOrAndAndOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0", + "FiltersAndAndOrOrOrOrAndAndOrOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrAnd", + "FiltersAndAndOrOrOrOrAndAndOrOrAndAnd", + "FiltersAndAndOrOrOrOrAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0", + "FiltersAndAndOrOrOrOrAndAndAndAndOr", + "FiltersAndAndOrOrOrOrAndAndAndAndOrOr", + "FiltersAndAndOrOrOrOrAndAndAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAndAndAnd", + "FiltersAndAndOrOrAnd", + "FiltersAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndUnionMember0", + "FiltersAndAndOrOrAndAndOr", + "FiltersAndAndOrOrAndAndOrOr", + "FiltersAndAndOrOrAndAndOrOrUnionMember0", + "FiltersAndAndOrOrAndAndOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0", + "FiltersAndAndOrOrAndAndOrOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrAnd", + "FiltersAndAndOrOrAndAndOrOrOrOrAndAnd", + "FiltersAndAndOrOrAndAndOrOrAnd", + "FiltersAndAndOrOrAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0", + "FiltersAndAndOrOrAndAndOrOrAndAndOr", + "FiltersAndAndOrOrAndAndOrOrAndAndOrOr", + "FiltersAndAndOrOrAndAndOrOrAndAndAnd", + "FiltersAndAndOrOrAndAndOrOrAndAndAndAnd", + "FiltersAndAndOrOrAndAndAnd", + "FiltersAndAndOrOrAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndUnionMember0", + "FiltersAndAndOrOrAndAndAndAndOr", + "FiltersAndAndOrOrAndAndAndAndOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0", + "FiltersAndAndOrOrAndAndAndAndOrOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrAnd", + "FiltersAndAndOrOrAndAndAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0", + "FiltersAndAndOrOrAndAndAndAndAndAndOr", + "FiltersAndAndOrOrAndAndAndAndAndAndOrOr", + "FiltersAndAndOrOrAndAndAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAndAndAnd", + "FiltersAndAndAnd", + "FiltersAndAndAndAnd", + "FiltersAndAndAndAndUnionMember0", + "FiltersAndAndAndAndOr", + "FiltersAndAndAndAndOrOr", + "FiltersAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOr", + "FiltersAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrAnd", + "FiltersAndAndAndAndOrOrOrOrOrOrAndAnd", + "FiltersAndAndAndAndOrOrOrOrAnd", + "FiltersAndAndAndAndOrOrOrOrAndAnd", + "FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0", + "FiltersAndAndAndAndOrOrOrOrAndAndOr", + "FiltersAndAndAndAndOrOrOrOrAndAndOrOr", + "FiltersAndAndAndAndOrOrOrOrAndAndAnd", + "FiltersAndAndAndAndOrOrOrOrAndAndAndAnd", + "FiltersAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndOrOrAndAndUnionMember0", + "FiltersAndAndAndAndOrOrAndAndOr", + "FiltersAndAndAndAndOrOrAndAndOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0", + "FiltersAndAndAndAndOrOrAndAndOrOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrAnd", + "FiltersAndAndAndAndOrOrAndAndOrOrAndAnd", + "FiltersAndAndAndAndOrOrAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0", + "FiltersAndAndAndAndOrOrAndAndAndAndOr", + "FiltersAndAndAndAndOrOrAndAndAndAndOrOr", + "FiltersAndAndAndAndOrOrAndAndAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAndAndAnd", + "FiltersAndAndAndAndAnd", + "FiltersAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndAndAndOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0", + "FiltersAndAndAndAndAndAndOrOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrAnd", + "FiltersAndAndAndAndAndAndOrOrOrOrAndAnd", + "FiltersAndAndAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0", + "FiltersAndAndAndAndAndAndOrOrAndAndOr", + "FiltersAndAndAndAndAndAndOrOrAndAndOrOr", + "FiltersAndAndAndAndAndAndOrOrAndAndAnd", + "FiltersAndAndAndAndAndAndOrOrAndAndAndAnd", + "FiltersAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndAndAndAndAndOrOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAndAndAnd", +] class DocumentListParams(TypedDict, total=False): @@ -41,16 +358,3482 @@ class DocumentListParams(TypedDict, total=False): """Field to sort by""" +class FiltersOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrOrOrAnd +] + + +class FiltersOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrAnd +] + + +class FiltersOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrOrOrAndAndOrOrAnd +] + + +class FiltersOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrOrOrAndAndAndAndAnd +] + + +class FiltersOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrAnd] + + +class FiltersOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOrOrOr, FiltersOrOrOrOrAndAndOrOrOrOrAnd +] + + +class FiltersOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOrOrAndAndOr, FiltersOrOrOrOrAndAndOrOrAndAndAnd +] + + +class FiltersOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrAndAndOrOrAnd +] + + +class FiltersOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndAndAndOrOrOr, FiltersOrOrOrOrAndAndAndAndOrOrAnd +] + + +class FiltersOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0, + FiltersOrOrOrOrAndAndAndAndAndAndOr, + FiltersOrOrOrOrAndAndAndAndAndAndAnd, +] + + +class FiltersOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrAndAndAndAndAnd +] + + +class FiltersOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOr, FiltersOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrUnionMember0, FiltersOrOrOrOrOr, FiltersOrOrOrOrAnd] + + +class FiltersOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrOrOrAnd +] + + +class FiltersOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrOrOrAndAndOr, FiltersOrOrAndAndOrOrOrOrAndAndAnd +] + + +class FiltersOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrAnd +] + + +class FiltersOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAndAndOrOrAnd +] + + +class FiltersOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0, + FiltersOrOrAndAndOrOrAndAndAndAndOr, + FiltersOrOrAndAndOrOrAndAndAndAndAnd, +] + + +class FiltersOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrAndAndOr, FiltersOrOrAndAndOrOrAndAndAnd +] + + +class FiltersOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAnd +] + + +class FiltersOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOrOrOr, FiltersOrOrAndAndAndAndOrOrOrOrAnd +] + + +class FiltersOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0, + FiltersOrOrAndAndAndAndOrOrAndAndOr, + FiltersOrOrAndAndAndAndOrOrAndAndAnd, +] + + +class FiltersOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOr, FiltersOrOrAndAndAndAndOrOrAnd +] + + +class FiltersOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0, + FiltersOrOrAndAndAndAndAndAndOrOrOr, + FiltersOrOrAndAndAndAndAndAndOrOrAnd, +] + + +class FiltersOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0, + FiltersOrOrAndAndAndAndAndAndAndAndOr, + FiltersOrOrAndAndAndAndAndAndAndAndAnd, +] + + +class FiltersOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndAndAndOr, FiltersOrOrAndAndAndAndAndAndAnd +] + + +class FiltersOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndOr, FiltersOrOrAndAndAndAndAnd +] + + +class FiltersOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAnd: TypeAlias = Union[FiltersOrOrAndAndUnionMember0, FiltersOrOrAndAndOr, FiltersOrOrAndAndAnd] + + +class FiltersOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd] + + class FiltersOr(TypedDict, total=False): - """OR""" + or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] + """Array of OR filter expressions""" + + +class FiltersAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrOrOrAndAndAnd +] + + +class FiltersAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrOrOrAndAndOrOrOr, FiltersAndAndOrOrOrOrAndAndOrOrAnd +] + + +class FiltersAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0, + FiltersAndAndOrOrOrOrAndAndAndAndOr, + FiltersAndAndOrOrOrOrAndAndAndAndAnd, +] + + +class FiltersAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrAndAndAnd +] + + +class FiltersAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOr, FiltersAndAndOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOrOrOr, FiltersAndAndOrOrAndAndOrOrOrOrAnd +] + + +class FiltersAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0, + FiltersAndAndOrOrAndAndOrOrAndAndOr, + FiltersAndAndOrOrAndAndOrOrAndAndAnd, +] + + +class FiltersAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOr, FiltersAndAndOrOrAndAndOrOrAnd +] + + +class FiltersAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0, + FiltersAndAndOrOrAndAndAndAndOrOrOr, + FiltersAndAndOrOrAndAndAndAndOrOrAnd, +] + + +class FiltersAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0, + FiltersAndAndOrOrAndAndAndAndAndAndOr, + FiltersAndAndOrOrAndAndAndAndAndAndAnd, +] + + +class FiltersAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndUnionMember0, FiltersAndAndOrOrAndAndAndAndOr, FiltersAndAndOrOrAndAndAndAndAnd +] + + +class FiltersAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndUnionMember0, FiltersAndAndOrOrAndAndOr, FiltersAndAndOrOrAndAndAnd +] + + +class FiltersAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOr: TypeAlias = Union[FiltersAndAndOrOrUnionMember0, FiltersAndAndOrOrOr, FiltersAndAndOrOrAnd] + + +class FiltersAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrOrOrAnd +] + + +class FiltersAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0, + FiltersAndAndAndAndOrOrOrOrAndAndOr, + FiltersAndAndAndAndOrOrOrOrAndAndAnd, +] + + +class FiltersAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrAnd +] + + +class FiltersAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] - or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] -class FiltersAnd(TypedDict, total=False): - """AND""" + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0, + FiltersAndAndAndAndOrOrAndAndOrOrOr, + FiltersAndAndAndAndOrOrAndAndOrOrAnd, +] + + +class FiltersAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0, + FiltersAndAndAndAndOrOrAndAndAndAndOr, + FiltersAndAndAndAndOrOrAndAndAndAndAnd, +] + + +class FiltersAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndUnionMember0, FiltersAndAndAndAndOrOrAndAndOr, FiltersAndAndAndAndOrOrAndAndAnd +] + + +class FiltersAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndOrOrOr, FiltersAndAndAndAndOrOrAnd +] + + +class FiltersAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0, + FiltersAndAndAndAndAndAndOrOrOrOrOr, + FiltersAndAndAndAndAndAndOrOrOrOrAnd, +] + + +class FiltersAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] - and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0, + FiltersAndAndAndAndAndAndOrOrAndAndOr, + FiltersAndAndAndAndAndAndOrOrAndAndAnd, +] + + +class FiltersAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndAndAndOrOrOr, FiltersAndAndAndAndAndAndOrOrAnd +] + + +class FiltersAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0, + FiltersAndAndAndAndAndAndAndAndOrOrOr, + FiltersAndAndAndAndAndAndAndAndOrOrAnd, +] + + +class FiltersAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0, + FiltersAndAndAndAndAndAndAndAndAndAndOr, + FiltersAndAndAndAndAndAndAndAndAndAndAnd, +] + + +class FiltersAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAndAndAnd +] + + +class FiltersAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAnd +] + + +class FiltersAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAnd: TypeAlias = Union[FiltersAndAndAndAndUnionMember0, FiltersAndAndAndAndOr, FiltersAndAndAndAndAnd] + + +class FiltersAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] + + +class FiltersAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] + """Array of AND filter expressions""" Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/src/supermemory/types/document_list_processing_response.py b/src/supermemory/types/document_list_processing_response.py new file mode 100644 index 0000000..6a671b2 --- /dev/null +++ b/src/supermemory/types/document_list_processing_response.py @@ -0,0 +1,75 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, List, Union, Optional +from typing_extensions import Literal + +from pydantic import Field as FieldInfo + +from .._models import BaseModel + +__all__ = ["DocumentListProcessingResponse", "Document"] + + +class Document(BaseModel): + id: str + """Unique identifier of the document.""" + + created_at: str = FieldInfo(alias="createdAt") + """Creation timestamp""" + + custom_id: Optional[str] = FieldInfo(alias="customId", default=None) + """Optional custom ID of the document. + + This could be an ID from your database that will uniquely identify this + document. + """ + + metadata: Union[str, float, bool, Dict[str, object], List[object], None] = None + """Optional metadata for the document. + + This is used to store additional information about the document. You can use + this to store any additional information you need about the document. Metadata + can be filtered through. Keys must be strings and are case sensitive. Values can + be strings, numbers, or booleans. You cannot nest objects. + """ + + status: Literal["unknown", "queued", "extracting", "chunking", "embedding", "indexing", "done", "failed"] + """Status of the document""" + + title: Optional[str] = None + """Title of the document""" + + type: Literal[ + "text", + "pdf", + "tweet", + "google_doc", + "google_slide", + "google_sheet", + "image", + "video", + "notion_doc", + "webpage", + "onedrive", + "github_markdown", + ] + """Type of the document""" + + updated_at: str = FieldInfo(alias="updatedAt") + """Last update timestamp""" + + container_tags: Optional[List[str]] = FieldInfo(alias="containerTags", default=None) + """Optional tags this document should be containerized by. + + This can be an ID for your user, a project ID, or any other identifier you wish + to use to group documents. + """ + + +class DocumentListProcessingResponse(BaseModel): + """List of documents currently being processed""" + + documents: List[Document] + + total_count: float = FieldInfo(alias="totalCount") + """Total number of processing documents""" diff --git a/src/supermemory/types/memory_list_params.py b/src/supermemory/types/memory_list_params.py index 31ac58f..2e2cb57 100644 --- a/src/supermemory/types/memory_list_params.py +++ b/src/supermemory/types/memory_list_params.py @@ -8,7 +8,324 @@ from .._types import SequenceNotStr from .._utils import PropertyInfo -__all__ = ["MemoryListParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = [ + "MemoryListParams", + "Filters", + "FiltersOr", + "FiltersOrOr", + "FiltersOrOrUnionMember0", + "FiltersOrOrOr", + "FiltersOrOrOrOr", + "FiltersOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOr", + "FiltersOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrOrOrOrOrAndAndOr", + "FiltersOrOrOrOrOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrOrOrAndAndOr", + "FiltersOrOrOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0", + "FiltersOrOrOrOrOrOrAndAndOrOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrAnd", + "FiltersOrOrOrOrOrOrAndAndOrOrAndAnd", + "FiltersOrOrOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0", + "FiltersOrOrOrOrOrOrAndAndAndAndOr", + "FiltersOrOrOrOrOrOrAndAndAndAndOrOr", + "FiltersOrOrOrOrOrOrAndAndAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAndAndAnd", + "FiltersOrOrOrOrAnd", + "FiltersOrOrOrOrAndAnd", + "FiltersOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrAndAndOr", + "FiltersOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrAndAndOrOrUnionMember0", + "FiltersOrOrOrOrAndAndOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0", + "FiltersOrOrOrOrAndAndOrOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrAnd", + "FiltersOrOrOrOrAndAndOrOrOrOrAndAnd", + "FiltersOrOrOrOrAndAndOrOrAnd", + "FiltersOrOrOrOrAndAndOrOrAndAnd", + "FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0", + "FiltersOrOrOrOrAndAndOrOrAndAndOr", + "FiltersOrOrOrOrAndAndOrOrAndAndOrOr", + "FiltersOrOrOrOrAndAndOrOrAndAndAnd", + "FiltersOrOrOrOrAndAndOrOrAndAndAndAnd", + "FiltersOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndUnionMember0", + "FiltersOrOrOrOrAndAndAndAndOr", + "FiltersOrOrOrOrAndAndAndAndOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0", + "FiltersOrOrOrOrAndAndAndAndOrOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrAnd", + "FiltersOrOrOrOrAndAndAndAndOrOrAndAnd", + "FiltersOrOrOrOrAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0", + "FiltersOrOrOrOrAndAndAndAndAndAndOr", + "FiltersOrOrOrOrAndAndAndAndAndAndOrOr", + "FiltersOrOrOrOrAndAndAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAndAndAnd", + "FiltersOrOrAnd", + "FiltersOrOrAndAnd", + "FiltersOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOr", + "FiltersOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOr", + "FiltersOrOrAndAndOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrAnd", + "FiltersOrOrAndAndOrOrOrOrOrOrAndAnd", + "FiltersOrOrAndAndOrOrOrOrAnd", + "FiltersOrOrAndAndOrOrOrOrAndAnd", + "FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOrOrOrOrAndAndOr", + "FiltersOrOrAndAndOrOrOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrOrOrAndAndAnd", + "FiltersOrOrAndAndOrOrOrOrAndAndAndAnd", + "FiltersOrOrAndAndOrOrAnd", + "FiltersOrOrAndAndOrOrAndAnd", + "FiltersOrOrAndAndOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOrOrAndAndOr", + "FiltersOrOrAndAndOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0", + "FiltersOrOrAndAndOrOrAndAndOrOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrAnd", + "FiltersOrOrAndAndOrOrAndAndOrOrAndAnd", + "FiltersOrOrAndAndOrOrAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0", + "FiltersOrOrAndAndOrOrAndAndAndAndOr", + "FiltersOrOrAndAndOrOrAndAndAndAndOrOr", + "FiltersOrOrAndAndOrOrAndAndAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAndAndAnd", + "FiltersOrOrAndAndAnd", + "FiltersOrOrAndAndAndAnd", + "FiltersOrOrAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndOr", + "FiltersOrOrAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndOrOrUnionMember0", + "FiltersOrOrAndAndAndAndOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0", + "FiltersOrOrAndAndAndAndOrOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrAnd", + "FiltersOrOrAndAndAndAndOrOrOrOrAndAnd", + "FiltersOrOrAndAndAndAndOrOrAnd", + "FiltersOrOrAndAndAndAndOrOrAndAnd", + "FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0", + "FiltersOrOrAndAndAndAndOrOrAndAndOr", + "FiltersOrOrAndAndAndAndOrOrAndAndOrOr", + "FiltersOrOrAndAndAndAndOrOrAndAndAnd", + "FiltersOrOrAndAndAndAndOrOrAndAndAndAnd", + "FiltersOrOrAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndAndAndOr", + "FiltersOrOrAndAndAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0", + "FiltersOrOrAndAndAndAndAndAndOrOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrAnd", + "FiltersOrOrAndAndAndAndAndAndOrOrAndAnd", + "FiltersOrOrAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndAndAndAndAndOr", + "FiltersOrOrAndAndAndAndAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAndAndAnd", + "FiltersAnd", + "FiltersAndAnd", + "FiltersAndAndUnionMember0", + "FiltersAndAndOr", + "FiltersAndAndOrOr", + "FiltersAndAndOrOrUnionMember0", + "FiltersAndAndOrOrOr", + "FiltersAndAndOrOrOrOr", + "FiltersAndAndOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0", + "FiltersAndAndOrOrOrOrOrOrAndAndOr", + "FiltersAndAndOrOrOrOrOrOrAndAndOrOr", + "FiltersAndAndOrOrOrOrOrOrAndAndAnd", + "FiltersAndAndOrOrOrOrOrOrAndAndAndAnd", + "FiltersAndAndOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrAndAndUnionMember0", + "FiltersAndAndOrOrOrOrAndAndOr", + "FiltersAndAndOrOrOrOrAndAndOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0", + "FiltersAndAndOrOrOrOrAndAndOrOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrAnd", + "FiltersAndAndOrOrOrOrAndAndOrOrAndAnd", + "FiltersAndAndOrOrOrOrAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0", + "FiltersAndAndOrOrOrOrAndAndAndAndOr", + "FiltersAndAndOrOrOrOrAndAndAndAndOrOr", + "FiltersAndAndOrOrOrOrAndAndAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAndAndAnd", + "FiltersAndAndOrOrAnd", + "FiltersAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndUnionMember0", + "FiltersAndAndOrOrAndAndOr", + "FiltersAndAndOrOrAndAndOrOr", + "FiltersAndAndOrOrAndAndOrOrUnionMember0", + "FiltersAndAndOrOrAndAndOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0", + "FiltersAndAndOrOrAndAndOrOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrAnd", + "FiltersAndAndOrOrAndAndOrOrOrOrAndAnd", + "FiltersAndAndOrOrAndAndOrOrAnd", + "FiltersAndAndOrOrAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0", + "FiltersAndAndOrOrAndAndOrOrAndAndOr", + "FiltersAndAndOrOrAndAndOrOrAndAndOrOr", + "FiltersAndAndOrOrAndAndOrOrAndAndAnd", + "FiltersAndAndOrOrAndAndOrOrAndAndAndAnd", + "FiltersAndAndOrOrAndAndAnd", + "FiltersAndAndOrOrAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndUnionMember0", + "FiltersAndAndOrOrAndAndAndAndOr", + "FiltersAndAndOrOrAndAndAndAndOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0", + "FiltersAndAndOrOrAndAndAndAndOrOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrAnd", + "FiltersAndAndOrOrAndAndAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0", + "FiltersAndAndOrOrAndAndAndAndAndAndOr", + "FiltersAndAndOrOrAndAndAndAndAndAndOrOr", + "FiltersAndAndOrOrAndAndAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAndAndAnd", + "FiltersAndAndAnd", + "FiltersAndAndAndAnd", + "FiltersAndAndAndAndUnionMember0", + "FiltersAndAndAndAndOr", + "FiltersAndAndAndAndOrOr", + "FiltersAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOr", + "FiltersAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrAnd", + "FiltersAndAndAndAndOrOrOrOrOrOrAndAnd", + "FiltersAndAndAndAndOrOrOrOrAnd", + "FiltersAndAndAndAndOrOrOrOrAndAnd", + "FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0", + "FiltersAndAndAndAndOrOrOrOrAndAndOr", + "FiltersAndAndAndAndOrOrOrOrAndAndOrOr", + "FiltersAndAndAndAndOrOrOrOrAndAndAnd", + "FiltersAndAndAndAndOrOrOrOrAndAndAndAnd", + "FiltersAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndOrOrAndAndUnionMember0", + "FiltersAndAndAndAndOrOrAndAndOr", + "FiltersAndAndAndAndOrOrAndAndOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0", + "FiltersAndAndAndAndOrOrAndAndOrOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrAnd", + "FiltersAndAndAndAndOrOrAndAndOrOrAndAnd", + "FiltersAndAndAndAndOrOrAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0", + "FiltersAndAndAndAndOrOrAndAndAndAndOr", + "FiltersAndAndAndAndOrOrAndAndAndAndOrOr", + "FiltersAndAndAndAndOrOrAndAndAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAndAndAnd", + "FiltersAndAndAndAndAnd", + "FiltersAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndAndAndOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0", + "FiltersAndAndAndAndAndAndOrOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrAnd", + "FiltersAndAndAndAndAndAndOrOrOrOrAndAnd", + "FiltersAndAndAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0", + "FiltersAndAndAndAndAndAndOrOrAndAndOr", + "FiltersAndAndAndAndAndAndOrOrAndAndOrOr", + "FiltersAndAndAndAndAndAndOrOrAndAndAnd", + "FiltersAndAndAndAndAndAndOrOrAndAndAndAnd", + "FiltersAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndAndAndAndAndOrOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAndAndAnd", +] class MemoryListParams(TypedDict, total=False): @@ -41,16 +358,3482 @@ class MemoryListParams(TypedDict, total=False): """Field to sort by""" +class FiltersOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrOrOrAnd +] + + +class FiltersOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrAnd +] + + +class FiltersOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrOrOrAndAndOrOrAnd +] + + +class FiltersOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrOrOrAndAndAndAndAnd +] + + +class FiltersOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrAnd] + + +class FiltersOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOrOrOr, FiltersOrOrOrOrAndAndOrOrOrOrAnd +] + + +class FiltersOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOrOrAndAndOr, FiltersOrOrOrOrAndAndOrOrAndAndAnd +] + + +class FiltersOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrAndAndOrOrAnd +] + + +class FiltersOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndAndAndOrOrOr, FiltersOrOrOrOrAndAndAndAndOrOrAnd +] + + +class FiltersOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0, + FiltersOrOrOrOrAndAndAndAndAndAndOr, + FiltersOrOrOrOrAndAndAndAndAndAndAnd, +] + + +class FiltersOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrAndAndAndAndAnd +] + + +class FiltersOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOr, FiltersOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrUnionMember0, FiltersOrOrOrOrOr, FiltersOrOrOrOrAnd] + + +class FiltersOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrOrOrAnd +] + + +class FiltersOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrOrOrAndAndOr, FiltersOrOrAndAndOrOrOrOrAndAndAnd +] + + +class FiltersOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrAnd +] + + +class FiltersOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAndAndOrOrAnd +] + + +class FiltersOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0, + FiltersOrOrAndAndOrOrAndAndAndAndOr, + FiltersOrOrAndAndOrOrAndAndAndAndAnd, +] + + +class FiltersOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrAndAndOr, FiltersOrOrAndAndOrOrAndAndAnd +] + + +class FiltersOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAnd +] + + +class FiltersOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOrOrOr, FiltersOrOrAndAndAndAndOrOrOrOrAnd +] + + +class FiltersOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0, + FiltersOrOrAndAndAndAndOrOrAndAndOr, + FiltersOrOrAndAndAndAndOrOrAndAndAnd, +] + + +class FiltersOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOr, FiltersOrOrAndAndAndAndOrOrAnd +] + + +class FiltersOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0, + FiltersOrOrAndAndAndAndAndAndOrOrOr, + FiltersOrOrAndAndAndAndAndAndOrOrAnd, +] + + +class FiltersOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0, + FiltersOrOrAndAndAndAndAndAndAndAndOr, + FiltersOrOrAndAndAndAndAndAndAndAndAnd, +] + + +class FiltersOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndAndAndOr, FiltersOrOrAndAndAndAndAndAndAnd +] + + +class FiltersOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndOr, FiltersOrOrAndAndAndAndAnd +] + + +class FiltersOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAnd: TypeAlias = Union[FiltersOrOrAndAndUnionMember0, FiltersOrOrAndAndOr, FiltersOrOrAndAndAnd] + + +class FiltersOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd] + + class FiltersOr(TypedDict, total=False): - """OR""" + or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] + """Array of OR filter expressions""" + + +class FiltersAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrOrOrAndAndAnd +] + + +class FiltersAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrOrOrAndAndOrOrOr, FiltersAndAndOrOrOrOrAndAndOrOrAnd +] + + +class FiltersAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0, + FiltersAndAndOrOrOrOrAndAndAndAndOr, + FiltersAndAndOrOrOrOrAndAndAndAndAnd, +] + + +class FiltersAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrAndAndAnd +] + + +class FiltersAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOr, FiltersAndAndOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOrOrOr, FiltersAndAndOrOrAndAndOrOrOrOrAnd +] + + +class FiltersAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0, + FiltersAndAndOrOrAndAndOrOrAndAndOr, + FiltersAndAndOrOrAndAndOrOrAndAndAnd, +] + + +class FiltersAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOr, FiltersAndAndOrOrAndAndOrOrAnd +] + + +class FiltersAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0, + FiltersAndAndOrOrAndAndAndAndOrOrOr, + FiltersAndAndOrOrAndAndAndAndOrOrAnd, +] + + +class FiltersAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0, + FiltersAndAndOrOrAndAndAndAndAndAndOr, + FiltersAndAndOrOrAndAndAndAndAndAndAnd, +] + + +class FiltersAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndUnionMember0, FiltersAndAndOrOrAndAndAndAndOr, FiltersAndAndOrOrAndAndAndAndAnd +] + + +class FiltersAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndUnionMember0, FiltersAndAndOrOrAndAndOr, FiltersAndAndOrOrAndAndAnd +] + + +class FiltersAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOr: TypeAlias = Union[FiltersAndAndOrOrUnionMember0, FiltersAndAndOrOrOr, FiltersAndAndOrOrAnd] + + +class FiltersAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrOrOrAnd +] + + +class FiltersAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0, + FiltersAndAndAndAndOrOrOrOrAndAndOr, + FiltersAndAndAndAndOrOrOrOrAndAndAnd, +] + + +class FiltersAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrAnd +] + + +class FiltersAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] - or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] -class FiltersAnd(TypedDict, total=False): - """AND""" + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0, + FiltersAndAndAndAndOrOrAndAndOrOrOr, + FiltersAndAndAndAndOrOrAndAndOrOrAnd, +] + + +class FiltersAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0, + FiltersAndAndAndAndOrOrAndAndAndAndOr, + FiltersAndAndAndAndOrOrAndAndAndAndAnd, +] + + +class FiltersAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndUnionMember0, FiltersAndAndAndAndOrOrAndAndOr, FiltersAndAndAndAndOrOrAndAndAnd +] + + +class FiltersAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndOrOrOr, FiltersAndAndAndAndOrOrAnd +] + + +class FiltersAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0, + FiltersAndAndAndAndAndAndOrOrOrOrOr, + FiltersAndAndAndAndAndAndOrOrOrOrAnd, +] + + +class FiltersAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] - and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0, + FiltersAndAndAndAndAndAndOrOrAndAndOr, + FiltersAndAndAndAndAndAndOrOrAndAndAnd, +] + + +class FiltersAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndAndAndOrOrOr, FiltersAndAndAndAndAndAndOrOrAnd +] + + +class FiltersAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0, + FiltersAndAndAndAndAndAndAndAndOrOrOr, + FiltersAndAndAndAndAndAndAndAndOrOrAnd, +] + + +class FiltersAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0, + FiltersAndAndAndAndAndAndAndAndAndAndOr, + FiltersAndAndAndAndAndAndAndAndAndAndAnd, +] + + +class FiltersAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAndAndAnd +] + + +class FiltersAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAnd +] + + +class FiltersAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAnd: TypeAlias = Union[FiltersAndAndAndAndUnionMember0, FiltersAndAndAndAndOr, FiltersAndAndAndAndAnd] + + +class FiltersAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] + + +class FiltersAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] + """Array of AND filter expressions""" Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/src/supermemory/types/search_documents_params.py b/src/supermemory/types/search_documents_params.py index 441ce04..87c235d 100644 --- a/src/supermemory/types/search_documents_params.py +++ b/src/supermemory/types/search_documents_params.py @@ -3,12 +3,329 @@ from __future__ import annotations from typing import Union, Iterable -from typing_extensions import Required, Annotated, TypeAlias, TypedDict +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -__all__ = ["SearchDocumentsParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = [ + "SearchDocumentsParams", + "Filters", + "FiltersOr", + "FiltersOrOr", + "FiltersOrOrUnionMember0", + "FiltersOrOrOr", + "FiltersOrOrOrOr", + "FiltersOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOr", + "FiltersOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrOrOrOrOrAndAndOr", + "FiltersOrOrOrOrOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrOrOrAndAndOr", + "FiltersOrOrOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0", + "FiltersOrOrOrOrOrOrAndAndOrOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrAnd", + "FiltersOrOrOrOrOrOrAndAndOrOrAndAnd", + "FiltersOrOrOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0", + "FiltersOrOrOrOrOrOrAndAndAndAndOr", + "FiltersOrOrOrOrOrOrAndAndAndAndOrOr", + "FiltersOrOrOrOrOrOrAndAndAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAndAndAnd", + "FiltersOrOrOrOrAnd", + "FiltersOrOrOrOrAndAnd", + "FiltersOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrAndAndOr", + "FiltersOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrAndAndOrOrUnionMember0", + "FiltersOrOrOrOrAndAndOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0", + "FiltersOrOrOrOrAndAndOrOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrAnd", + "FiltersOrOrOrOrAndAndOrOrOrOrAndAnd", + "FiltersOrOrOrOrAndAndOrOrAnd", + "FiltersOrOrOrOrAndAndOrOrAndAnd", + "FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0", + "FiltersOrOrOrOrAndAndOrOrAndAndOr", + "FiltersOrOrOrOrAndAndOrOrAndAndOrOr", + "FiltersOrOrOrOrAndAndOrOrAndAndAnd", + "FiltersOrOrOrOrAndAndOrOrAndAndAndAnd", + "FiltersOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndUnionMember0", + "FiltersOrOrOrOrAndAndAndAndOr", + "FiltersOrOrOrOrAndAndAndAndOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0", + "FiltersOrOrOrOrAndAndAndAndOrOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrAnd", + "FiltersOrOrOrOrAndAndAndAndOrOrAndAnd", + "FiltersOrOrOrOrAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0", + "FiltersOrOrOrOrAndAndAndAndAndAndOr", + "FiltersOrOrOrOrAndAndAndAndAndAndOrOr", + "FiltersOrOrOrOrAndAndAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAndAndAnd", + "FiltersOrOrAnd", + "FiltersOrOrAndAnd", + "FiltersOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOr", + "FiltersOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOr", + "FiltersOrOrAndAndOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrAnd", + "FiltersOrOrAndAndOrOrOrOrOrOrAndAnd", + "FiltersOrOrAndAndOrOrOrOrAnd", + "FiltersOrOrAndAndOrOrOrOrAndAnd", + "FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOrOrOrOrAndAndOr", + "FiltersOrOrAndAndOrOrOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrOrOrAndAndAnd", + "FiltersOrOrAndAndOrOrOrOrAndAndAndAnd", + "FiltersOrOrAndAndOrOrAnd", + "FiltersOrOrAndAndOrOrAndAnd", + "FiltersOrOrAndAndOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOrOrAndAndOr", + "FiltersOrOrAndAndOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0", + "FiltersOrOrAndAndOrOrAndAndOrOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrAnd", + "FiltersOrOrAndAndOrOrAndAndOrOrAndAnd", + "FiltersOrOrAndAndOrOrAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0", + "FiltersOrOrAndAndOrOrAndAndAndAndOr", + "FiltersOrOrAndAndOrOrAndAndAndAndOrOr", + "FiltersOrOrAndAndOrOrAndAndAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAndAndAnd", + "FiltersOrOrAndAndAnd", + "FiltersOrOrAndAndAndAnd", + "FiltersOrOrAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndOr", + "FiltersOrOrAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndOrOrUnionMember0", + "FiltersOrOrAndAndAndAndOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0", + "FiltersOrOrAndAndAndAndOrOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrAnd", + "FiltersOrOrAndAndAndAndOrOrOrOrAndAnd", + "FiltersOrOrAndAndAndAndOrOrAnd", + "FiltersOrOrAndAndAndAndOrOrAndAnd", + "FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0", + "FiltersOrOrAndAndAndAndOrOrAndAndOr", + "FiltersOrOrAndAndAndAndOrOrAndAndOrOr", + "FiltersOrOrAndAndAndAndOrOrAndAndAnd", + "FiltersOrOrAndAndAndAndOrOrAndAndAndAnd", + "FiltersOrOrAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndAndAndOr", + "FiltersOrOrAndAndAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0", + "FiltersOrOrAndAndAndAndAndAndOrOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrAnd", + "FiltersOrOrAndAndAndAndAndAndOrOrAndAnd", + "FiltersOrOrAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndAndAndAndAndOr", + "FiltersOrOrAndAndAndAndAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAndAndAnd", + "FiltersAnd", + "FiltersAndAnd", + "FiltersAndAndUnionMember0", + "FiltersAndAndOr", + "FiltersAndAndOrOr", + "FiltersAndAndOrOrUnionMember0", + "FiltersAndAndOrOrOr", + "FiltersAndAndOrOrOrOr", + "FiltersAndAndOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0", + "FiltersAndAndOrOrOrOrOrOrAndAndOr", + "FiltersAndAndOrOrOrOrOrOrAndAndOrOr", + "FiltersAndAndOrOrOrOrOrOrAndAndAnd", + "FiltersAndAndOrOrOrOrOrOrAndAndAndAnd", + "FiltersAndAndOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrAndAndUnionMember0", + "FiltersAndAndOrOrOrOrAndAndOr", + "FiltersAndAndOrOrOrOrAndAndOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0", + "FiltersAndAndOrOrOrOrAndAndOrOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrAnd", + "FiltersAndAndOrOrOrOrAndAndOrOrAndAnd", + "FiltersAndAndOrOrOrOrAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0", + "FiltersAndAndOrOrOrOrAndAndAndAndOr", + "FiltersAndAndOrOrOrOrAndAndAndAndOrOr", + "FiltersAndAndOrOrOrOrAndAndAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAndAndAnd", + "FiltersAndAndOrOrAnd", + "FiltersAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndUnionMember0", + "FiltersAndAndOrOrAndAndOr", + "FiltersAndAndOrOrAndAndOrOr", + "FiltersAndAndOrOrAndAndOrOrUnionMember0", + "FiltersAndAndOrOrAndAndOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0", + "FiltersAndAndOrOrAndAndOrOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrAnd", + "FiltersAndAndOrOrAndAndOrOrOrOrAndAnd", + "FiltersAndAndOrOrAndAndOrOrAnd", + "FiltersAndAndOrOrAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0", + "FiltersAndAndOrOrAndAndOrOrAndAndOr", + "FiltersAndAndOrOrAndAndOrOrAndAndOrOr", + "FiltersAndAndOrOrAndAndOrOrAndAndAnd", + "FiltersAndAndOrOrAndAndOrOrAndAndAndAnd", + "FiltersAndAndOrOrAndAndAnd", + "FiltersAndAndOrOrAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndUnionMember0", + "FiltersAndAndOrOrAndAndAndAndOr", + "FiltersAndAndOrOrAndAndAndAndOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0", + "FiltersAndAndOrOrAndAndAndAndOrOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrAnd", + "FiltersAndAndOrOrAndAndAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0", + "FiltersAndAndOrOrAndAndAndAndAndAndOr", + "FiltersAndAndOrOrAndAndAndAndAndAndOrOr", + "FiltersAndAndOrOrAndAndAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAndAndAnd", + "FiltersAndAndAnd", + "FiltersAndAndAndAnd", + "FiltersAndAndAndAndUnionMember0", + "FiltersAndAndAndAndOr", + "FiltersAndAndAndAndOrOr", + "FiltersAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOr", + "FiltersAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrAnd", + "FiltersAndAndAndAndOrOrOrOrOrOrAndAnd", + "FiltersAndAndAndAndOrOrOrOrAnd", + "FiltersAndAndAndAndOrOrOrOrAndAnd", + "FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0", + "FiltersAndAndAndAndOrOrOrOrAndAndOr", + "FiltersAndAndAndAndOrOrOrOrAndAndOrOr", + "FiltersAndAndAndAndOrOrOrOrAndAndAnd", + "FiltersAndAndAndAndOrOrOrOrAndAndAndAnd", + "FiltersAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndOrOrAndAndUnionMember0", + "FiltersAndAndAndAndOrOrAndAndOr", + "FiltersAndAndAndAndOrOrAndAndOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0", + "FiltersAndAndAndAndOrOrAndAndOrOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrAnd", + "FiltersAndAndAndAndOrOrAndAndOrOrAndAnd", + "FiltersAndAndAndAndOrOrAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0", + "FiltersAndAndAndAndOrOrAndAndAndAndOr", + "FiltersAndAndAndAndOrOrAndAndAndAndOrOr", + "FiltersAndAndAndAndOrOrAndAndAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAndAndAnd", + "FiltersAndAndAndAndAnd", + "FiltersAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndAndAndOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0", + "FiltersAndAndAndAndAndAndOrOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrAnd", + "FiltersAndAndAndAndAndAndOrOrOrOrAndAnd", + "FiltersAndAndAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0", + "FiltersAndAndAndAndAndAndOrOrAndAndOr", + "FiltersAndAndAndAndAndAndOrOrAndAndOrOr", + "FiltersAndAndAndAndAndAndOrOrAndAndAnd", + "FiltersAndAndAndAndAndAndOrOrAndAndAndAnd", + "FiltersAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndAndAndAndAndOrOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAndAndAnd", +] class SearchDocumentsParams(TypedDict, total=False): @@ -82,16 +399,3482 @@ class SearchDocumentsParams(TypedDict, total=False): """ +class FiltersOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrOrOrAnd +] + + +class FiltersOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrAnd +] + + +class FiltersOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrOrOrAndAndOrOrAnd +] + + +class FiltersOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrOrOrAndAndAndAndAnd +] + + +class FiltersOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrAnd] + + +class FiltersOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOrOrOr, FiltersOrOrOrOrAndAndOrOrOrOrAnd +] + + +class FiltersOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOrOrAndAndOr, FiltersOrOrOrOrAndAndOrOrAndAndAnd +] + + +class FiltersOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrAndAndOrOrAnd +] + + +class FiltersOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndAndAndOrOrOr, FiltersOrOrOrOrAndAndAndAndOrOrAnd +] + + +class FiltersOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0, + FiltersOrOrOrOrAndAndAndAndAndAndOr, + FiltersOrOrOrOrAndAndAndAndAndAndAnd, +] + + +class FiltersOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrAndAndAndAndAnd +] + + +class FiltersOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOr, FiltersOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrUnionMember0, FiltersOrOrOrOrOr, FiltersOrOrOrOrAnd] + + +class FiltersOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrOrOrAnd +] + + +class FiltersOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrOrOrAndAndOr, FiltersOrOrAndAndOrOrOrOrAndAndAnd +] + + +class FiltersOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrAnd +] + + +class FiltersOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAndAndOrOrAnd +] + + +class FiltersOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0, + FiltersOrOrAndAndOrOrAndAndAndAndOr, + FiltersOrOrAndAndOrOrAndAndAndAndAnd, +] + + +class FiltersOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrAndAndOr, FiltersOrOrAndAndOrOrAndAndAnd +] + + +class FiltersOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAnd +] + + +class FiltersOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOrOrOr, FiltersOrOrAndAndAndAndOrOrOrOrAnd +] + + +class FiltersOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0, + FiltersOrOrAndAndAndAndOrOrAndAndOr, + FiltersOrOrAndAndAndAndOrOrAndAndAnd, +] + + +class FiltersOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOr, FiltersOrOrAndAndAndAndOrOrAnd +] + + +class FiltersOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0, + FiltersOrOrAndAndAndAndAndAndOrOrOr, + FiltersOrOrAndAndAndAndAndAndOrOrAnd, +] + + +class FiltersOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0, + FiltersOrOrAndAndAndAndAndAndAndAndOr, + FiltersOrOrAndAndAndAndAndAndAndAndAnd, +] + + +class FiltersOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndAndAndOr, FiltersOrOrAndAndAndAndAndAndAnd +] + + +class FiltersOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndOr, FiltersOrOrAndAndAndAndAnd +] + + +class FiltersOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAnd: TypeAlias = Union[FiltersOrOrAndAndUnionMember0, FiltersOrOrAndAndOr, FiltersOrOrAndAndAnd] + + +class FiltersOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd] + + class FiltersOr(TypedDict, total=False): - """OR""" + or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] + """Array of OR filter expressions""" + + +class FiltersAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrOrOrAndAndAnd +] + + +class FiltersAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrOrOrAndAndOrOrOr, FiltersAndAndOrOrOrOrAndAndOrOrAnd +] + + +class FiltersAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0, + FiltersAndAndOrOrOrOrAndAndAndAndOr, + FiltersAndAndOrOrOrOrAndAndAndAndAnd, +] + + +class FiltersAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrAndAndAnd +] + + +class FiltersAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOr, FiltersAndAndOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOrOrOr, FiltersAndAndOrOrAndAndOrOrOrOrAnd +] + + +class FiltersAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0, + FiltersAndAndOrOrAndAndOrOrAndAndOr, + FiltersAndAndOrOrAndAndOrOrAndAndAnd, +] + + +class FiltersAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOr, FiltersAndAndOrOrAndAndOrOrAnd +] + + +class FiltersAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0, + FiltersAndAndOrOrAndAndAndAndOrOrOr, + FiltersAndAndOrOrAndAndAndAndOrOrAnd, +] + + +class FiltersAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0, + FiltersAndAndOrOrAndAndAndAndAndAndOr, + FiltersAndAndOrOrAndAndAndAndAndAndAnd, +] + + +class FiltersAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndUnionMember0, FiltersAndAndOrOrAndAndAndAndOr, FiltersAndAndOrOrAndAndAndAndAnd +] + + +class FiltersAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndUnionMember0, FiltersAndAndOrOrAndAndOr, FiltersAndAndOrOrAndAndAnd +] + + +class FiltersAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOr: TypeAlias = Union[FiltersAndAndOrOrUnionMember0, FiltersAndAndOrOrOr, FiltersAndAndOrOrAnd] + + +class FiltersAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrOrOrAnd +] + + +class FiltersAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0, + FiltersAndAndAndAndOrOrOrOrAndAndOr, + FiltersAndAndAndAndOrOrOrOrAndAndAnd, +] + + +class FiltersAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrAnd +] + + +class FiltersAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] - or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] -class FiltersAnd(TypedDict, total=False): - """AND""" + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0, + FiltersAndAndAndAndOrOrAndAndOrOrOr, + FiltersAndAndAndAndOrOrAndAndOrOrAnd, +] + + +class FiltersAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0, + FiltersAndAndAndAndOrOrAndAndAndAndOr, + FiltersAndAndAndAndOrOrAndAndAndAndAnd, +] + + +class FiltersAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndUnionMember0, FiltersAndAndAndAndOrOrAndAndOr, FiltersAndAndAndAndOrOrAndAndAnd +] + + +class FiltersAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndOrOrOr, FiltersAndAndAndAndOrOrAnd +] + + +class FiltersAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0, + FiltersAndAndAndAndAndAndOrOrOrOrOr, + FiltersAndAndAndAndAndAndOrOrOrOrAnd, +] + + +class FiltersAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] - and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0, + FiltersAndAndAndAndAndAndOrOrAndAndOr, + FiltersAndAndAndAndAndAndOrOrAndAndAnd, +] + + +class FiltersAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndAndAndOrOrOr, FiltersAndAndAndAndAndAndOrOrAnd +] + + +class FiltersAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0, + FiltersAndAndAndAndAndAndAndAndOrOrOr, + FiltersAndAndAndAndAndAndAndAndOrOrAnd, +] + + +class FiltersAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0, + FiltersAndAndAndAndAndAndAndAndAndAndOr, + FiltersAndAndAndAndAndAndAndAndAndAndAnd, +] + + +class FiltersAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAndAndAnd +] + + +class FiltersAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAnd +] + + +class FiltersAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAnd: TypeAlias = Union[FiltersAndAndAndAndUnionMember0, FiltersAndAndAndAndOr, FiltersAndAndAndAndAnd] + + +class FiltersAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] + + +class FiltersAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] + """Array of AND filter expressions""" Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/src/supermemory/types/search_execute_params.py b/src/supermemory/types/search_execute_params.py index 0a1290a..56121a3 100644 --- a/src/supermemory/types/search_execute_params.py +++ b/src/supermemory/types/search_execute_params.py @@ -3,12 +3,329 @@ from __future__ import annotations from typing import Union, Iterable -from typing_extensions import Required, Annotated, TypeAlias, TypedDict +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -__all__ = ["SearchExecuteParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = [ + "SearchExecuteParams", + "Filters", + "FiltersOr", + "FiltersOrOr", + "FiltersOrOrUnionMember0", + "FiltersOrOrOr", + "FiltersOrOrOrOr", + "FiltersOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOr", + "FiltersOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrOrOrOrOrAndAndOr", + "FiltersOrOrOrOrOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrOrOrAndAndOr", + "FiltersOrOrOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0", + "FiltersOrOrOrOrOrOrAndAndOrOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrAnd", + "FiltersOrOrOrOrOrOrAndAndOrOrAndAnd", + "FiltersOrOrOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0", + "FiltersOrOrOrOrOrOrAndAndAndAndOr", + "FiltersOrOrOrOrOrOrAndAndAndAndOrOr", + "FiltersOrOrOrOrOrOrAndAndAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAndAndAnd", + "FiltersOrOrOrOrAnd", + "FiltersOrOrOrOrAndAnd", + "FiltersOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrAndAndOr", + "FiltersOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrAndAndOrOrUnionMember0", + "FiltersOrOrOrOrAndAndOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0", + "FiltersOrOrOrOrAndAndOrOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrAnd", + "FiltersOrOrOrOrAndAndOrOrOrOrAndAnd", + "FiltersOrOrOrOrAndAndOrOrAnd", + "FiltersOrOrOrOrAndAndOrOrAndAnd", + "FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0", + "FiltersOrOrOrOrAndAndOrOrAndAndOr", + "FiltersOrOrOrOrAndAndOrOrAndAndOrOr", + "FiltersOrOrOrOrAndAndOrOrAndAndAnd", + "FiltersOrOrOrOrAndAndOrOrAndAndAndAnd", + "FiltersOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndUnionMember0", + "FiltersOrOrOrOrAndAndAndAndOr", + "FiltersOrOrOrOrAndAndAndAndOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0", + "FiltersOrOrOrOrAndAndAndAndOrOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrAnd", + "FiltersOrOrOrOrAndAndAndAndOrOrAndAnd", + "FiltersOrOrOrOrAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0", + "FiltersOrOrOrOrAndAndAndAndAndAndOr", + "FiltersOrOrOrOrAndAndAndAndAndAndOrOr", + "FiltersOrOrOrOrAndAndAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAndAndAnd", + "FiltersOrOrAnd", + "FiltersOrOrAndAnd", + "FiltersOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOr", + "FiltersOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOr", + "FiltersOrOrAndAndOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrAnd", + "FiltersOrOrAndAndOrOrOrOrOrOrAndAnd", + "FiltersOrOrAndAndOrOrOrOrAnd", + "FiltersOrOrAndAndOrOrOrOrAndAnd", + "FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOrOrOrOrAndAndOr", + "FiltersOrOrAndAndOrOrOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrOrOrAndAndAnd", + "FiltersOrOrAndAndOrOrOrOrAndAndAndAnd", + "FiltersOrOrAndAndOrOrAnd", + "FiltersOrOrAndAndOrOrAndAnd", + "FiltersOrOrAndAndOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOrOrAndAndOr", + "FiltersOrOrAndAndOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0", + "FiltersOrOrAndAndOrOrAndAndOrOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrAnd", + "FiltersOrOrAndAndOrOrAndAndOrOrAndAnd", + "FiltersOrOrAndAndOrOrAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0", + "FiltersOrOrAndAndOrOrAndAndAndAndOr", + "FiltersOrOrAndAndOrOrAndAndAndAndOrOr", + "FiltersOrOrAndAndOrOrAndAndAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAndAndAnd", + "FiltersOrOrAndAndAnd", + "FiltersOrOrAndAndAndAnd", + "FiltersOrOrAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndOr", + "FiltersOrOrAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndOrOrUnionMember0", + "FiltersOrOrAndAndAndAndOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0", + "FiltersOrOrAndAndAndAndOrOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrAnd", + "FiltersOrOrAndAndAndAndOrOrOrOrAndAnd", + "FiltersOrOrAndAndAndAndOrOrAnd", + "FiltersOrOrAndAndAndAndOrOrAndAnd", + "FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0", + "FiltersOrOrAndAndAndAndOrOrAndAndOr", + "FiltersOrOrAndAndAndAndOrOrAndAndOrOr", + "FiltersOrOrAndAndAndAndOrOrAndAndAnd", + "FiltersOrOrAndAndAndAndOrOrAndAndAndAnd", + "FiltersOrOrAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndAndAndOr", + "FiltersOrOrAndAndAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0", + "FiltersOrOrAndAndAndAndAndAndOrOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrAnd", + "FiltersOrOrAndAndAndAndAndAndOrOrAndAnd", + "FiltersOrOrAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndAndAndAndAndOr", + "FiltersOrOrAndAndAndAndAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAndAndAnd", + "FiltersAnd", + "FiltersAndAnd", + "FiltersAndAndUnionMember0", + "FiltersAndAndOr", + "FiltersAndAndOrOr", + "FiltersAndAndOrOrUnionMember0", + "FiltersAndAndOrOrOr", + "FiltersAndAndOrOrOrOr", + "FiltersAndAndOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0", + "FiltersAndAndOrOrOrOrOrOrAndAndOr", + "FiltersAndAndOrOrOrOrOrOrAndAndOrOr", + "FiltersAndAndOrOrOrOrOrOrAndAndAnd", + "FiltersAndAndOrOrOrOrOrOrAndAndAndAnd", + "FiltersAndAndOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrAndAndUnionMember0", + "FiltersAndAndOrOrOrOrAndAndOr", + "FiltersAndAndOrOrOrOrAndAndOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0", + "FiltersAndAndOrOrOrOrAndAndOrOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrAnd", + "FiltersAndAndOrOrOrOrAndAndOrOrAndAnd", + "FiltersAndAndOrOrOrOrAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0", + "FiltersAndAndOrOrOrOrAndAndAndAndOr", + "FiltersAndAndOrOrOrOrAndAndAndAndOrOr", + "FiltersAndAndOrOrOrOrAndAndAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAndAndAnd", + "FiltersAndAndOrOrAnd", + "FiltersAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndUnionMember0", + "FiltersAndAndOrOrAndAndOr", + "FiltersAndAndOrOrAndAndOrOr", + "FiltersAndAndOrOrAndAndOrOrUnionMember0", + "FiltersAndAndOrOrAndAndOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0", + "FiltersAndAndOrOrAndAndOrOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrAnd", + "FiltersAndAndOrOrAndAndOrOrOrOrAndAnd", + "FiltersAndAndOrOrAndAndOrOrAnd", + "FiltersAndAndOrOrAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0", + "FiltersAndAndOrOrAndAndOrOrAndAndOr", + "FiltersAndAndOrOrAndAndOrOrAndAndOrOr", + "FiltersAndAndOrOrAndAndOrOrAndAndAnd", + "FiltersAndAndOrOrAndAndOrOrAndAndAndAnd", + "FiltersAndAndOrOrAndAndAnd", + "FiltersAndAndOrOrAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndUnionMember0", + "FiltersAndAndOrOrAndAndAndAndOr", + "FiltersAndAndOrOrAndAndAndAndOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0", + "FiltersAndAndOrOrAndAndAndAndOrOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrAnd", + "FiltersAndAndOrOrAndAndAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0", + "FiltersAndAndOrOrAndAndAndAndAndAndOr", + "FiltersAndAndOrOrAndAndAndAndAndAndOrOr", + "FiltersAndAndOrOrAndAndAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAndAndAnd", + "FiltersAndAndAnd", + "FiltersAndAndAndAnd", + "FiltersAndAndAndAndUnionMember0", + "FiltersAndAndAndAndOr", + "FiltersAndAndAndAndOrOr", + "FiltersAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOr", + "FiltersAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrAnd", + "FiltersAndAndAndAndOrOrOrOrOrOrAndAnd", + "FiltersAndAndAndAndOrOrOrOrAnd", + "FiltersAndAndAndAndOrOrOrOrAndAnd", + "FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0", + "FiltersAndAndAndAndOrOrOrOrAndAndOr", + "FiltersAndAndAndAndOrOrOrOrAndAndOrOr", + "FiltersAndAndAndAndOrOrOrOrAndAndAnd", + "FiltersAndAndAndAndOrOrOrOrAndAndAndAnd", + "FiltersAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndOrOrAndAndUnionMember0", + "FiltersAndAndAndAndOrOrAndAndOr", + "FiltersAndAndAndAndOrOrAndAndOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0", + "FiltersAndAndAndAndOrOrAndAndOrOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrAnd", + "FiltersAndAndAndAndOrOrAndAndOrOrAndAnd", + "FiltersAndAndAndAndOrOrAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0", + "FiltersAndAndAndAndOrOrAndAndAndAndOr", + "FiltersAndAndAndAndOrOrAndAndAndAndOrOr", + "FiltersAndAndAndAndOrOrAndAndAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAndAndAnd", + "FiltersAndAndAndAndAnd", + "FiltersAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndAndAndOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0", + "FiltersAndAndAndAndAndAndOrOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrAnd", + "FiltersAndAndAndAndAndAndOrOrOrOrAndAnd", + "FiltersAndAndAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0", + "FiltersAndAndAndAndAndAndOrOrAndAndOr", + "FiltersAndAndAndAndAndAndOrOrAndAndOrOr", + "FiltersAndAndAndAndAndAndOrOrAndAndAnd", + "FiltersAndAndAndAndAndAndOrOrAndAndAndAnd", + "FiltersAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndAndAndAndAndOrOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAndAndAnd", +] class SearchExecuteParams(TypedDict, total=False): @@ -82,16 +399,3482 @@ class SearchExecuteParams(TypedDict, total=False): """ +class FiltersOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrOrOrAnd +] + + +class FiltersOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrAnd +] + + +class FiltersOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrOrOrAndAndOrOrAnd +] + + +class FiltersOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrOrOrAndAndAndAndAnd +] + + +class FiltersOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrAnd] + + +class FiltersOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOrOrOr, FiltersOrOrOrOrAndAndOrOrOrOrAnd +] + + +class FiltersOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOrOrAndAndOr, FiltersOrOrOrOrAndAndOrOrAndAndAnd +] + + +class FiltersOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrAndAndOrOrAnd +] + + +class FiltersOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndAndAndOrOrOr, FiltersOrOrOrOrAndAndAndAndOrOrAnd +] + + +class FiltersOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0, + FiltersOrOrOrOrAndAndAndAndAndAndOr, + FiltersOrOrOrOrAndAndAndAndAndAndAnd, +] + + +class FiltersOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrAndAndAndAndAnd +] + + +class FiltersOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOr, FiltersOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrUnionMember0, FiltersOrOrOrOrOr, FiltersOrOrOrOrAnd] + + +class FiltersOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrOrOrAnd +] + + +class FiltersOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrOrOrAndAndOr, FiltersOrOrAndAndOrOrOrOrAndAndAnd +] + + +class FiltersOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrAnd +] + + +class FiltersOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAndAndOrOrAnd +] + + +class FiltersOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0, + FiltersOrOrAndAndOrOrAndAndAndAndOr, + FiltersOrOrAndAndOrOrAndAndAndAndAnd, +] + + +class FiltersOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrAndAndOr, FiltersOrOrAndAndOrOrAndAndAnd +] + + +class FiltersOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAnd +] + + +class FiltersOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOrOrOr, FiltersOrOrAndAndAndAndOrOrOrOrAnd +] + + +class FiltersOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0, + FiltersOrOrAndAndAndAndOrOrAndAndOr, + FiltersOrOrAndAndAndAndOrOrAndAndAnd, +] + + +class FiltersOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOr, FiltersOrOrAndAndAndAndOrOrAnd +] + + +class FiltersOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0, + FiltersOrOrAndAndAndAndAndAndOrOrOr, + FiltersOrOrAndAndAndAndAndAndOrOrAnd, +] + + +class FiltersOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0, + FiltersOrOrAndAndAndAndAndAndAndAndOr, + FiltersOrOrAndAndAndAndAndAndAndAndAnd, +] + + +class FiltersOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndAndAndOr, FiltersOrOrAndAndAndAndAndAndAnd +] + + +class FiltersOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndOr, FiltersOrOrAndAndAndAndAnd +] + + +class FiltersOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAnd: TypeAlias = Union[FiltersOrOrAndAndUnionMember0, FiltersOrOrAndAndOr, FiltersOrOrAndAndAnd] + + +class FiltersOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd] + + class FiltersOr(TypedDict, total=False): - """OR""" + or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] + """Array of OR filter expressions""" + + +class FiltersAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrOrOrAndAndAnd +] + + +class FiltersAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrOrOrAndAndOrOrOr, FiltersAndAndOrOrOrOrAndAndOrOrAnd +] + + +class FiltersAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0, + FiltersAndAndOrOrOrOrAndAndAndAndOr, + FiltersAndAndOrOrOrOrAndAndAndAndAnd, +] + + +class FiltersAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrAndAndAnd +] + + +class FiltersAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOr, FiltersAndAndOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOrOrOr, FiltersAndAndOrOrAndAndOrOrOrOrAnd +] + + +class FiltersAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0, + FiltersAndAndOrOrAndAndOrOrAndAndOr, + FiltersAndAndOrOrAndAndOrOrAndAndAnd, +] + + +class FiltersAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOr, FiltersAndAndOrOrAndAndOrOrAnd +] + + +class FiltersAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0, + FiltersAndAndOrOrAndAndAndAndOrOrOr, + FiltersAndAndOrOrAndAndAndAndOrOrAnd, +] + + +class FiltersAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0, + FiltersAndAndOrOrAndAndAndAndAndAndOr, + FiltersAndAndOrOrAndAndAndAndAndAndAnd, +] + + +class FiltersAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndUnionMember0, FiltersAndAndOrOrAndAndAndAndOr, FiltersAndAndOrOrAndAndAndAndAnd +] + + +class FiltersAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndUnionMember0, FiltersAndAndOrOrAndAndOr, FiltersAndAndOrOrAndAndAnd +] + + +class FiltersAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOr: TypeAlias = Union[FiltersAndAndOrOrUnionMember0, FiltersAndAndOrOrOr, FiltersAndAndOrOrAnd] + + +class FiltersAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrOrOrAnd +] + + +class FiltersAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0, + FiltersAndAndAndAndOrOrOrOrAndAndOr, + FiltersAndAndAndAndOrOrOrOrAndAndAnd, +] + + +class FiltersAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrAnd +] + + +class FiltersAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] - or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] -class FiltersAnd(TypedDict, total=False): - """AND""" + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0, + FiltersAndAndAndAndOrOrAndAndOrOrOr, + FiltersAndAndAndAndOrOrAndAndOrOrAnd, +] + + +class FiltersAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0, + FiltersAndAndAndAndOrOrAndAndAndAndOr, + FiltersAndAndAndAndOrOrAndAndAndAndAnd, +] + + +class FiltersAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndUnionMember0, FiltersAndAndAndAndOrOrAndAndOr, FiltersAndAndAndAndOrOrAndAndAnd +] + + +class FiltersAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndOrOrOr, FiltersAndAndAndAndOrOrAnd +] + + +class FiltersAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0, + FiltersAndAndAndAndAndAndOrOrOrOrOr, + FiltersAndAndAndAndAndAndOrOrOrOrAnd, +] + + +class FiltersAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] - and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0, + FiltersAndAndAndAndAndAndOrOrAndAndOr, + FiltersAndAndAndAndAndAndOrOrAndAndAnd, +] + + +class FiltersAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndAndAndOrOrOr, FiltersAndAndAndAndAndAndOrOrAnd +] + + +class FiltersAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0, + FiltersAndAndAndAndAndAndAndAndOrOrOr, + FiltersAndAndAndAndAndAndAndAndOrOrAnd, +] + + +class FiltersAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0, + FiltersAndAndAndAndAndAndAndAndAndAndOr, + FiltersAndAndAndAndAndAndAndAndAndAndAnd, +] + + +class FiltersAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAndAndAnd +] + + +class FiltersAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAnd +] + + +class FiltersAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAnd: TypeAlias = Union[FiltersAndAndAndAndUnionMember0, FiltersAndAndAndAndOr, FiltersAndAndAndAndAnd] + + +class FiltersAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] + + +class FiltersAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] + """Array of AND filter expressions""" Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/src/supermemory/types/search_memories_params.py b/src/supermemory/types/search_memories_params.py index 1d5320b..e5bb7ba 100644 --- a/src/supermemory/types/search_memories_params.py +++ b/src/supermemory/types/search_memories_params.py @@ -3,11 +3,329 @@ from __future__ import annotations from typing import Union, Iterable -from typing_extensions import Required, Annotated, TypeAlias, TypedDict +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._utils import PropertyInfo -__all__ = ["SearchMemoriesParams", "Filters", "FiltersOr", "FiltersAnd", "Include"] +__all__ = [ + "SearchMemoriesParams", + "Filters", + "FiltersOr", + "FiltersOrOr", + "FiltersOrOrUnionMember0", + "FiltersOrOrOr", + "FiltersOrOrOrOr", + "FiltersOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOr", + "FiltersOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0", + "FiltersOrOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrOrOr", + "FiltersOrOrOrOrOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrOrOrOrOrAndAndOr", + "FiltersOrOrOrOrOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrOrOrAnd", + "FiltersOrOrOrOrOrOrAndAnd", + "FiltersOrOrOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrOrOrAndAndOr", + "FiltersOrOrOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0", + "FiltersOrOrOrOrOrOrAndAndOrOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrOrOr", + "FiltersOrOrOrOrOrOrAndAndOrOrAnd", + "FiltersOrOrOrOrOrOrAndAndOrOrAndAnd", + "FiltersOrOrOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0", + "FiltersOrOrOrOrOrOrAndAndAndAndOr", + "FiltersOrOrOrOrOrOrAndAndAndAndOrOr", + "FiltersOrOrOrOrOrOrAndAndAndAndAnd", + "FiltersOrOrOrOrOrOrAndAndAndAndAndAnd", + "FiltersOrOrOrOrAnd", + "FiltersOrOrOrOrAndAnd", + "FiltersOrOrOrOrAndAndUnionMember0", + "FiltersOrOrOrOrAndAndOr", + "FiltersOrOrOrOrAndAndOrOr", + "FiltersOrOrOrOrAndAndOrOrUnionMember0", + "FiltersOrOrOrOrAndAndOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0", + "FiltersOrOrOrOrAndAndOrOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrOrOr", + "FiltersOrOrOrOrAndAndOrOrOrOrAnd", + "FiltersOrOrOrOrAndAndOrOrOrOrAndAnd", + "FiltersOrOrOrOrAndAndOrOrAnd", + "FiltersOrOrOrOrAndAndOrOrAndAnd", + "FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0", + "FiltersOrOrOrOrAndAndOrOrAndAndOr", + "FiltersOrOrOrOrAndAndOrOrAndAndOrOr", + "FiltersOrOrOrOrAndAndOrOrAndAndAnd", + "FiltersOrOrOrOrAndAndOrOrAndAndAndAnd", + "FiltersOrOrOrOrAndAndAnd", + "FiltersOrOrOrOrAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndUnionMember0", + "FiltersOrOrOrOrAndAndAndAndOr", + "FiltersOrOrOrOrAndAndAndAndOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0", + "FiltersOrOrOrOrAndAndAndAndOrOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrOrOr", + "FiltersOrOrOrOrAndAndAndAndOrOrAnd", + "FiltersOrOrOrOrAndAndAndAndOrOrAndAnd", + "FiltersOrOrOrOrAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0", + "FiltersOrOrOrOrAndAndAndAndAndAndOr", + "FiltersOrOrOrOrAndAndAndAndAndAndOrOr", + "FiltersOrOrOrOrAndAndAndAndAndAndAnd", + "FiltersOrOrOrOrAndAndAndAndAndAndAndAnd", + "FiltersOrOrAnd", + "FiltersOrOrAndAnd", + "FiltersOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOr", + "FiltersOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOr", + "FiltersOrOrAndAndOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0", + "FiltersOrOrAndAndOrOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrOrOr", + "FiltersOrOrAndAndOrOrOrOrOrOrAnd", + "FiltersOrOrAndAndOrOrOrOrOrOrAndAnd", + "FiltersOrOrAndAndOrOrOrOrAnd", + "FiltersOrOrAndAndOrOrOrOrAndAnd", + "FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOrOrOrOrAndAndOr", + "FiltersOrOrAndAndOrOrOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrOrOrAndAndAnd", + "FiltersOrOrAndAndOrOrOrOrAndAndAndAnd", + "FiltersOrOrAndAndOrOrAnd", + "FiltersOrOrAndAndOrOrAndAnd", + "FiltersOrOrAndAndOrOrAndAndUnionMember0", + "FiltersOrOrAndAndOrOrAndAndOr", + "FiltersOrOrAndAndOrOrAndAndOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0", + "FiltersOrOrAndAndOrOrAndAndOrOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrOrOr", + "FiltersOrOrAndAndOrOrAndAndOrOrAnd", + "FiltersOrOrAndAndOrOrAndAndOrOrAndAnd", + "FiltersOrOrAndAndOrOrAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0", + "FiltersOrOrAndAndOrOrAndAndAndAndOr", + "FiltersOrOrAndAndOrOrAndAndAndAndOrOr", + "FiltersOrOrAndAndOrOrAndAndAndAndAnd", + "FiltersOrOrAndAndOrOrAndAndAndAndAndAnd", + "FiltersOrOrAndAndAnd", + "FiltersOrOrAndAndAndAnd", + "FiltersOrOrAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndOr", + "FiltersOrOrAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndOrOrUnionMember0", + "FiltersOrOrAndAndAndAndOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0", + "FiltersOrOrAndAndAndAndOrOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrOrOr", + "FiltersOrOrAndAndAndAndOrOrOrOrAnd", + "FiltersOrOrAndAndAndAndOrOrOrOrAndAnd", + "FiltersOrOrAndAndAndAndOrOrAnd", + "FiltersOrOrAndAndAndAndOrOrAndAnd", + "FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0", + "FiltersOrOrAndAndAndAndOrOrAndAndOr", + "FiltersOrOrAndAndAndAndOrOrAndAndOrOr", + "FiltersOrOrAndAndAndAndOrOrAndAndAnd", + "FiltersOrOrAndAndAndAndOrOrAndAndAndAnd", + "FiltersOrOrAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndAndAndOr", + "FiltersOrOrAndAndAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0", + "FiltersOrOrAndAndAndAndAndAndOrOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrOrOr", + "FiltersOrOrAndAndAndAndAndAndOrOrAnd", + "FiltersOrOrAndAndAndAndAndAndOrOrAndAnd", + "FiltersOrOrAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0", + "FiltersOrOrAndAndAndAndAndAndAndAndOr", + "FiltersOrOrAndAndAndAndAndAndAndAndOrOr", + "FiltersOrOrAndAndAndAndAndAndAndAndAnd", + "FiltersOrOrAndAndAndAndAndAndAndAndAndAnd", + "FiltersAnd", + "FiltersAndAnd", + "FiltersAndAndUnionMember0", + "FiltersAndAndOr", + "FiltersAndAndOrOr", + "FiltersAndAndOrOrUnionMember0", + "FiltersAndAndOrOrOr", + "FiltersAndAndOrOrOrOr", + "FiltersAndAndOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0", + "FiltersAndAndOrOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrOrOr", + "FiltersAndAndOrOrOrOrOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0", + "FiltersAndAndOrOrOrOrOrOrAndAndOr", + "FiltersAndAndOrOrOrOrOrOrAndAndOrOr", + "FiltersAndAndOrOrOrOrOrOrAndAndAnd", + "FiltersAndAndOrOrOrOrOrOrAndAndAndAnd", + "FiltersAndAndOrOrOrOrAnd", + "FiltersAndAndOrOrOrOrAndAnd", + "FiltersAndAndOrOrOrOrAndAndUnionMember0", + "FiltersAndAndOrOrOrOrAndAndOr", + "FiltersAndAndOrOrOrOrAndAndOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0", + "FiltersAndAndOrOrOrOrAndAndOrOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrOrOr", + "FiltersAndAndOrOrOrOrAndAndOrOrAnd", + "FiltersAndAndOrOrOrOrAndAndOrOrAndAnd", + "FiltersAndAndOrOrOrOrAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0", + "FiltersAndAndOrOrOrOrAndAndAndAndOr", + "FiltersAndAndOrOrOrOrAndAndAndAndOrOr", + "FiltersAndAndOrOrOrOrAndAndAndAndAnd", + "FiltersAndAndOrOrOrOrAndAndAndAndAndAnd", + "FiltersAndAndOrOrAnd", + "FiltersAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndUnionMember0", + "FiltersAndAndOrOrAndAndOr", + "FiltersAndAndOrOrAndAndOrOr", + "FiltersAndAndOrOrAndAndOrOrUnionMember0", + "FiltersAndAndOrOrAndAndOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0", + "FiltersAndAndOrOrAndAndOrOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrOrOr", + "FiltersAndAndOrOrAndAndOrOrOrOrAnd", + "FiltersAndAndOrOrAndAndOrOrOrOrAndAnd", + "FiltersAndAndOrOrAndAndOrOrAnd", + "FiltersAndAndOrOrAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0", + "FiltersAndAndOrOrAndAndOrOrAndAndOr", + "FiltersAndAndOrOrAndAndOrOrAndAndOrOr", + "FiltersAndAndOrOrAndAndOrOrAndAndAnd", + "FiltersAndAndOrOrAndAndOrOrAndAndAndAnd", + "FiltersAndAndOrOrAndAndAnd", + "FiltersAndAndOrOrAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndUnionMember0", + "FiltersAndAndOrOrAndAndAndAndOr", + "FiltersAndAndOrOrAndAndAndAndOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0", + "FiltersAndAndOrOrAndAndAndAndOrOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrOrOr", + "FiltersAndAndOrOrAndAndAndAndOrOrAnd", + "FiltersAndAndOrOrAndAndAndAndOrOrAndAnd", + "FiltersAndAndOrOrAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0", + "FiltersAndAndOrOrAndAndAndAndAndAndOr", + "FiltersAndAndOrOrAndAndAndAndAndAndOrOr", + "FiltersAndAndOrOrAndAndAndAndAndAndAnd", + "FiltersAndAndOrOrAndAndAndAndAndAndAndAnd", + "FiltersAndAndAnd", + "FiltersAndAndAndAnd", + "FiltersAndAndAndAndUnionMember0", + "FiltersAndAndAndAndOr", + "FiltersAndAndAndAndOrOr", + "FiltersAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOr", + "FiltersAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0", + "FiltersAndAndAndAndOrOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrOrOr", + "FiltersAndAndAndAndOrOrOrOrOrOrAnd", + "FiltersAndAndAndAndOrOrOrOrOrOrAndAnd", + "FiltersAndAndAndAndOrOrOrOrAnd", + "FiltersAndAndAndAndOrOrOrOrAndAnd", + "FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0", + "FiltersAndAndAndAndOrOrOrOrAndAndOr", + "FiltersAndAndAndAndOrOrOrOrAndAndOrOr", + "FiltersAndAndAndAndOrOrOrOrAndAndAnd", + "FiltersAndAndAndAndOrOrOrOrAndAndAndAnd", + "FiltersAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndOrOrAndAndUnionMember0", + "FiltersAndAndAndAndOrOrAndAndOr", + "FiltersAndAndAndAndOrOrAndAndOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0", + "FiltersAndAndAndAndOrOrAndAndOrOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrOrOr", + "FiltersAndAndAndAndOrOrAndAndOrOrAnd", + "FiltersAndAndAndAndOrOrAndAndOrOrAndAnd", + "FiltersAndAndAndAndOrOrAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0", + "FiltersAndAndAndAndOrOrAndAndAndAndOr", + "FiltersAndAndAndAndOrOrAndAndAndAndOrOr", + "FiltersAndAndAndAndOrOrAndAndAndAndAnd", + "FiltersAndAndAndAndOrOrAndAndAndAndAndAnd", + "FiltersAndAndAndAndAnd", + "FiltersAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndAndAndOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0", + "FiltersAndAndAndAndAndAndOrOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrOrOr", + "FiltersAndAndAndAndAndAndOrOrOrOrAnd", + "FiltersAndAndAndAndAndAndOrOrOrOrAndAnd", + "FiltersAndAndAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0", + "FiltersAndAndAndAndAndAndOrOrAndAndOr", + "FiltersAndAndAndAndAndAndOrOrAndAndOrOr", + "FiltersAndAndAndAndAndAndOrOrAndAndAnd", + "FiltersAndAndAndAndAndAndOrOrAndAndAndAnd", + "FiltersAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0", + "FiltersAndAndAndAndAndAndAndAndOrOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrOrOr", + "FiltersAndAndAndAndAndAndAndAndOrOrAnd", + "FiltersAndAndAndAndAndAndAndAndOrOrAndAnd", + "FiltersAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0", + "FiltersAndAndAndAndAndAndAndAndAndAndOr", + "FiltersAndAndAndAndAndAndAndAndAndAndOrOr", + "FiltersAndAndAndAndAndAndAndAndAndAndAnd", + "FiltersAndAndAndAndAndAndAndAndAndAndAndAnd", + "Include", +] class SearchMemoriesParams(TypedDict, total=False): @@ -49,16 +367,3482 @@ class SearchMemoriesParams(TypedDict, total=False): """ +class FiltersOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrOrOrAnd +] + + +class FiltersOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrAnd +] + + +class FiltersOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrOrOrAndAndOrOrAnd +] + + +class FiltersOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrOrOrAndAndAndAndAnd +] + + +class FiltersOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrAnd] + + +class FiltersOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOrOrOr, FiltersOrOrOrOrAndAndOrOrOrOrAnd +] + + +class FiltersOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOrOrAndAndOr, FiltersOrOrOrOrAndAndOrOrAndAndAnd +] + + +class FiltersOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrAndAndOrOrAnd +] + + +class FiltersOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndAndAndOrOrOr, FiltersOrOrOrOrAndAndAndAndOrOrAnd +] + + +class FiltersOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0, + FiltersOrOrOrOrAndAndAndAndAndAndOr, + FiltersOrOrOrOrAndAndAndAndAndAndAnd, +] + + +class FiltersOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrAndAndAndAndAnd +] + + +class FiltersOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOr, FiltersOrOrOrOrAndAndAnd +] + + +class FiltersOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrUnionMember0, FiltersOrOrOrOrOr, FiltersOrOrOrOrAnd] + + +class FiltersOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrOrOrAnd +] + + +class FiltersOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrOrOrAndAndOr, FiltersOrOrAndAndOrOrOrOrAndAndAnd +] + + +class FiltersOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrAnd +] + + +class FiltersOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAndAndOrOrAnd +] + + +class FiltersOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0, + FiltersOrOrAndAndOrOrAndAndAndAndOr, + FiltersOrOrAndAndOrOrAndAndAndAndAnd, +] + + +class FiltersOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrAndAndOr, FiltersOrOrAndAndOrOrAndAndAnd +] + + +class FiltersOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAnd +] + + +class FiltersOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOrOrOr, FiltersOrOrAndAndAndAndOrOrOrOrAnd +] + + +class FiltersOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0, + FiltersOrOrAndAndAndAndOrOrAndAndOr, + FiltersOrOrAndAndAndAndOrOrAndAndAnd, +] + + +class FiltersOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOr, FiltersOrOrAndAndAndAndOrOrAnd +] + + +class FiltersOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0, + FiltersOrOrAndAndAndAndAndAndOrOrOr, + FiltersOrOrAndAndAndAndAndAndOrOrAnd, +] + + +class FiltersOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersOrOrAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersOrOrAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersOrOrAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0, + FiltersOrOrAndAndAndAndAndAndAndAndOr, + FiltersOrOrAndAndAndAndAndAndAndAndAnd, +] + + +class FiltersOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndAndAndOr, FiltersOrOrAndAndAndAndAndAndAnd +] + + +class FiltersOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersOrOrAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndOr, FiltersOrOrAndAndAndAndAnd +] + + +class FiltersOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOrAndAnd: TypeAlias = Union[FiltersOrOrAndAndUnionMember0, FiltersOrOrAndAndOr, FiltersOrOrAndAndAnd] + + +class FiltersOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd] + + class FiltersOr(TypedDict, total=False): - """OR""" + or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] + """Array of OR filter expressions""" + + +class FiltersAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrOrOrAndAndAnd +] + + +class FiltersAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrOrOrAndAndOrOrOr, FiltersAndAndOrOrOrOrAndAndOrOrAnd +] + + +class FiltersAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0, + FiltersAndAndOrOrOrOrAndAndAndAndOr, + FiltersAndAndOrOrOrOrAndAndAndAndAnd, +] + + +class FiltersAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrAndAndAnd +] + + +class FiltersAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOr, FiltersAndAndOrOrOrOrAnd +] + + +class FiltersAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOrOrOr, FiltersAndAndOrOrAndAndOrOrOrOrAnd +] + + +class FiltersAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0, + FiltersAndAndOrOrAndAndOrOrAndAndOr, + FiltersAndAndOrOrAndAndOrOrAndAndAnd, +] + + +class FiltersAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOr, FiltersAndAndOrOrAndAndOrOrAnd +] + + +class FiltersAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0, + FiltersAndAndOrOrAndAndAndAndOrOrOr, + FiltersAndAndOrOrAndAndAndAndOrOrAnd, +] + + +class FiltersAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndOrOrAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0, + FiltersAndAndOrOrAndAndAndAndAndAndOr, + FiltersAndAndOrOrAndAndAndAndAndAndAnd, +] + + +class FiltersAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndAndAndUnionMember0, FiltersAndAndOrOrAndAndAndAndOr, FiltersAndAndOrOrAndAndAndAndAnd +] + + +class FiltersAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndOrOrAndAndUnionMember0, FiltersAndAndOrOrAndAndOr, FiltersAndAndOrOrAndAndAnd +] + + +class FiltersAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndOrOr: TypeAlias = Union[FiltersAndAndOrOrUnionMember0, FiltersAndAndOrOrOr, FiltersAndAndOrOrAnd] + + +class FiltersAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrOrOrAnd +] + + +class FiltersAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0, + FiltersAndAndAndAndOrOrOrOrAndAndOr, + FiltersAndAndAndAndOrOrOrOrAndAndAnd, +] + + +class FiltersAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrAnd +] + + +class FiltersAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] - or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] -class FiltersAnd(TypedDict, total=False): - """AND""" + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0, + FiltersAndAndAndAndOrOrAndAndOrOrOr, + FiltersAndAndAndAndOrOrAndAndOrOrAnd, +] + + +class FiltersAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndOrOrAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0, + FiltersAndAndAndAndOrOrAndAndAndAndOr, + FiltersAndAndAndAndOrOrAndAndAndAndAnd, +] + + +class FiltersAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndOrOrAndAndUnionMember0, FiltersAndAndAndAndOrOrAndAndOr, FiltersAndAndAndAndOrOrAndAndAnd +] + + +class FiltersAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndOrOrOr, FiltersAndAndAndAndOrOrAnd +] + + +class FiltersAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndOrOrOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0, + FiltersAndAndAndAndAndAndOrOrOrOrOr, + FiltersAndAndAndAndAndAndOrOrOrOrAnd, +] + + +class FiltersAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] - and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndOrOrAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0, + FiltersAndAndAndAndAndAndOrOrAndAndOr, + FiltersAndAndAndAndAndAndOrOrAndAndAnd, +] + + +class FiltersAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndAndAndOrOrOr, FiltersAndAndAndAndAndAndOrOrAnd +] + + +class FiltersAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndAndAndOrOr: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0, + FiltersAndAndAndAndAndAndAndAndOrOrOr, + FiltersAndAndAndAndAndAndAndAndOrOrAnd, +] + + +class FiltersAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions or nested expressions""" + + +class FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] + """OR: Array of conditions""" + + +class FiltersAndAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + """ + A single filter condition based on metadata, numeric values, array contents, or string matching + """ + + key: Required[str] + + value: Required[str] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + negate: Union[bool, Literal["true", "false"]] + + numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] + + +class FiltersAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions""" + + +FiltersAndAndAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0, + FiltersAndAndAndAndAndAndAndAndAndAndOr, + FiltersAndAndAndAndAndAndAndAndAndAndAnd, +] + + +class FiltersAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAndAndAnd +] + + +class FiltersAndAndAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAndAndAnd: TypeAlias = Union[ + FiltersAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAnd +] + + +class FiltersAndAndAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAndAndAnd: TypeAlias = Union[FiltersAndAndAndAndUnionMember0, FiltersAndAndAndAndOr, FiltersAndAndAndAndAnd] + + +class FiltersAndAndAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAndAndAnd], PropertyInfo(alias="AND")]] + """AND: Array of conditions or nested expressions""" + + +FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] + + +class FiltersAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] + """Array of AND filter expressions""" Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/src/supermemory/types/search_response.py b/src/supermemory/types/search_response.py deleted file mode 100644 index 7637939..0000000 --- a/src/supermemory/types/search_response.py +++ /dev/null @@ -1,143 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Dict, List, Optional -from typing_extensions import Literal - -from pydantic import Field as FieldInfo - -from .._models import BaseModel - -__all__ = [ - "SearchResponse", - "Result", - "ResultChunk", - "ResultContext", - "ResultContextChild", - "ResultContextParent", - "ResultDocument", -] - - -class ResultChunk(BaseModel): - content: str - """Content of the chunk""" - - document_id: str = FieldInfo(alias="documentId") - """ID of the document this chunk belongs to""" - - position: float - """Position of chunk in the document (0-indexed)""" - - score: float - """Similarity score between the query and chunk""" - - -class ResultContextChild(BaseModel): - memory: str - """The contextual memory content""" - - relation: Literal["updates", "extends", "derives"] - """Relation type between this memory and its parent/child""" - - updated_at: str = FieldInfo(alias="updatedAt") - """Contextual memory last update date""" - - metadata: Optional[Dict[str, object]] = None - """Contextual memory metadata""" - - version: Optional[float] = None - """ - Relative version distance from the primary memory (+1 for direct child, +2 for - grand-child, etc.) - """ - - -class ResultContextParent(BaseModel): - memory: str - """The contextual memory content""" - - relation: Literal["updates", "extends", "derives"] - """Relation type between this memory and its parent/child""" - - updated_at: str = FieldInfo(alias="updatedAt") - """Contextual memory last update date""" - - metadata: Optional[Dict[str, object]] = None - """Contextual memory metadata""" - - version: Optional[float] = None - """ - Relative version distance from the primary memory (-1 for direct parent, -2 for - grand-parent, etc.) - """ - - -class ResultContext(BaseModel): - """Object containing arrays of parent and child contextual memories""" - - children: Optional[List[ResultContextChild]] = None - - parents: Optional[List[ResultContextParent]] = None - - -class ResultDocument(BaseModel): - id: str - """Document ID""" - - created_at: str = FieldInfo(alias="createdAt") - """Document creation date""" - - updated_at: str = FieldInfo(alias="updatedAt") - """Document last update date""" - - metadata: Optional[Dict[str, object]] = None - """Document metadata (only included when documents=true)""" - - summary: Optional[str] = None - """Document summary (only included when summaries=true)""" - - title: Optional[str] = None - """Document title (only included when documents=true)""" - - type: Optional[str] = None - """Document type (only included when documents=true)""" - - -class Result(BaseModel): - id: str - """Memory entry ID""" - - memory: str - """The memory content""" - - metadata: Optional[Dict[str, object]] = None - """Memory metadata""" - - similarity: float - """Similarity score between the query and memory entry""" - - updated_at: str = FieldInfo(alias="updatedAt") - """Memory last update date""" - - chunks: Optional[List[ResultChunk]] = None - """Relevant chunks from associated documents (only included when chunks=true)""" - - context: Optional[ResultContext] = None - """Object containing arrays of parent and child contextual memories""" - - documents: Optional[List[ResultDocument]] = None - """Associated documents for this memory entry""" - - version: Optional[float] = None - """Version number of this memory entry""" - - -class SearchResponse(BaseModel): - results: List[Result] - """Array of matching memory entries with similarity scores""" - - timing: float - """Search execution time in milliseconds""" - - total: float - """Total number of results returned""" diff --git a/tests/api_resources/test_client.py b/tests/api_resources/test_client.py index 77a5769..37b1c63 100644 --- a/tests/api_resources/test_client.py +++ b/tests/api_resources/test_client.py @@ -9,11 +9,7 @@ from supermemory import Supermemory, AsyncSupermemory from tests.utils import assert_matches_type -from supermemory.types import ( - AddResponse, - SearchResponse, - ProfileResponse, -) +from supermemory.types import AddResponse, ProfileResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -110,61 +106,6 @@ def test_streaming_response_profile(self, client: Supermemory) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_search(self, client: Supermemory) -> None: - client_ = client.search( - q="machine learning concepts", - ) - assert_matches_type(SearchResponse, client_, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_search_with_all_params(self, client: Supermemory) -> None: - client_ = client.search( - q="machine learning concepts", - container_tag="user_123", - filters={"or_": [{}]}, - include={ - "chunks": False, - "documents": True, - "forgotten_memories": False, - "related_memories": True, - "summaries": True, - }, - limit=10, - rerank=False, - rewrite_query=False, - threshold=0.5, - ) - assert_matches_type(SearchResponse, client_, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_raw_response_search(self, client: Supermemory) -> None: - response = client.with_raw_response.search( - q="machine learning concepts", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - client_ = response.parse() - assert_matches_type(SearchResponse, client_, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_streaming_response_search(self, client: Supermemory) -> None: - with client.with_streaming_response.search( - q="machine learning concepts", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - client_ = response.parse() - assert_matches_type(SearchResponse, client_, path=["response"]) - - assert cast(Any, response.is_closed) is True - class TestAsyncClient: parametrize = pytest.mark.parametrize( @@ -259,58 +200,3 @@ async def test_streaming_response_profile(self, async_client: AsyncSupermemory) assert_matches_type(ProfileResponse, client, path=["response"]) assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_search(self, async_client: AsyncSupermemory) -> None: - client = await async_client.search( - q="machine learning concepts", - ) - assert_matches_type(SearchResponse, client, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_search_with_all_params(self, async_client: AsyncSupermemory) -> None: - client = await async_client.search( - q="machine learning concepts", - container_tag="user_123", - filters={"or_": [{}]}, - include={ - "chunks": False, - "documents": True, - "forgotten_memories": False, - "related_memories": True, - "summaries": True, - }, - limit=10, - rerank=False, - rewrite_query=False, - threshold=0.5, - ) - assert_matches_type(SearchResponse, client, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_raw_response_search(self, async_client: AsyncSupermemory) -> None: - response = await async_client.with_raw_response.search( - q="machine learning concepts", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - client = await response.parse() - assert_matches_type(SearchResponse, client, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_streaming_response_search(self, async_client: AsyncSupermemory) -> None: - async with async_client.with_streaming_response.search( - q="machine learning concepts", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - client = await response.parse() - assert_matches_type(SearchResponse, client, path=["response"]) - - assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_documents.py b/tests/api_resources/test_documents.py index 0ef64f8..f18f5ee 100644 --- a/tests/api_resources/test_documents.py +++ b/tests/api_resources/test_documents.py @@ -14,8 +14,10 @@ DocumentGetResponse, DocumentListResponse, DocumentUpdateResponse, + DocumentBatchAddResponse, DocumentDeleteBulkResponse, DocumentUploadFileResponse, + DocumentListProcessingResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -100,17 +102,20 @@ def test_method_list_with_all_params(self, client: Supermemory) -> None: filters={ "and_": [ { - "filterType": "metadata", "key": "group", - "negate": False, "value": "jira_users", + "filter_type": "metadata", + "ignore_case": True, + "negate": False, + "numeric_operator": ">", }, { - "filterType": "numeric", "key": "timestamp", - "negate": False, - "numericOperator": ">", "value": "1742745777", + "filter_type": "numeric", + "ignore_case": True, + "negate": False, + "numeric_operator": ">", }, ] }, @@ -232,6 +237,74 @@ def test_streaming_response_add(self, client: Supermemory) -> None: assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_batch_add(self, client: Supermemory) -> None: + document = client.documents.batch_add( + documents=[{"content": "This is a detailed article about machine learning concepts..."}], + ) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_batch_add_with_all_params(self, client: Supermemory) -> None: + document = client.documents.batch_add( + documents=[ + { + "content": "This is a detailed article about machine learning concepts...", + "container_tag": "user_123", + "container_tags": ["user_123", "project_123"], + "custom_id": "mem_abc123", + "metadata": { + "category": "technology", + "isPublic": True, + "readingTime": 5, + "source": "web", + "tag_1": "ai", + "tag_2": "machine-learning", + }, + } + ], + container_tag="user_123", + container_tags=["user_123", "project_123"], + content=None, + metadata={ + "category": "technology", + "isPublic": True, + "readingTime": 5, + "source": "web", + "tag_1": "ai", + "tag_2": "machine-learning", + }, + ) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_raw_response_batch_add(self, client: Supermemory) -> None: + response = client.documents.with_raw_response.batch_add( + documents=[{"content": "This is a detailed article about machine learning concepts..."}], + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + document = response.parse() + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_streaming_response_batch_add(self, client: Supermemory) -> None: + with client.documents.with_streaming_response.batch_add( + documents=[{"content": "This is a detailed article about machine learning concepts..."}], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + document = response.parse() + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) + + assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_delete_bulk(self, client: Supermemory) -> None: @@ -311,6 +384,34 @@ def test_path_params_get(self, client: Supermemory) -> None: "", ) + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_list_processing(self, client: Supermemory) -> None: + document = client.documents.list_processing() + assert_matches_type(DocumentListProcessingResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_raw_response_list_processing(self, client: Supermemory) -> None: + response = client.documents.with_raw_response.list_processing() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + document = response.parse() + assert_matches_type(DocumentListProcessingResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_streaming_response_list_processing(self, client: Supermemory) -> None: + with client.documents.with_streaming_response.list_processing() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + document = response.parse() + assert_matches_type(DocumentListProcessingResponse, document, path=["response"]) + + assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_upload_file(self, client: Supermemory) -> None: @@ -439,17 +540,20 @@ async def test_method_list_with_all_params(self, async_client: AsyncSupermemory) filters={ "and_": [ { - "filterType": "metadata", "key": "group", - "negate": False, "value": "jira_users", + "filter_type": "metadata", + "ignore_case": True, + "negate": False, + "numeric_operator": ">", }, { - "filterType": "numeric", "key": "timestamp", - "negate": False, - "numericOperator": ">", "value": "1742745777", + "filter_type": "numeric", + "ignore_case": True, + "negate": False, + "numeric_operator": ">", }, ] }, @@ -571,6 +675,74 @@ async def test_streaming_response_add(self, async_client: AsyncSupermemory) -> N assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_batch_add(self, async_client: AsyncSupermemory) -> None: + document = await async_client.documents.batch_add( + documents=[{"content": "This is a detailed article about machine learning concepts..."}], + ) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_batch_add_with_all_params(self, async_client: AsyncSupermemory) -> None: + document = await async_client.documents.batch_add( + documents=[ + { + "content": "This is a detailed article about machine learning concepts...", + "container_tag": "user_123", + "container_tags": ["user_123", "project_123"], + "custom_id": "mem_abc123", + "metadata": { + "category": "technology", + "isPublic": True, + "readingTime": 5, + "source": "web", + "tag_1": "ai", + "tag_2": "machine-learning", + }, + } + ], + container_tag="user_123", + container_tags=["user_123", "project_123"], + content=None, + metadata={ + "category": "technology", + "isPublic": True, + "readingTime": 5, + "source": "web", + "tag_1": "ai", + "tag_2": "machine-learning", + }, + ) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_raw_response_batch_add(self, async_client: AsyncSupermemory) -> None: + response = await async_client.documents.with_raw_response.batch_add( + documents=[{"content": "This is a detailed article about machine learning concepts..."}], + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + document = await response.parse() + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_streaming_response_batch_add(self, async_client: AsyncSupermemory) -> None: + async with async_client.documents.with_streaming_response.batch_add( + documents=[{"content": "This is a detailed article about machine learning concepts..."}], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + document = await response.parse() + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) + + assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_delete_bulk(self, async_client: AsyncSupermemory) -> None: @@ -650,6 +822,34 @@ async def test_path_params_get(self, async_client: AsyncSupermemory) -> None: "", ) + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_list_processing(self, async_client: AsyncSupermemory) -> None: + document = await async_client.documents.list_processing() + assert_matches_type(DocumentListProcessingResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_raw_response_list_processing(self, async_client: AsyncSupermemory) -> None: + response = await async_client.documents.with_raw_response.list_processing() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + document = await response.parse() + assert_matches_type(DocumentListProcessingResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_streaming_response_list_processing(self, async_client: AsyncSupermemory) -> None: + async with async_client.documents.with_streaming_response.list_processing() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + document = await response.parse() + assert_matches_type(DocumentListProcessingResponse, document, path=["response"]) + + assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_upload_file(self, async_client: AsyncSupermemory) -> None: diff --git a/tests/api_resources/test_memories.py b/tests/api_resources/test_memories.py index 908ba97..e6f2a41 100644 --- a/tests/api_resources/test_memories.py +++ b/tests/api_resources/test_memories.py @@ -101,17 +101,20 @@ def test_method_list_with_all_params(self, client: Supermemory) -> None: filters={ "and_": [ { - "filterType": "metadata", "key": "group", - "negate": False, "value": "jira_users", + "filter_type": "metadata", + "ignore_case": True, + "negate": False, + "numeric_operator": ">", }, { - "filterType": "numeric", "key": "timestamp", - "negate": False, - "numericOperator": ">", "value": "1742745777", + "filter_type": "numeric", + "ignore_case": True, + "negate": False, + "numeric_operator": ">", }, ] }, @@ -497,17 +500,20 @@ async def test_method_list_with_all_params(self, async_client: AsyncSupermemory) filters={ "and_": [ { - "filterType": "metadata", "key": "group", - "negate": False, "value": "jira_users", + "filter_type": "metadata", + "ignore_case": True, + "negate": False, + "numeric_operator": ">", }, { - "filterType": "numeric", "key": "timestamp", - "negate": False, - "numericOperator": ">", "value": "1742745777", + "filter_type": "numeric", + "ignore_case": True, + "negate": False, + "numeric_operator": ">", }, ] }, diff --git a/tests/api_resources/test_search.py b/tests/api_resources/test_search.py index 36860ea..8352797 100644 --- a/tests/api_resources/test_search.py +++ b/tests/api_resources/test_search.py @@ -39,7 +39,18 @@ def test_method_documents_with_all_params(self, client: Supermemory) -> None: container_tags=["user_123"], doc_id="docId", document_threshold=0, - filters={"or_": [{}]}, + filters={ + "or_": [ + { + "key": "key", + "value": "value", + "filter_type": "metadata", + "ignore_case": True, + "negate": True, + "numeric_operator": ">", + } + ] + }, include_full_docs=False, include_summary=True, limit=10, @@ -93,7 +104,18 @@ def test_method_execute_with_all_params(self, client: Supermemory) -> None: container_tags=["user_123"], doc_id="docId", document_threshold=0, - filters={"or_": [{}]}, + filters={ + "or_": [ + { + "key": "key", + "value": "value", + "filter_type": "metadata", + "ignore_case": True, + "negate": True, + "numeric_operator": ">", + } + ] + }, include_full_docs=False, include_summary=True, limit=10, @@ -143,7 +165,18 @@ def test_method_memories_with_all_params(self, client: Supermemory) -> None: search = client.search.memories( q="machine learning concepts", container_tag="user_123", - filters={"or_": [{}]}, + filters={ + "or_": [ + { + "key": "key", + "value": "value", + "filter_type": "metadata", + "ignore_case": True, + "negate": True, + "numeric_operator": ">", + } + ] + }, include={ "chunks": False, "documents": True, @@ -208,7 +241,18 @@ async def test_method_documents_with_all_params(self, async_client: AsyncSuperme container_tags=["user_123"], doc_id="docId", document_threshold=0, - filters={"or_": [{}]}, + filters={ + "or_": [ + { + "key": "key", + "value": "value", + "filter_type": "metadata", + "ignore_case": True, + "negate": True, + "numeric_operator": ">", + } + ] + }, include_full_docs=False, include_summary=True, limit=10, @@ -262,7 +306,18 @@ async def test_method_execute_with_all_params(self, async_client: AsyncSupermemo container_tags=["user_123"], doc_id="docId", document_threshold=0, - filters={"or_": [{}]}, + filters={ + "or_": [ + { + "key": "key", + "value": "value", + "filter_type": "metadata", + "ignore_case": True, + "negate": True, + "numeric_operator": ">", + } + ] + }, include_full_docs=False, include_summary=True, limit=10, @@ -312,7 +367,18 @@ async def test_method_memories_with_all_params(self, async_client: AsyncSupermem search = await async_client.search.memories( q="machine learning concepts", container_tag="user_123", - filters={"or_": [{}]}, + filters={ + "or_": [ + { + "key": "key", + "value": "value", + "filter_type": "metadata", + "ignore_case": True, + "negate": True, + "numeric_operator": ">", + } + ] + }, include={ "chunks": False, "documents": True,