From ca75227ff922f6d25d4a12e045066fe6545454af Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 01:01:44 +0000 Subject: [PATCH 01/10] feat(api): manual updates --- .stats.yml | 2 +- api.md | 6 +++++ src/supermemory/types/__init__.py | 1 + src/supermemory/types/client_search_params.py | 20 +++++------------ src/supermemory/types/document_list_params.py | 22 +++++-------------- src/supermemory/types/memory_list_params.py | 22 +++++-------------- .../types/search_documents_params.py | 20 +++++------------ .../types/search_execute_params.py | 20 +++++------------ .../types/search_memories_params.py | 20 +++++------------ src/supermemory/types/shared/__init__.py | 4 ++++ src/supermemory/types/shared/and_.py | 15 +++++++++++++ src/supermemory/types/shared/or_.py | 15 +++++++++++++ .../types/shared_params/__init__.py | 4 ++++ src/supermemory/types/shared_params/and_.py | 16 ++++++++++++++ src/supermemory/types/shared_params/or_.py | 16 ++++++++++++++ 15 files changed, 110 insertions(+), 93 deletions(-) create mode 100644 src/supermemory/types/shared/__init__.py create mode 100644 src/supermemory/types/shared/and_.py create mode 100644 src/supermemory/types/shared/or_.py create mode 100644 src/supermemory/types/shared_params/__init__.py create mode 100644 src/supermemory/types/shared_params/and_.py create mode 100644 src/supermemory/types/shared_params/or_.py diff --git a/.stats.yml b/.stats.yml index b53bbe45..e49b07fe 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 +config_hash: 293588cb2728a4e82aba52073e15ebc1 diff --git a/api.md b/api.md index aca2b3b7..3cfb2341 100644 --- a/api.md +++ b/api.md @@ -1,3 +1,9 @@ +# Shared Types + +```python +from supermemory.types import And, Or +``` + # Supermemory Types: diff --git a/src/supermemory/types/__init__.py b/src/supermemory/types/__init__.py index a60c46c9..988629b8 100644 --- a/src/supermemory/types/__init__.py +++ b/src/supermemory/types/__init__.py @@ -2,6 +2,7 @@ from __future__ import annotations +from .shared import Or as Or, And as And from .add_response import AddResponse as AddResponse from .search_response import SearchResponse as SearchResponse from .profile_response import ProfileResponse as ProfileResponse diff --git a/src/supermemory/types/client_search_params.py b/src/supermemory/types/client_search_params.py index fbc5e245..f18cc483 100644 --- a/src/supermemory/types/client_search_params.py +++ b/src/supermemory/types/client_search_params.py @@ -2,12 +2,14 @@ from __future__ import annotations -from typing import Union, Iterable +from typing import Union from typing_extensions import Required, Annotated, TypeAlias, TypedDict from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["ClientSearchParams", "Filters", "FiltersOr", "FiltersAnd", "Include"] +__all__ = ["ClientSearchParams", "Filters", "Include"] class ClientSearchParams(TypedDict, total=False): @@ -49,19 +51,7 @@ class ClientSearchParams(TypedDict, total=False): """ -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] +Filters: TypeAlias = Union[Or, And] class Include(TypedDict, total=False): diff --git a/src/supermemory/types/document_list_params.py b/src/supermemory/types/document_list_params.py index c3aab05b..f48c76f1 100644 --- a/src/supermemory/types/document_list_params.py +++ b/src/supermemory/types/document_list_params.py @@ -2,13 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable -from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict +from typing import Union +from typing_extensions import Literal, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["DocumentListParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = ["DocumentListParams", "Filters"] class DocumentListParams(TypedDict, total=False): @@ -41,16 +43,4 @@ class DocumentListParams(TypedDict, total=False): """Field to sort by""" -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] +Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/memory_list_params.py b/src/supermemory/types/memory_list_params.py index 31ac58f4..07eb8d9a 100644 --- a/src/supermemory/types/memory_list_params.py +++ b/src/supermemory/types/memory_list_params.py @@ -2,13 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable -from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict +from typing import Union +from typing_extensions import Literal, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["MemoryListParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = ["MemoryListParams", "Filters"] class MemoryListParams(TypedDict, total=False): @@ -41,16 +43,4 @@ class MemoryListParams(TypedDict, total=False): """Field to sort by""" -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] +Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/search_documents_params.py b/src/supermemory/types/search_documents_params.py index 441ce04e..20f62b3c 100644 --- a/src/supermemory/types/search_documents_params.py +++ b/src/supermemory/types/search_documents_params.py @@ -2,13 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable +from typing import Union from typing_extensions import Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["SearchDocumentsParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = ["SearchDocumentsParams", "Filters"] class SearchDocumentsParams(TypedDict, total=False): @@ -82,16 +84,4 @@ class SearchDocumentsParams(TypedDict, total=False): """ -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] +Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/search_execute_params.py b/src/supermemory/types/search_execute_params.py index 0a1290a6..da786065 100644 --- a/src/supermemory/types/search_execute_params.py +++ b/src/supermemory/types/search_execute_params.py @@ -2,13 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable +from typing import Union from typing_extensions import Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["SearchExecuteParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = ["SearchExecuteParams", "Filters"] class SearchExecuteParams(TypedDict, total=False): @@ -82,16 +84,4 @@ class SearchExecuteParams(TypedDict, total=False): """ -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] +Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/search_memories_params.py b/src/supermemory/types/search_memories_params.py index 1d5320b2..7d3bd45b 100644 --- a/src/supermemory/types/search_memories_params.py +++ b/src/supermemory/types/search_memories_params.py @@ -2,12 +2,14 @@ from __future__ import annotations -from typing import Union, Iterable +from typing import Union from typing_extensions import Required, Annotated, TypeAlias, TypedDict from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["SearchMemoriesParams", "Filters", "FiltersOr", "FiltersAnd", "Include"] +__all__ = ["SearchMemoriesParams", "Filters", "Include"] class SearchMemoriesParams(TypedDict, total=False): @@ -49,19 +51,7 @@ class SearchMemoriesParams(TypedDict, total=False): """ -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] +Filters: TypeAlias = Union[Or, And] class Include(TypedDict, total=False): diff --git a/src/supermemory/types/shared/__init__.py b/src/supermemory/types/shared/__init__.py new file mode 100644 index 00000000..96ecf13e --- /dev/null +++ b/src/supermemory/types/shared/__init__.py @@ -0,0 +1,4 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .or_ import Or as Or +from .and_ import And as And diff --git a/src/supermemory/types/shared/and_.py b/src/supermemory/types/shared/and_.py new file mode 100644 index 00000000..1f41863a --- /dev/null +++ b/src/supermemory/types/shared/and_.py @@ -0,0 +1,15 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["And"] + + +class And(BaseModel): + """AND""" + + and_: List[object] = FieldInfo(alias="AND") diff --git a/src/supermemory/types/shared/or_.py b/src/supermemory/types/shared/or_.py new file mode 100644 index 00000000..c5d66048 --- /dev/null +++ b/src/supermemory/types/shared/or_.py @@ -0,0 +1,15 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["Or"] + + +class Or(BaseModel): + """OR""" + + or_: List[object] = FieldInfo(alias="OR") diff --git a/src/supermemory/types/shared_params/__init__.py b/src/supermemory/types/shared_params/__init__.py new file mode 100644 index 00000000..96ecf13e --- /dev/null +++ b/src/supermemory/types/shared_params/__init__.py @@ -0,0 +1,4 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .or_ import Or as Or +from .and_ import And as And diff --git a/src/supermemory/types/shared_params/and_.py b/src/supermemory/types/shared_params/and_.py new file mode 100644 index 00000000..45dc92d8 --- /dev/null +++ b/src/supermemory/types/shared_params/and_.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Iterable +from typing_extensions import Required, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["And"] + + +class And(TypedDict, total=False): + """AND""" + + and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] diff --git a/src/supermemory/types/shared_params/or_.py b/src/supermemory/types/shared_params/or_.py new file mode 100644 index 00000000..448bddc0 --- /dev/null +++ b/src/supermemory/types/shared_params/or_.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Iterable +from typing_extensions import Required, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["Or"] + + +class Or(TypedDict, total=False): + """OR""" + + or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] From acee529be2cdc01a6452cf3981575ece4905465a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 01:03:18 +0000 Subject: [PATCH 02/10] feat(api): manual updates --- .stats.yml | 2 +- README.md | 2 +- api.md | 3 +- src/supermemory/_client.py | 155 +----------------- src/supermemory/types/__init__.py | 2 - src/supermemory/types/client_search_params.py | 75 --------- src/supermemory/types/search_response.py | 143 ---------------- tests/api_resources/test_client.py | 116 +------------ 8 files changed, 5 insertions(+), 493 deletions(-) delete mode 100644 src/supermemory/types/client_search_params.py delete mode 100644 src/supermemory/types/search_response.py diff --git a/.stats.yml b/.stats.yml index e49b07fe..c5a0fc39 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: 293588cb2728a4e82aba52073e15ebc1 +config_hash: 86bb383366a4687b405d4aa49808933d diff --git a/README.md b/README.md index 23c3f8c0..f634745d 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 3cfb2341..3fe06378 100644 --- a/api.md +++ b/api.md @@ -9,14 +9,13 @@ from supermemory.types import And, Or 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 diff --git a/src/supermemory/_client.py b/src/supermemory/_client.py index 044da7dc..e9070a3b 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/types/__init__.py b/src/supermemory/types/__init__.py index 988629b8..5384b467 100644 --- a/src/supermemory/types/__init__.py +++ b/src/supermemory/types/__init__.py @@ -4,7 +4,6 @@ from .shared import Or as Or, And as And 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 @@ -12,7 +11,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 diff --git a/src/supermemory/types/client_search_params.py b/src/supermemory/types/client_search_params.py deleted file mode 100644 index f18cc483..00000000 --- a/src/supermemory/types/client_search_params.py +++ /dev/null @@ -1,75 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union -from typing_extensions import Required, Annotated, TypeAlias, TypedDict - -from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And - -__all__ = ["ClientSearchParams", "Filters", "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) - """ - - -Filters: TypeAlias = Union[Or, And] - - -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/search_response.py b/src/supermemory/types/search_response.py deleted file mode 100644 index 7637939a..00000000 --- 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 77a5769d..37b1c63e 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 From 13a8b89e35e60356537d1c59c6721043e45d7577 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 01:08:44 +0000 Subject: [PATCH 03/10] feat(api): manual updates --- .stats.yml | 4 +- api.md | 5 + src/supermemory/resources/documents.py | 195 +++++++++++++++++- src/supermemory/resources/memories.py | 6 +- src/supermemory/resources/search.py | 15 +- src/supermemory/types/__init__.py | 4 + .../types/document_batch_create_params.py | 84 ++++++++ .../types/document_batch_create_response.py | 19 ++ src/supermemory/types/document_list_params.py | 12 +- .../document_list_processing_response.py | 75 +++++++ src/supermemory/types/memory_list_params.py | 12 +- src/supermemory/types/query_param.py | 13 ++ .../types/search_documents_params.py | 13 +- .../types/search_execute_params.py | 13 +- .../types/search_memories_params.py | 13 +- tests/api_resources/test_documents.py | 194 +++++++++++++++++ 16 files changed, 620 insertions(+), 57 deletions(-) create mode 100644 src/supermemory/types/document_batch_create_params.py create mode 100644 src/supermemory/types/document_batch_create_response.py create mode 100644 src/supermemory/types/document_list_processing_response.py create mode 100644 src/supermemory/types/query_param.py diff --git a/.stats.yml b/.stats.yml index c5a0fc39..16d67525 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 24 +configured_endpoints: 26 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-3856961a8959b60dbf0b6912d69c23390fbbca1c5e31028dd0decc85234dd285.yml openapi_spec_hash: 988a7d6d7cef81ceb4acda3ef9f8c21e -config_hash: 86bb383366a4687b405d4aa49808933d +config_hash: b6ef9b4dc6a01f799e46a04dd24becc7 diff --git a/api.md b/api.md index 3fe06378..9c540c43 100644 --- a/api.md +++ b/api.md @@ -50,11 +50,14 @@ Types: ```python from supermemory.types import ( + Query, DocumentUpdateResponse, DocumentListResponse, DocumentAddResponse, + DocumentBatchCreateResponse, DocumentDeleteBulkResponse, DocumentGetResponse, + DocumentListProcessingResponse, DocumentUploadFileResponse, ) ``` @@ -65,8 +68,10 @@ Methods: - client.documents.list(\*\*params) -> DocumentListResponse - client.documents.delete(id) -> None - client.documents.add(\*\*params) -> DocumentAddResponse +- client.documents.batch_create(\*\*params) -> DocumentBatchCreateResponse - 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/src/supermemory/resources/documents.py b/src/supermemory/resources/documents.py index 6ae976a1..ef45e446 100644 --- a/src/supermemory/resources/documents.py +++ b/src/supermemory/resources/documents.py @@ -2,17 +2,19 @@ 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 from ..types import ( + Query, document_add_params, document_list_params, document_update_params, document_delete_bulk_params, document_upload_file_params, + document_batch_create_params, ) from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, FileTypes, SequenceNotStr, omit, not_given from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform @@ -25,12 +27,15 @@ async_to_streamed_response_wrapper, ) from .._base_client import make_request_options +from ..types.query_param import QueryParam from ..types.document_add_response import DocumentAddResponse from ..types.document_get_response import DocumentGetResponse from ..types.document_list_response import DocumentListResponse from ..types.document_update_response import DocumentUpdateResponse from ..types.document_delete_bulk_response import DocumentDeleteBulkResponse from ..types.document_upload_file_response import DocumentUploadFileResponse +from ..types.document_batch_create_response import DocumentBatchCreateResponse +from ..types.document_list_processing_response import DocumentListProcessingResponse __all__ = ["DocumentsResource", "AsyncDocumentsResource"] @@ -133,7 +138,7 @@ def list( self, *, container_tags: SequenceNotStr[str] | Omit = omit, - filters: document_list_params.Filters | Omit = omit, + filters: QueryParam | Omit = omit, include_content: bool | Omit = omit, limit: Union[str, float] | Omit = omit, order: Literal["asc", "desc"] | Omit = omit, @@ -285,6 +290,67 @@ def add( cast_to=DocumentAddResponse, ) + def batch_create( + self, + *, + documents: Union[Iterable[document_batch_create_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, + ) -> DocumentBatchCreateResponse: + """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_create_params.DocumentBatchCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DocumentBatchCreateResponse, + ) + def delete_bulk( self, *, @@ -361,6 +427,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, *, @@ -529,7 +614,7 @@ async def list( self, *, container_tags: SequenceNotStr[str] | Omit = omit, - filters: document_list_params.Filters | Omit = omit, + filters: QueryParam | Omit = omit, include_content: bool | Omit = omit, limit: Union[str, float] | Omit = omit, order: Literal["asc", "desc"] | Omit = omit, @@ -681,6 +766,67 @@ async def add( cast_to=DocumentAddResponse, ) + async def batch_create( + self, + *, + documents: Union[Iterable[document_batch_create_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, + ) -> DocumentBatchCreateResponse: + """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_create_params.DocumentBatchCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DocumentBatchCreateResponse, + ) + async def delete_bulk( self, *, @@ -757,6 +903,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 +1008,18 @@ def __init__(self, documents: DocumentsResource) -> None: self.add = to_raw_response_wrapper( documents.add, ) + self.batch_create = to_raw_response_wrapper( + documents.batch_create, + ) 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 +1041,18 @@ def __init__(self, documents: AsyncDocumentsResource) -> None: self.add = async_to_raw_response_wrapper( documents.add, ) + self.batch_create = async_to_raw_response_wrapper( + documents.batch_create, + ) 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 +1074,18 @@ def __init__(self, documents: DocumentsResource) -> None: self.add = to_streamed_response_wrapper( documents.add, ) + self.batch_create = to_streamed_response_wrapper( + documents.batch_create, + ) 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 +1107,18 @@ def __init__(self, documents: AsyncDocumentsResource) -> None: self.add = async_to_streamed_response_wrapper( documents.add, ) + self.batch_create = async_to_streamed_response_wrapper( + documents.batch_create, + ) 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/resources/memories.py b/src/supermemory/resources/memories.py index 7779d258..75da698a 100644 --- a/src/supermemory/resources/memories.py +++ b/src/supermemory/resources/memories.py @@ -8,6 +8,7 @@ import httpx from ..types import ( + Query, memory_add_params, memory_list_params, memory_forget_params, @@ -26,6 +27,7 @@ async_to_streamed_response_wrapper, ) from .._base_client import make_request_options +from ..types.query_param import QueryParam from ..types.memory_add_response import MemoryAddResponse from ..types.memory_get_response import MemoryGetResponse from ..types.memory_list_response import MemoryListResponse @@ -135,7 +137,7 @@ def list( self, *, container_tags: SequenceNotStr[str] | Omit = omit, - filters: memory_list_params.Filters | Omit = omit, + filters: QueryParam | Omit = omit, include_content: bool | Omit = omit, limit: Union[str, float] | Omit = omit, order: Literal["asc", "desc"] | Omit = omit, @@ -600,7 +602,7 @@ async def list( self, *, container_tags: SequenceNotStr[str] | Omit = omit, - filters: memory_list_params.Filters | Omit = omit, + filters: QueryParam | Omit = omit, include_content: bool | Omit = omit, limit: Union[str, float] | Omit = omit, order: Literal["asc", "desc"] | Omit = omit, diff --git a/src/supermemory/resources/search.py b/src/supermemory/resources/search.py index a5eec266..ebb11ed7 100644 --- a/src/supermemory/resources/search.py +++ b/src/supermemory/resources/search.py @@ -4,7 +4,7 @@ import httpx -from ..types import search_execute_params, search_memories_params, search_documents_params +from ..types import Query, search_execute_params, search_memories_params, search_documents_params from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property @@ -16,6 +16,7 @@ async_to_streamed_response_wrapper, ) from .._base_client import make_request_options +from ..types.query_param import QueryParam from ..types.search_execute_response import SearchExecuteResponse from ..types.search_memories_response import SearchMemoriesResponse from ..types.search_documents_response import SearchDocumentsResponse @@ -52,7 +53,7 @@ def documents( container_tags: SequenceNotStr[str] | Omit = omit, doc_id: str | Omit = omit, document_threshold: float | Omit = omit, - filters: search_documents_params.Filters | Omit = omit, + filters: QueryParam | Omit = omit, include_full_docs: bool | Omit = omit, include_summary: bool | Omit = omit, limit: int | Omit = omit, @@ -150,7 +151,7 @@ def execute( container_tags: SequenceNotStr[str] | Omit = omit, doc_id: str | Omit = omit, document_threshold: float | Omit = omit, - filters: search_execute_params.Filters | Omit = omit, + filters: QueryParam | Omit = omit, include_full_docs: bool | Omit = omit, include_summary: bool | Omit = omit, limit: int | Omit = omit, @@ -244,7 +245,7 @@ def memories( *, q: str, container_tag: str | Omit = omit, - filters: search_memories_params.Filters | Omit = omit, + filters: QueryParam | Omit = omit, include: search_memories_params.Include | Omit = omit, limit: int | Omit = omit, rerank: bool | Omit = omit, @@ -339,7 +340,7 @@ async def documents( container_tags: SequenceNotStr[str] | Omit = omit, doc_id: str | Omit = omit, document_threshold: float | Omit = omit, - filters: search_documents_params.Filters | Omit = omit, + filters: QueryParam | Omit = omit, include_full_docs: bool | Omit = omit, include_summary: bool | Omit = omit, limit: int | Omit = omit, @@ -437,7 +438,7 @@ async def execute( container_tags: SequenceNotStr[str] | Omit = omit, doc_id: str | Omit = omit, document_threshold: float | Omit = omit, - filters: search_execute_params.Filters | Omit = omit, + filters: QueryParam | Omit = omit, include_full_docs: bool | Omit = omit, include_summary: bool | Omit = omit, limit: int | Omit = omit, @@ -531,7 +532,7 @@ async def memories( *, q: str, container_tag: str | Omit = omit, - filters: search_memories_params.Filters | Omit = omit, + filters: QueryParam | Omit = omit, include: search_memories_params.Include | Omit = omit, limit: int | Omit = omit, rerank: bool | Omit = omit, diff --git a/src/supermemory/types/__init__.py b/src/supermemory/types/__init__.py index 5384b467..31017d54 100644 --- a/src/supermemory/types/__init__.py +++ b/src/supermemory/types/__init__.py @@ -3,6 +3,7 @@ from __future__ import annotations from .shared import Or as Or, And as And +from .query_param import QueryParam as QueryParam from .add_response import AddResponse as AddResponse from .profile_response import ProfileResponse as ProfileResponse from .client_add_params import ClientAddParams as ClientAddParams @@ -46,6 +47,7 @@ from .memory_update_memory_params import MemoryUpdateMemoryParams as MemoryUpdateMemoryParams from .memory_upload_file_response import MemoryUploadFileResponse as MemoryUploadFileResponse from .connection_get_by_tag_params import ConnectionGetByTagParams as ConnectionGetByTagParams +from .document_batch_create_params import DocumentBatchCreateParams as DocumentBatchCreateParams from .connection_configure_response import ConnectionConfigureResponse as ConnectionConfigureResponse from .connection_get_by_id_response import ConnectionGetByIDResponse as ConnectionGetByIDResponse from .connection_resources_response import ConnectionResourcesResponse as ConnectionResourcesResponse @@ -53,8 +55,10 @@ from .document_upload_file_response import DocumentUploadFileResponse as DocumentUploadFileResponse from .memory_update_memory_response import MemoryUpdateMemoryResponse as MemoryUpdateMemoryResponse from .connection_get_by_tag_response import ConnectionGetByTagResponse as ConnectionGetByTagResponse +from .document_batch_create_response import DocumentBatchCreateResponse as DocumentBatchCreateResponse 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/document_batch_create_params.py b/src/supermemory/types/document_batch_create_params.py new file mode 100644 index 00000000..d7be72ad --- /dev/null +++ b/src/supermemory/types/document_batch_create_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__ = ["DocumentBatchCreateParams", "DocumentsUnionMember0"] + + +class DocumentBatchCreateParams(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_create_response.py b/src/supermemory/types/document_batch_create_response.py new file mode 100644 index 00000000..f9b6f5ab --- /dev/null +++ b/src/supermemory/types/document_batch_create_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__ = ["DocumentBatchCreateResponse", "DocumentBatchCreateResponseItem"] + + +class DocumentBatchCreateResponseItem(BaseModel): + id: str + """Unique identifier of the document""" + + status: str + """Status of the document""" + + +DocumentBatchCreateResponse: TypeAlias = List[DocumentBatchCreateResponseItem] diff --git a/src/supermemory/types/document_list_params.py b/src/supermemory/types/document_list_params.py index f48c76f1..0e5bcf8a 100644 --- a/src/supermemory/types/document_list_params.py +++ b/src/supermemory/types/document_list_params.py @@ -3,14 +3,13 @@ from __future__ import annotations from typing import Union -from typing_extensions import Literal, Annotated, TypeAlias, TypedDict +from typing_extensions import Literal, Annotated, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And +from .query_param import QueryParam -__all__ = ["DocumentListParams", "Filters"] +__all__ = ["DocumentListParams"] class DocumentListParams(TypedDict, total=False): @@ -21,7 +20,7 @@ class DocumentListParams(TypedDict, total=False): to use to group documents. """ - filters: Filters + filters: QueryParam """Optional filters to apply to the search. Can be a JSON string or Query object.""" include_content: Annotated[bool, PropertyInfo(alias="includeContent")] @@ -41,6 +40,3 @@ class DocumentListParams(TypedDict, total=False): sort: Literal["createdAt", "updatedAt"] """Field to sort by""" - - -Filters: TypeAlias = Union[Or, And] 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 00000000..6a671b25 --- /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 07eb8d9a..12b63949 100644 --- a/src/supermemory/types/memory_list_params.py +++ b/src/supermemory/types/memory_list_params.py @@ -3,14 +3,13 @@ from __future__ import annotations from typing import Union -from typing_extensions import Literal, Annotated, TypeAlias, TypedDict +from typing_extensions import Literal, Annotated, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And +from .query_param import QueryParam -__all__ = ["MemoryListParams", "Filters"] +__all__ = ["MemoryListParams"] class MemoryListParams(TypedDict, total=False): @@ -21,7 +20,7 @@ class MemoryListParams(TypedDict, total=False): to use to group documents. """ - filters: Filters + filters: QueryParam """Optional filters to apply to the search. Can be a JSON string or Query object.""" include_content: Annotated[bool, PropertyInfo(alias="includeContent")] @@ -41,6 +40,3 @@ class MemoryListParams(TypedDict, total=False): sort: Literal["createdAt", "updatedAt"] """Field to sort by""" - - -Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/query_param.py b/src/supermemory/types/query_param.py new file mode 100644 index 00000000..8a88b781 --- /dev/null +++ b/src/supermemory/types/query_param.py @@ -0,0 +1,13 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from typing_extensions import TypeAlias + +from .shared_params.or_ import Or +from .shared_params.and_ import And + +__all__ = ["QueryParam"] + +QueryParam: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/search_documents_params.py b/src/supermemory/types/search_documents_params.py index 20f62b3c..8455838b 100644 --- a/src/supermemory/types/search_documents_params.py +++ b/src/supermemory/types/search_documents_params.py @@ -2,15 +2,13 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Required, Annotated, TypeAlias, TypedDict +from typing_extensions import Required, Annotated, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And +from .query_param import QueryParam -__all__ = ["SearchDocumentsParams", "Filters"] +__all__ = ["SearchDocumentsParams"] class SearchDocumentsParams(TypedDict, total=False): @@ -46,7 +44,7 @@ class SearchDocumentsParams(TypedDict, total=False): The search now uses chunkThreshold only. This parameter will be ignored. """ - filters: Filters + filters: QueryParam """Optional filters to apply to the search. Can be a JSON string or Query object.""" include_full_docs: Annotated[bool, PropertyInfo(alias="includeFullDocs")] @@ -82,6 +80,3 @@ class SearchDocumentsParams(TypedDict, total=False): This increases the latency by about 400ms """ - - -Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/search_execute_params.py b/src/supermemory/types/search_execute_params.py index da786065..f11c0791 100644 --- a/src/supermemory/types/search_execute_params.py +++ b/src/supermemory/types/search_execute_params.py @@ -2,15 +2,13 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Required, Annotated, TypeAlias, TypedDict +from typing_extensions import Required, Annotated, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And +from .query_param import QueryParam -__all__ = ["SearchExecuteParams", "Filters"] +__all__ = ["SearchExecuteParams"] class SearchExecuteParams(TypedDict, total=False): @@ -46,7 +44,7 @@ class SearchExecuteParams(TypedDict, total=False): The search now uses chunkThreshold only. This parameter will be ignored. """ - filters: Filters + filters: QueryParam """Optional filters to apply to the search. Can be a JSON string or Query object.""" include_full_docs: Annotated[bool, PropertyInfo(alias="includeFullDocs")] @@ -82,6 +80,3 @@ class SearchExecuteParams(TypedDict, total=False): This increases the latency by about 400ms """ - - -Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/search_memories_params.py b/src/supermemory/types/search_memories_params.py index 7d3bd45b..ed6c2c85 100644 --- a/src/supermemory/types/search_memories_params.py +++ b/src/supermemory/types/search_memories_params.py @@ -2,14 +2,12 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Required, Annotated, TypeAlias, TypedDict +from typing_extensions import Required, Annotated, TypedDict from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And +from .query_param import QueryParam -__all__ = ["SearchMemoriesParams", "Filters", "Include"] +__all__ = ["SearchMemoriesParams", "Include"] class SearchMemoriesParams(TypedDict, total=False): @@ -23,7 +21,7 @@ class SearchMemoriesParams(TypedDict, total=False): to use to filter memories. """ - filters: Filters + filters: QueryParam """Optional filters to apply to the search. Can be a JSON string or Query object.""" include: Include @@ -51,9 +49,6 @@ class SearchMemoriesParams(TypedDict, total=False): """ -Filters: TypeAlias = Union[Or, And] - - class Include(TypedDict, total=False): chunks: bool """ diff --git a/tests/api_resources/test_documents.py b/tests/api_resources/test_documents.py index 0ef64f86..68378095 100644 --- a/tests/api_resources/test_documents.py +++ b/tests/api_resources/test_documents.py @@ -16,6 +16,8 @@ DocumentUpdateResponse, DocumentDeleteBulkResponse, DocumentUploadFileResponse, + DocumentBatchCreateResponse, + DocumentListProcessingResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -232,6 +234,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_create(self, client: Supermemory) -> None: + document = client.documents.batch_create( + documents=[{"content": "This is a detailed article about machine learning concepts..."}], + ) + assert_matches_type(DocumentBatchCreateResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_method_batch_create_with_all_params(self, client: Supermemory) -> None: + document = client.documents.batch_create( + 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(DocumentBatchCreateResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_raw_response_batch_create(self, client: Supermemory) -> None: + response = client.documents.with_raw_response.batch_create( + 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(DocumentBatchCreateResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + def test_streaming_response_batch_create(self, client: Supermemory) -> None: + with client.documents.with_streaming_response.batch_create( + 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(DocumentBatchCreateResponse, 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 +381,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: @@ -571,6 +669,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_create(self, async_client: AsyncSupermemory) -> None: + document = await async_client.documents.batch_create( + documents=[{"content": "This is a detailed article about machine learning concepts..."}], + ) + assert_matches_type(DocumentBatchCreateResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_method_batch_create_with_all_params(self, async_client: AsyncSupermemory) -> None: + document = await async_client.documents.batch_create( + 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(DocumentBatchCreateResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_raw_response_batch_create(self, async_client: AsyncSupermemory) -> None: + response = await async_client.documents.with_raw_response.batch_create( + 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(DocumentBatchCreateResponse, document, path=["response"]) + + @pytest.mark.skip(reason="Prism tests are disabled") + @parametrize + async def test_streaming_response_batch_create(self, async_client: AsyncSupermemory) -> None: + async with async_client.documents.with_streaming_response.batch_create( + 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(DocumentBatchCreateResponse, 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 +816,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: From 094162f52b3eba730f85176acfb5b5f34267449f Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 01:09:04 +0000 Subject: [PATCH 04/10] feat(api): manual updates --- .stats.yml | 2 +- api.md | 4 +- src/supermemory/resources/documents.py | 40 +++++++-------- src/supermemory/types/__init__.py | 4 +- ...params.py => document_batch_add_params.py} | 4 +- ...onse.py => document_batch_add_response.py} | 6 +-- tests/api_resources/test_documents.py | 50 +++++++++---------- 7 files changed, 55 insertions(+), 55 deletions(-) rename src/supermemory/types/{document_batch_create_params.py => document_batch_add_params.py} (96%) rename src/supermemory/types/{document_batch_create_response.py => document_batch_add_response.py} (58%) diff --git a/.stats.yml b/.stats.yml index 16d67525..e204cf34 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 26 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-3856961a8959b60dbf0b6912d69c23390fbbca1c5e31028dd0decc85234dd285.yml openapi_spec_hash: 988a7d6d7cef81ceb4acda3ef9f8c21e -config_hash: b6ef9b4dc6a01f799e46a04dd24becc7 +config_hash: 87b9e108ccf7a61dbda94437747a84be diff --git a/api.md b/api.md index 9c540c43..9500981d 100644 --- a/api.md +++ b/api.md @@ -54,7 +54,7 @@ from supermemory.types import ( DocumentUpdateResponse, DocumentListResponse, DocumentAddResponse, - DocumentBatchCreateResponse, + DocumentBatchAddResponse, DocumentDeleteBulkResponse, DocumentGetResponse, DocumentListProcessingResponse, @@ -68,7 +68,7 @@ Methods: - client.documents.list(\*\*params) -> DocumentListResponse - client.documents.delete(id) -> None - client.documents.add(\*\*params) -> DocumentAddResponse -- client.documents.batch_create(\*\*params) -> DocumentBatchCreateResponse +- client.documents.batch_add(\*\*params) -> DocumentBatchAddResponse - client.documents.delete_bulk(\*\*params) -> DocumentDeleteBulkResponse - client.documents.get(id) -> DocumentGetResponse - client.documents.list_processing() -> DocumentListProcessingResponse diff --git a/src/supermemory/resources/documents.py b/src/supermemory/resources/documents.py index ef45e446..503ebae5 100644 --- a/src/supermemory/resources/documents.py +++ b/src/supermemory/resources/documents.py @@ -12,9 +12,9 @@ document_add_params, document_list_params, document_update_params, + document_batch_add_params, document_delete_bulk_params, document_upload_file_params, - document_batch_create_params, ) from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, FileTypes, SequenceNotStr, omit, not_given from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform @@ -32,9 +32,9 @@ 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_batch_create_response import DocumentBatchCreateResponse from ..types.document_list_processing_response import DocumentListProcessingResponse __all__ = ["DocumentsResource", "AsyncDocumentsResource"] @@ -290,10 +290,10 @@ def add( cast_to=DocumentAddResponse, ) - def batch_create( + def batch_add( self, *, - documents: Union[Iterable[document_batch_create_params.DocumentsUnionMember0], SequenceNotStr[str]], + 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, @@ -304,7 +304,7 @@ def batch_create( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> DocumentBatchCreateResponse: + ) -> DocumentBatchAddResponse: """Add multiple documents in a single request. Each document can have any content @@ -343,12 +343,12 @@ def batch_create( "content": content, "metadata": metadata, }, - document_batch_create_params.DocumentBatchCreateParams, + 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=DocumentBatchCreateResponse, + cast_to=DocumentBatchAddResponse, ) def delete_bulk( @@ -766,10 +766,10 @@ async def add( cast_to=DocumentAddResponse, ) - async def batch_create( + async def batch_add( self, *, - documents: Union[Iterable[document_batch_create_params.DocumentsUnionMember0], SequenceNotStr[str]], + 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, @@ -780,7 +780,7 @@ async def batch_create( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> DocumentBatchCreateResponse: + ) -> DocumentBatchAddResponse: """Add multiple documents in a single request. Each document can have any content @@ -819,12 +819,12 @@ async def batch_create( "content": content, "metadata": metadata, }, - document_batch_create_params.DocumentBatchCreateParams, + 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=DocumentBatchCreateResponse, + cast_to=DocumentBatchAddResponse, ) async def delete_bulk( @@ -1008,8 +1008,8 @@ def __init__(self, documents: DocumentsResource) -> None: self.add = to_raw_response_wrapper( documents.add, ) - self.batch_create = to_raw_response_wrapper( - documents.batch_create, + self.batch_add = to_raw_response_wrapper( + documents.batch_add, ) self.delete_bulk = to_raw_response_wrapper( documents.delete_bulk, @@ -1041,8 +1041,8 @@ def __init__(self, documents: AsyncDocumentsResource) -> None: self.add = async_to_raw_response_wrapper( documents.add, ) - self.batch_create = async_to_raw_response_wrapper( - documents.batch_create, + self.batch_add = async_to_raw_response_wrapper( + documents.batch_add, ) self.delete_bulk = async_to_raw_response_wrapper( documents.delete_bulk, @@ -1074,8 +1074,8 @@ def __init__(self, documents: DocumentsResource) -> None: self.add = to_streamed_response_wrapper( documents.add, ) - self.batch_create = to_streamed_response_wrapper( - documents.batch_create, + self.batch_add = to_streamed_response_wrapper( + documents.batch_add, ) self.delete_bulk = to_streamed_response_wrapper( documents.delete_bulk, @@ -1107,8 +1107,8 @@ def __init__(self, documents: AsyncDocumentsResource) -> None: self.add = async_to_streamed_response_wrapper( documents.add, ) - self.batch_create = async_to_streamed_response_wrapper( - documents.batch_create, + self.batch_add = async_to_streamed_response_wrapper( + documents.batch_add, ) self.delete_bulk = async_to_streamed_response_wrapper( documents.delete_bulk, diff --git a/src/supermemory/types/__init__.py b/src/supermemory/types/__init__.py index 31017d54..ce31d081 100644 --- a/src/supermemory/types/__init__.py +++ b/src/supermemory/types/__init__.py @@ -36,18 +36,19 @@ 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 from .memory_upload_file_response import MemoryUploadFileResponse as MemoryUploadFileResponse from .connection_get_by_tag_params import ConnectionGetByTagParams as ConnectionGetByTagParams -from .document_batch_create_params import DocumentBatchCreateParams as DocumentBatchCreateParams from .connection_configure_response import ConnectionConfigureResponse as ConnectionConfigureResponse from .connection_get_by_id_response import ConnectionGetByIDResponse as ConnectionGetByIDResponse from .connection_resources_response import ConnectionResourcesResponse as ConnectionResourcesResponse @@ -55,7 +56,6 @@ from .document_upload_file_response import DocumentUploadFileResponse as DocumentUploadFileResponse from .memory_update_memory_response import MemoryUpdateMemoryResponse as MemoryUpdateMemoryResponse from .connection_get_by_tag_response import ConnectionGetByTagResponse as ConnectionGetByTagResponse -from .document_batch_create_response import DocumentBatchCreateResponse as DocumentBatchCreateResponse 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 diff --git a/src/supermemory/types/document_batch_create_params.py b/src/supermemory/types/document_batch_add_params.py similarity index 96% rename from src/supermemory/types/document_batch_create_params.py rename to src/supermemory/types/document_batch_add_params.py index d7be72ad..4a35fe85 100644 --- a/src/supermemory/types/document_batch_create_params.py +++ b/src/supermemory/types/document_batch_add_params.py @@ -8,10 +8,10 @@ from .._types import SequenceNotStr from .._utils import PropertyInfo -__all__ = ["DocumentBatchCreateParams", "DocumentsUnionMember0"] +__all__ = ["DocumentBatchAddParams", "DocumentsUnionMember0"] -class DocumentBatchCreateParams(TypedDict, total=False): +class DocumentBatchAddParams(TypedDict, total=False): documents: Required[Union[Iterable[DocumentsUnionMember0], SequenceNotStr[str]]] container_tag: Annotated[str, PropertyInfo(alias="containerTag")] diff --git a/src/supermemory/types/document_batch_create_response.py b/src/supermemory/types/document_batch_add_response.py similarity index 58% rename from src/supermemory/types/document_batch_create_response.py rename to src/supermemory/types/document_batch_add_response.py index f9b6f5ab..f5a3bda0 100644 --- a/src/supermemory/types/document_batch_create_response.py +++ b/src/supermemory/types/document_batch_add_response.py @@ -5,10 +5,10 @@ from .._models import BaseModel -__all__ = ["DocumentBatchCreateResponse", "DocumentBatchCreateResponseItem"] +__all__ = ["DocumentBatchAddResponse", "DocumentBatchAddResponseItem"] -class DocumentBatchCreateResponseItem(BaseModel): +class DocumentBatchAddResponseItem(BaseModel): id: str """Unique identifier of the document""" @@ -16,4 +16,4 @@ class DocumentBatchCreateResponseItem(BaseModel): """Status of the document""" -DocumentBatchCreateResponse: TypeAlias = List[DocumentBatchCreateResponseItem] +DocumentBatchAddResponse: TypeAlias = List[DocumentBatchAddResponseItem] diff --git a/tests/api_resources/test_documents.py b/tests/api_resources/test_documents.py index 68378095..925bf10f 100644 --- a/tests/api_resources/test_documents.py +++ b/tests/api_resources/test_documents.py @@ -14,9 +14,9 @@ DocumentGetResponse, DocumentListResponse, DocumentUpdateResponse, + DocumentBatchAddResponse, DocumentDeleteBulkResponse, DocumentUploadFileResponse, - DocumentBatchCreateResponse, DocumentListProcessingResponse, ) @@ -236,16 +236,16 @@ def test_streaming_response_add(self, client: Supermemory) -> None: @pytest.mark.skip(reason="Prism tests are disabled") @parametrize - def test_method_batch_create(self, client: Supermemory) -> None: - document = client.documents.batch_create( + 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(DocumentBatchCreateResponse, document, path=["response"]) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize - def test_method_batch_create_with_all_params(self, client: Supermemory) -> None: - document = client.documents.batch_create( + 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...", @@ -274,31 +274,31 @@ def test_method_batch_create_with_all_params(self, client: Supermemory) -> None: "tag_2": "machine-learning", }, ) - assert_matches_type(DocumentBatchCreateResponse, document, path=["response"]) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize - def test_raw_response_batch_create(self, client: Supermemory) -> None: - response = client.documents.with_raw_response.batch_create( + 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(DocumentBatchCreateResponse, document, path=["response"]) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize - def test_streaming_response_batch_create(self, client: Supermemory) -> None: - with client.documents.with_streaming_response.batch_create( + 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(DocumentBatchCreateResponse, document, path=["response"]) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) assert cast(Any, response.is_closed) is True @@ -671,16 +671,16 @@ async def test_streaming_response_add(self, async_client: AsyncSupermemory) -> N @pytest.mark.skip(reason="Prism tests are disabled") @parametrize - async def test_method_batch_create(self, async_client: AsyncSupermemory) -> None: - document = await async_client.documents.batch_create( + 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(DocumentBatchCreateResponse, document, path=["response"]) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize - async def test_method_batch_create_with_all_params(self, async_client: AsyncSupermemory) -> None: - document = await async_client.documents.batch_create( + 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...", @@ -709,31 +709,31 @@ async def test_method_batch_create_with_all_params(self, async_client: AsyncSupe "tag_2": "machine-learning", }, ) - assert_matches_type(DocumentBatchCreateResponse, document, path=["response"]) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize - async def test_raw_response_batch_create(self, async_client: AsyncSupermemory) -> None: - response = await async_client.documents.with_raw_response.batch_create( + 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(DocumentBatchCreateResponse, document, path=["response"]) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) @pytest.mark.skip(reason="Prism tests are disabled") @parametrize - async def test_streaming_response_batch_create(self, async_client: AsyncSupermemory) -> None: - async with async_client.documents.with_streaming_response.batch_create( + 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(DocumentBatchCreateResponse, document, path=["response"]) + assert_matches_type(DocumentBatchAddResponse, document, path=["response"]) assert cast(Any, response.is_closed) is True From 822525089de88691c334f32b8ae3bf71096894e9 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 01:49:09 +0000 Subject: [PATCH 05/10] feat(api): api update --- .stats.yml | 4 +- api.md | 7 - src/supermemory/resources/documents.py | 6 +- src/supermemory/resources/memories.py | 6 +- src/supermemory/resources/search.py | 15 +- src/supermemory/types/__init__.py | 2 - src/supermemory/types/document_list_params.py | 3807 ++++++++++++++++- src/supermemory/types/memory_list_params.py | 3807 ++++++++++++++++- src/supermemory/types/query_param.py | 13 - .../types/search_documents_params.py | 3806 +++++++++++++++- .../types/search_execute_params.py | 3806 +++++++++++++++- .../types/search_memories_params.py | 3807 ++++++++++++++++- src/supermemory/types/shared/__init__.py | 4 - src/supermemory/types/shared/and_.py | 15 - src/supermemory/types/shared/or_.py | 15 - .../types/shared_params/__init__.py | 4 - src/supermemory/types/shared_params/and_.py | 16 - src/supermemory/types/shared_params/or_.py | 16 - tests/api_resources/test_documents.py | 26 +- tests/api_resources/test_memories.py | 26 +- tests/api_resources/test_search.py | 78 +- 21 files changed, 19128 insertions(+), 158 deletions(-) delete mode 100644 src/supermemory/types/query_param.py delete mode 100644 src/supermemory/types/shared/__init__.py delete mode 100644 src/supermemory/types/shared/and_.py delete mode 100644 src/supermemory/types/shared/or_.py delete mode 100644 src/supermemory/types/shared_params/__init__.py delete mode 100644 src/supermemory/types/shared_params/and_.py delete mode 100644 src/supermemory/types/shared_params/or_.py diff --git a/.stats.yml b/.stats.yml index e204cf34..35905d06 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 26 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-3856961a8959b60dbf0b6912d69c23390fbbca1c5e31028dd0decc85234dd285.yml -openapi_spec_hash: 988a7d6d7cef81ceb4acda3ef9f8c21e +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-c42d5f3942d6e32b6d1ed95d40bf6cca87aa8c715343444b97e0c68d44646878.yml +openapi_spec_hash: 952074229d1f810fe95aeee711db8ca4 config_hash: 87b9e108ccf7a61dbda94437747a84be diff --git a/api.md b/api.md index 9500981d..84da60ef 100644 --- a/api.md +++ b/api.md @@ -1,9 +1,3 @@ -# Shared Types - -```python -from supermemory.types import And, Or -``` - # Supermemory Types: @@ -50,7 +44,6 @@ Types: ```python from supermemory.types import ( - Query, DocumentUpdateResponse, DocumentListResponse, DocumentAddResponse, diff --git a/src/supermemory/resources/documents.py b/src/supermemory/resources/documents.py index 503ebae5..c99a3a59 100644 --- a/src/supermemory/resources/documents.py +++ b/src/supermemory/resources/documents.py @@ -8,7 +8,6 @@ import httpx from ..types import ( - Query, document_add_params, document_list_params, document_update_params, @@ -27,7 +26,6 @@ async_to_streamed_response_wrapper, ) from .._base_client import make_request_options -from ..types.query_param import QueryParam from ..types.document_add_response import DocumentAddResponse from ..types.document_get_response import DocumentGetResponse from ..types.document_list_response import DocumentListResponse @@ -138,7 +136,7 @@ def list( self, *, container_tags: SequenceNotStr[str] | Omit = omit, - filters: QueryParam | Omit = omit, + filters: document_list_params.Filters | Omit = omit, include_content: bool | Omit = omit, limit: Union[str, float] | Omit = omit, order: Literal["asc", "desc"] | Omit = omit, @@ -614,7 +612,7 @@ async def list( self, *, container_tags: SequenceNotStr[str] | Omit = omit, - filters: QueryParam | Omit = omit, + filters: document_list_params.Filters | Omit = omit, include_content: bool | Omit = omit, limit: Union[str, float] | Omit = omit, order: Literal["asc", "desc"] | Omit = omit, diff --git a/src/supermemory/resources/memories.py b/src/supermemory/resources/memories.py index 75da698a..7779d258 100644 --- a/src/supermemory/resources/memories.py +++ b/src/supermemory/resources/memories.py @@ -8,7 +8,6 @@ import httpx from ..types import ( - Query, memory_add_params, memory_list_params, memory_forget_params, @@ -27,7 +26,6 @@ async_to_streamed_response_wrapper, ) from .._base_client import make_request_options -from ..types.query_param import QueryParam from ..types.memory_add_response import MemoryAddResponse from ..types.memory_get_response import MemoryGetResponse from ..types.memory_list_response import MemoryListResponse @@ -137,7 +135,7 @@ def list( self, *, container_tags: SequenceNotStr[str] | Omit = omit, - filters: QueryParam | Omit = omit, + filters: memory_list_params.Filters | Omit = omit, include_content: bool | Omit = omit, limit: Union[str, float] | Omit = omit, order: Literal["asc", "desc"] | Omit = omit, @@ -602,7 +600,7 @@ async def list( self, *, container_tags: SequenceNotStr[str] | Omit = omit, - filters: QueryParam | Omit = omit, + filters: memory_list_params.Filters | Omit = omit, include_content: bool | Omit = omit, limit: Union[str, float] | Omit = omit, order: Literal["asc", "desc"] | Omit = omit, diff --git a/src/supermemory/resources/search.py b/src/supermemory/resources/search.py index ebb11ed7..a5eec266 100644 --- a/src/supermemory/resources/search.py +++ b/src/supermemory/resources/search.py @@ -4,7 +4,7 @@ import httpx -from ..types import Query, search_execute_params, search_memories_params, search_documents_params +from ..types import search_execute_params, search_memories_params, search_documents_params from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property @@ -16,7 +16,6 @@ async_to_streamed_response_wrapper, ) from .._base_client import make_request_options -from ..types.query_param import QueryParam from ..types.search_execute_response import SearchExecuteResponse from ..types.search_memories_response import SearchMemoriesResponse from ..types.search_documents_response import SearchDocumentsResponse @@ -53,7 +52,7 @@ def documents( container_tags: SequenceNotStr[str] | Omit = omit, doc_id: str | Omit = omit, document_threshold: float | Omit = omit, - filters: QueryParam | Omit = omit, + filters: search_documents_params.Filters | Omit = omit, include_full_docs: bool | Omit = omit, include_summary: bool | Omit = omit, limit: int | Omit = omit, @@ -151,7 +150,7 @@ def execute( container_tags: SequenceNotStr[str] | Omit = omit, doc_id: str | Omit = omit, document_threshold: float | Omit = omit, - filters: QueryParam | Omit = omit, + filters: search_execute_params.Filters | Omit = omit, include_full_docs: bool | Omit = omit, include_summary: bool | Omit = omit, limit: int | Omit = omit, @@ -245,7 +244,7 @@ def memories( *, q: str, container_tag: str | Omit = omit, - filters: QueryParam | Omit = omit, + filters: search_memories_params.Filters | Omit = omit, include: search_memories_params.Include | Omit = omit, limit: int | Omit = omit, rerank: bool | Omit = omit, @@ -340,7 +339,7 @@ async def documents( container_tags: SequenceNotStr[str] | Omit = omit, doc_id: str | Omit = omit, document_threshold: float | Omit = omit, - filters: QueryParam | Omit = omit, + filters: search_documents_params.Filters | Omit = omit, include_full_docs: bool | Omit = omit, include_summary: bool | Omit = omit, limit: int | Omit = omit, @@ -438,7 +437,7 @@ async def execute( container_tags: SequenceNotStr[str] | Omit = omit, doc_id: str | Omit = omit, document_threshold: float | Omit = omit, - filters: QueryParam | Omit = omit, + filters: search_execute_params.Filters | Omit = omit, include_full_docs: bool | Omit = omit, include_summary: bool | Omit = omit, limit: int | Omit = omit, @@ -532,7 +531,7 @@ async def memories( *, q: str, container_tag: str | Omit = omit, - filters: QueryParam | Omit = omit, + filters: search_memories_params.Filters | Omit = omit, include: search_memories_params.Include | Omit = omit, limit: int | Omit = omit, rerank: bool | Omit = omit, diff --git a/src/supermemory/types/__init__.py b/src/supermemory/types/__init__.py index ce31d081..0cdef254 100644 --- a/src/supermemory/types/__init__.py +++ b/src/supermemory/types/__init__.py @@ -2,8 +2,6 @@ from __future__ import annotations -from .shared import Or as Or, And as And -from .query_param import QueryParam as QueryParam from .add_response import AddResponse as AddResponse from .profile_response import ProfileResponse as ProfileResponse from .client_add_params import ClientAddParams as ClientAddParams diff --git a/src/supermemory/types/document_list_params.py b/src/supermemory/types/document_list_params.py index 0e5bcf8a..d37a0e39 100644 --- a/src/supermemory/types/document_list_params.py +++ b/src/supermemory/types/document_list_params.py @@ -2,14 +2,330 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Literal, Annotated, TypedDict +from typing import Union, Iterable +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .query_param import QueryParam -__all__ = ["DocumentListParams"] +__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): @@ -20,7 +336,7 @@ class DocumentListParams(TypedDict, total=False): to use to group documents. """ - filters: QueryParam + filters: Filters """Optional filters to apply to the search. Can be a JSON string or Query object.""" include_content: Annotated[bool, PropertyInfo(alias="includeContent")] @@ -40,3 +356,3484 @@ class DocumentListParams(TypedDict, total=False): sort: Literal["createdAt", "updatedAt"] """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_: 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_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/memory_list_params.py b/src/supermemory/types/memory_list_params.py index 12b63949..2e2cb575 100644 --- a/src/supermemory/types/memory_list_params.py +++ b/src/supermemory/types/memory_list_params.py @@ -2,14 +2,330 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Literal, Annotated, TypedDict +from typing import Union, Iterable +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .query_param import QueryParam -__all__ = ["MemoryListParams"] +__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): @@ -20,7 +336,7 @@ class MemoryListParams(TypedDict, total=False): to use to group documents. """ - filters: QueryParam + filters: Filters """Optional filters to apply to the search. Can be a JSON string or Query object.""" include_content: Annotated[bool, PropertyInfo(alias="includeContent")] @@ -40,3 +356,3484 @@ class MemoryListParams(TypedDict, total=False): sort: Literal["createdAt", "updatedAt"] """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_: 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_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/query_param.py b/src/supermemory/types/query_param.py deleted file mode 100644 index 8a88b781..00000000 --- a/src/supermemory/types/query_param.py +++ /dev/null @@ -1,13 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union -from typing_extensions import TypeAlias - -from .shared_params.or_ import Or -from .shared_params.and_ import And - -__all__ = ["QueryParam"] - -QueryParam: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/search_documents_params.py b/src/supermemory/types/search_documents_params.py index 8455838b..87c235d2 100644 --- a/src/supermemory/types/search_documents_params.py +++ b/src/supermemory/types/search_documents_params.py @@ -2,13 +2,330 @@ from __future__ import annotations -from typing_extensions import Required, Annotated, TypedDict +from typing import Union, Iterable +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .query_param import QueryParam -__all__ = ["SearchDocumentsParams"] +__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): @@ -44,7 +361,7 @@ class SearchDocumentsParams(TypedDict, total=False): The search now uses chunkThreshold only. This parameter will be ignored. """ - filters: QueryParam + filters: Filters """Optional filters to apply to the search. Can be a JSON string or Query object.""" include_full_docs: Annotated[bool, PropertyInfo(alias="includeFullDocs")] @@ -80,3 +397,3484 @@ class SearchDocumentsParams(TypedDict, total=False): This increases the latency by about 400ms """ + + +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_: 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_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 f11c0791..56121a3e 100644 --- a/src/supermemory/types/search_execute_params.py +++ b/src/supermemory/types/search_execute_params.py @@ -2,13 +2,330 @@ from __future__ import annotations -from typing_extensions import Required, Annotated, TypedDict +from typing import Union, Iterable +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .query_param import QueryParam -__all__ = ["SearchExecuteParams"] +__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): @@ -44,7 +361,7 @@ class SearchExecuteParams(TypedDict, total=False): The search now uses chunkThreshold only. This parameter will be ignored. """ - filters: QueryParam + filters: Filters """Optional filters to apply to the search. Can be a JSON string or Query object.""" include_full_docs: Annotated[bool, PropertyInfo(alias="includeFullDocs")] @@ -80,3 +397,3484 @@ class SearchExecuteParams(TypedDict, total=False): This increases the latency by about 400ms """ + + +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_: 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_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 ed6c2c85..e5bb7baf 100644 --- a/src/supermemory/types/search_memories_params.py +++ b/src/supermemory/types/search_memories_params.py @@ -2,12 +2,330 @@ from __future__ import annotations -from typing_extensions import Required, Annotated, TypedDict +from typing import Union, Iterable +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._utils import PropertyInfo -from .query_param import QueryParam -__all__ = ["SearchMemoriesParams", "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): @@ -21,7 +339,7 @@ class SearchMemoriesParams(TypedDict, total=False): to use to filter memories. """ - filters: QueryParam + filters: Filters """Optional filters to apply to the search. Can be a JSON string or Query object.""" include: Include @@ -49,6 +367,3487 @@ 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_: 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_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] + + class Include(TypedDict, total=False): chunks: bool """ diff --git a/src/supermemory/types/shared/__init__.py b/src/supermemory/types/shared/__init__.py deleted file mode 100644 index 96ecf13e..00000000 --- a/src/supermemory/types/shared/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .or_ import Or as Or -from .and_ import And as And diff --git a/src/supermemory/types/shared/and_.py b/src/supermemory/types/shared/and_.py deleted file mode 100644 index 1f41863a..00000000 --- a/src/supermemory/types/shared/and_.py +++ /dev/null @@ -1,15 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List - -from pydantic import Field as FieldInfo - -from ..._models import BaseModel - -__all__ = ["And"] - - -class And(BaseModel): - """AND""" - - and_: List[object] = FieldInfo(alias="AND") diff --git a/src/supermemory/types/shared/or_.py b/src/supermemory/types/shared/or_.py deleted file mode 100644 index c5d66048..00000000 --- a/src/supermemory/types/shared/or_.py +++ /dev/null @@ -1,15 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List - -from pydantic import Field as FieldInfo - -from ..._models import BaseModel - -__all__ = ["Or"] - - -class Or(BaseModel): - """OR""" - - or_: List[object] = FieldInfo(alias="OR") diff --git a/src/supermemory/types/shared_params/__init__.py b/src/supermemory/types/shared_params/__init__.py deleted file mode 100644 index 96ecf13e..00000000 --- a/src/supermemory/types/shared_params/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .or_ import Or as Or -from .and_ import And as And diff --git a/src/supermemory/types/shared_params/and_.py b/src/supermemory/types/shared_params/and_.py deleted file mode 100644 index 45dc92d8..00000000 --- a/src/supermemory/types/shared_params/and_.py +++ /dev/null @@ -1,16 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Iterable -from typing_extensions import Required, Annotated, TypedDict - -from ..._utils import PropertyInfo - -__all__ = ["And"] - - -class And(TypedDict, total=False): - """AND""" - - and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] diff --git a/src/supermemory/types/shared_params/or_.py b/src/supermemory/types/shared_params/or_.py deleted file mode 100644 index 448bddc0..00000000 --- a/src/supermemory/types/shared_params/or_.py +++ /dev/null @@ -1,16 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Iterable -from typing_extensions import Required, Annotated, TypedDict - -from ..._utils import PropertyInfo - -__all__ = ["Or"] - - -class Or(TypedDict, total=False): - """OR""" - - or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] diff --git a/tests/api_resources/test_documents.py b/tests/api_resources/test_documents.py index 925bf10f..f18f5ee1 100644 --- a/tests/api_resources/test_documents.py +++ b/tests/api_resources/test_documents.py @@ -102,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": ">", }, ] }, @@ -537,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": ">", }, ] }, diff --git a/tests/api_resources/test_memories.py b/tests/api_resources/test_memories.py index 908ba97a..e6f2a418 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 36860eaa..8352797e 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, From be8efa6ea1c7fdb58428741e7938540e266cbdc2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 01:50:32 +0000 Subject: [PATCH 06/10] feat(api): manual updates --- .stats.yml | 6 +- src/supermemory/types/document_list_params.py | 3797 +--------------- src/supermemory/types/memory_list_params.py | 3797 +--------------- .../types/search_documents_params.py | 3799 +--------------- .../types/search_execute_params.py | 3799 +--------------- .../types/search_memories_params.py | 3800 +---------------- tests/api_resources/test_documents.py | 26 +- tests/api_resources/test_memories.py | 26 +- tests/api_resources/test_search.py | 78 +- 9 files changed, 67 insertions(+), 19061 deletions(-) diff --git a/.stats.yml b/.stats.yml index 35905d06..b4dee28f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ 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: 87b9e108ccf7a61dbda94437747a84be +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-3856961a8959b60dbf0b6912d69c23390fbbca1c5e31028dd0decc85234dd285.yml +openapi_spec_hash: 988a7d6d7cef81ceb4acda3ef9f8c21e +config_hash: dafc28a817aebd9b00b3851c3c6ead1d diff --git a/src/supermemory/types/document_list_params.py b/src/supermemory/types/document_list_params.py index d37a0e39..c3aab05b 100644 --- a/src/supermemory/types/document_list_params.py +++ b/src/supermemory/types/document_list_params.py @@ -8,324 +8,7 @@ from .._types import SequenceNotStr from .._utils import PropertyInfo -__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", -] +__all__ = ["DocumentListParams", "Filters", "FiltersOr", "FiltersAnd"] class DocumentListParams(TypedDict, total=False): @@ -358,3482 +41,16 @@ 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_: 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] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - 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] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_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""" - +class FiltersOr(TypedDict, total=False): + """OR""" -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] + or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] class FiltersAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] - """Array of AND filter expressions""" + """AND""" + + and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/src/supermemory/types/memory_list_params.py b/src/supermemory/types/memory_list_params.py index 2e2cb575..31ac58f4 100644 --- a/src/supermemory/types/memory_list_params.py +++ b/src/supermemory/types/memory_list_params.py @@ -8,324 +8,7 @@ from .._types import SequenceNotStr from .._utils import PropertyInfo -__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", -] +__all__ = ["MemoryListParams", "Filters", "FiltersOr", "FiltersAnd"] class MemoryListParams(TypedDict, total=False): @@ -358,3482 +41,16 @@ 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_: 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] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - 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] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_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""" - +class FiltersOr(TypedDict, total=False): + """OR""" -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] + or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] class FiltersAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] - """Array of AND filter expressions""" + """AND""" + + and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/src/supermemory/types/search_documents_params.py b/src/supermemory/types/search_documents_params.py index 87c235d2..441ce04e 100644 --- a/src/supermemory/types/search_documents_params.py +++ b/src/supermemory/types/search_documents_params.py @@ -3,329 +3,12 @@ from __future__ import annotations from typing import Union, Iterable -from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict +from typing_extensions import Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -__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", -] +__all__ = ["SearchDocumentsParams", "Filters", "FiltersOr", "FiltersAnd"] class SearchDocumentsParams(TypedDict, total=False): @@ -399,3482 +82,16 @@ 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_: 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] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - 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] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_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""" - +class FiltersOr(TypedDict, total=False): + """OR""" -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] + or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] class FiltersAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] - """Array of AND filter expressions""" + """AND""" + + and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/src/supermemory/types/search_execute_params.py b/src/supermemory/types/search_execute_params.py index 56121a3e..0a1290a6 100644 --- a/src/supermemory/types/search_execute_params.py +++ b/src/supermemory/types/search_execute_params.py @@ -3,329 +3,12 @@ from __future__ import annotations from typing import Union, Iterable -from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict +from typing_extensions import Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -__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", -] +__all__ = ["SearchExecuteParams", "Filters", "FiltersOr", "FiltersAnd"] class SearchExecuteParams(TypedDict, total=False): @@ -399,3482 +82,16 @@ 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_: 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] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - 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] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_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""" - +class FiltersOr(TypedDict, total=False): + """OR""" -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] + or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] class FiltersAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] - """Array of AND filter expressions""" + """AND""" + + and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/src/supermemory/types/search_memories_params.py b/src/supermemory/types/search_memories_params.py index e5bb7baf..1d5320b2 100644 --- a/src/supermemory/types/search_memories_params.py +++ b/src/supermemory/types/search_memories_params.py @@ -3,329 +3,11 @@ from __future__ import annotations from typing import Union, Iterable -from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict +from typing_extensions import Required, Annotated, TypeAlias, TypedDict from .._utils import PropertyInfo -__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", -] +__all__ = ["SearchMemoriesParams", "Filters", "FiltersOr", "FiltersAnd", "Include"] class SearchMemoriesParams(TypedDict, total=False): @@ -367,3482 +49,16 @@ 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_: 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] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - 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] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_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""" - +class FiltersOr(TypedDict, total=False): + """OR""" -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] + or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] class FiltersAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] - """Array of AND filter expressions""" + """AND""" + + and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/tests/api_resources/test_documents.py b/tests/api_resources/test_documents.py index f18f5ee1..925bf10f 100644 --- a/tests/api_resources/test_documents.py +++ b/tests/api_resources/test_documents.py @@ -102,20 +102,17 @@ def test_method_list_with_all_params(self, client: Supermemory) -> None: filters={ "and_": [ { + "filterType": "metadata", "key": "group", - "value": "jira_users", - "filter_type": "metadata", - "ignore_case": True, "negate": False, - "numeric_operator": ">", + "value": "jira_users", }, { + "filterType": "numeric", "key": "timestamp", - "value": "1742745777", - "filter_type": "numeric", - "ignore_case": True, "negate": False, - "numeric_operator": ">", + "numericOperator": ">", + "value": "1742745777", }, ] }, @@ -540,20 +537,17 @@ async def test_method_list_with_all_params(self, async_client: AsyncSupermemory) filters={ "and_": [ { + "filterType": "metadata", "key": "group", - "value": "jira_users", - "filter_type": "metadata", - "ignore_case": True, "negate": False, - "numeric_operator": ">", + "value": "jira_users", }, { + "filterType": "numeric", "key": "timestamp", - "value": "1742745777", - "filter_type": "numeric", - "ignore_case": True, "negate": False, - "numeric_operator": ">", + "numericOperator": ">", + "value": "1742745777", }, ] }, diff --git a/tests/api_resources/test_memories.py b/tests/api_resources/test_memories.py index e6f2a418..908ba97a 100644 --- a/tests/api_resources/test_memories.py +++ b/tests/api_resources/test_memories.py @@ -101,20 +101,17 @@ def test_method_list_with_all_params(self, client: Supermemory) -> None: filters={ "and_": [ { + "filterType": "metadata", "key": "group", - "value": "jira_users", - "filter_type": "metadata", - "ignore_case": True, "negate": False, - "numeric_operator": ">", + "value": "jira_users", }, { + "filterType": "numeric", "key": "timestamp", - "value": "1742745777", - "filter_type": "numeric", - "ignore_case": True, "negate": False, - "numeric_operator": ">", + "numericOperator": ">", + "value": "1742745777", }, ] }, @@ -500,20 +497,17 @@ async def test_method_list_with_all_params(self, async_client: AsyncSupermemory) filters={ "and_": [ { + "filterType": "metadata", "key": "group", - "value": "jira_users", - "filter_type": "metadata", - "ignore_case": True, "negate": False, - "numeric_operator": ">", + "value": "jira_users", }, { + "filterType": "numeric", "key": "timestamp", - "value": "1742745777", - "filter_type": "numeric", - "ignore_case": True, "negate": False, - "numeric_operator": ">", + "numericOperator": ">", + "value": "1742745777", }, ] }, diff --git a/tests/api_resources/test_search.py b/tests/api_resources/test_search.py index 8352797e..36860eaa 100644 --- a/tests/api_resources/test_search.py +++ b/tests/api_resources/test_search.py @@ -39,18 +39,7 @@ def test_method_documents_with_all_params(self, client: Supermemory) -> None: container_tags=["user_123"], doc_id="docId", document_threshold=0, - filters={ - "or_": [ - { - "key": "key", - "value": "value", - "filter_type": "metadata", - "ignore_case": True, - "negate": True, - "numeric_operator": ">", - } - ] - }, + filters={"or_": [{}]}, include_full_docs=False, include_summary=True, limit=10, @@ -104,18 +93,7 @@ def test_method_execute_with_all_params(self, client: Supermemory) -> None: container_tags=["user_123"], doc_id="docId", document_threshold=0, - filters={ - "or_": [ - { - "key": "key", - "value": "value", - "filter_type": "metadata", - "ignore_case": True, - "negate": True, - "numeric_operator": ">", - } - ] - }, + filters={"or_": [{}]}, include_full_docs=False, include_summary=True, limit=10, @@ -165,18 +143,7 @@ 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_": [ - { - "key": "key", - "value": "value", - "filter_type": "metadata", - "ignore_case": True, - "negate": True, - "numeric_operator": ">", - } - ] - }, + filters={"or_": [{}]}, include={ "chunks": False, "documents": True, @@ -241,18 +208,7 @@ async def test_method_documents_with_all_params(self, async_client: AsyncSuperme container_tags=["user_123"], doc_id="docId", document_threshold=0, - filters={ - "or_": [ - { - "key": "key", - "value": "value", - "filter_type": "metadata", - "ignore_case": True, - "negate": True, - "numeric_operator": ">", - } - ] - }, + filters={"or_": [{}]}, include_full_docs=False, include_summary=True, limit=10, @@ -306,18 +262,7 @@ async def test_method_execute_with_all_params(self, async_client: AsyncSupermemo container_tags=["user_123"], doc_id="docId", document_threshold=0, - filters={ - "or_": [ - { - "key": "key", - "value": "value", - "filter_type": "metadata", - "ignore_case": True, - "negate": True, - "numeric_operator": ">", - } - ] - }, + filters={"or_": [{}]}, include_full_docs=False, include_summary=True, limit=10, @@ -367,18 +312,7 @@ 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_": [ - { - "key": "key", - "value": "value", - "filter_type": "metadata", - "ignore_case": True, - "negate": True, - "numeric_operator": ">", - } - ] - }, + filters={"or_": [{}]}, include={ "chunks": False, "documents": True, From 3691dfd45b9c8c15e8d318adc4b79e8c8ae9ed27 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 01:52:40 +0000 Subject: [PATCH 07/10] feat(api): manual updates --- .stats.yml | 2 +- api.md | 6 +++++ src/supermemory/types/__init__.py | 1 + src/supermemory/types/document_list_params.py | 22 +++++-------------- src/supermemory/types/memory_list_params.py | 22 +++++-------------- .../types/search_documents_params.py | 20 +++++------------ .../types/search_execute_params.py | 20 +++++------------ .../types/search_memories_params.py | 20 +++++------------ src/supermemory/types/shared/__init__.py | 4 ++++ src/supermemory/types/shared/and_.py | 15 +++++++++++++ src/supermemory/types/shared/or_.py | 15 +++++++++++++ .../types/shared_params/__init__.py | 4 ++++ src/supermemory/types/shared_params/and_.py | 16 ++++++++++++++ src/supermemory/types/shared_params/or_.py | 16 ++++++++++++++ 14 files changed, 105 insertions(+), 78 deletions(-) create mode 100644 src/supermemory/types/shared/__init__.py create mode 100644 src/supermemory/types/shared/and_.py create mode 100644 src/supermemory/types/shared/or_.py create mode 100644 src/supermemory/types/shared_params/__init__.py create mode 100644 src/supermemory/types/shared_params/and_.py create mode 100644 src/supermemory/types/shared_params/or_.py diff --git a/.stats.yml b/.stats.yml index b4dee28f..ddec73c6 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 26 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-3856961a8959b60dbf0b6912d69c23390fbbca1c5e31028dd0decc85234dd285.yml openapi_spec_hash: 988a7d6d7cef81ceb4acda3ef9f8c21e -config_hash: dafc28a817aebd9b00b3851c3c6ead1d +config_hash: 3a51c51e3bf444bb4ea2421715e214d6 diff --git a/api.md b/api.md index 84da60ef..35f3c7fa 100644 --- a/api.md +++ b/api.md @@ -1,3 +1,9 @@ +# Shared Types + +```python +from supermemory.types import And, Or +``` + # Supermemory Types: diff --git a/src/supermemory/types/__init__.py b/src/supermemory/types/__init__.py index 0cdef254..70e24362 100644 --- a/src/supermemory/types/__init__.py +++ b/src/supermemory/types/__init__.py @@ -2,6 +2,7 @@ from __future__ import annotations +from .shared import Or as Or, And as And from .add_response import AddResponse as AddResponse from .profile_response import ProfileResponse as ProfileResponse from .client_add_params import ClientAddParams as ClientAddParams diff --git a/src/supermemory/types/document_list_params.py b/src/supermemory/types/document_list_params.py index c3aab05b..f48c76f1 100644 --- a/src/supermemory/types/document_list_params.py +++ b/src/supermemory/types/document_list_params.py @@ -2,13 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable -from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict +from typing import Union +from typing_extensions import Literal, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["DocumentListParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = ["DocumentListParams", "Filters"] class DocumentListParams(TypedDict, total=False): @@ -41,16 +43,4 @@ class DocumentListParams(TypedDict, total=False): """Field to sort by""" -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] +Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/memory_list_params.py b/src/supermemory/types/memory_list_params.py index 31ac58f4..07eb8d9a 100644 --- a/src/supermemory/types/memory_list_params.py +++ b/src/supermemory/types/memory_list_params.py @@ -2,13 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable -from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict +from typing import Union +from typing_extensions import Literal, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["MemoryListParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = ["MemoryListParams", "Filters"] class MemoryListParams(TypedDict, total=False): @@ -41,16 +43,4 @@ class MemoryListParams(TypedDict, total=False): """Field to sort by""" -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] +Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/search_documents_params.py b/src/supermemory/types/search_documents_params.py index 441ce04e..20f62b3c 100644 --- a/src/supermemory/types/search_documents_params.py +++ b/src/supermemory/types/search_documents_params.py @@ -2,13 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable +from typing import Union from typing_extensions import Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["SearchDocumentsParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = ["SearchDocumentsParams", "Filters"] class SearchDocumentsParams(TypedDict, total=False): @@ -82,16 +84,4 @@ class SearchDocumentsParams(TypedDict, total=False): """ -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] +Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/search_execute_params.py b/src/supermemory/types/search_execute_params.py index 0a1290a6..da786065 100644 --- a/src/supermemory/types/search_execute_params.py +++ b/src/supermemory/types/search_execute_params.py @@ -2,13 +2,15 @@ from __future__ import annotations -from typing import Union, Iterable +from typing import Union from typing_extensions import Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["SearchExecuteParams", "Filters", "FiltersOr", "FiltersAnd"] +__all__ = ["SearchExecuteParams", "Filters"] class SearchExecuteParams(TypedDict, total=False): @@ -82,16 +84,4 @@ class SearchExecuteParams(TypedDict, total=False): """ -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] +Filters: TypeAlias = Union[Or, And] diff --git a/src/supermemory/types/search_memories_params.py b/src/supermemory/types/search_memories_params.py index 1d5320b2..7d3bd45b 100644 --- a/src/supermemory/types/search_memories_params.py +++ b/src/supermemory/types/search_memories_params.py @@ -2,12 +2,14 @@ from __future__ import annotations -from typing import Union, Iterable +from typing import Union from typing_extensions import Required, Annotated, TypeAlias, TypedDict from .._utils import PropertyInfo +from .shared_params.or_ import Or +from .shared_params.and_ import And -__all__ = ["SearchMemoriesParams", "Filters", "FiltersOr", "FiltersAnd", "Include"] +__all__ = ["SearchMemoriesParams", "Filters", "Include"] class SearchMemoriesParams(TypedDict, total=False): @@ -49,19 +51,7 @@ class SearchMemoriesParams(TypedDict, total=False): """ -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] +Filters: TypeAlias = Union[Or, And] class Include(TypedDict, total=False): diff --git a/src/supermemory/types/shared/__init__.py b/src/supermemory/types/shared/__init__.py new file mode 100644 index 00000000..96ecf13e --- /dev/null +++ b/src/supermemory/types/shared/__init__.py @@ -0,0 +1,4 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .or_ import Or as Or +from .and_ import And as And diff --git a/src/supermemory/types/shared/and_.py b/src/supermemory/types/shared/and_.py new file mode 100644 index 00000000..1f41863a --- /dev/null +++ b/src/supermemory/types/shared/and_.py @@ -0,0 +1,15 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["And"] + + +class And(BaseModel): + """AND""" + + and_: List[object] = FieldInfo(alias="AND") diff --git a/src/supermemory/types/shared/or_.py b/src/supermemory/types/shared/or_.py new file mode 100644 index 00000000..c5d66048 --- /dev/null +++ b/src/supermemory/types/shared/or_.py @@ -0,0 +1,15 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["Or"] + + +class Or(BaseModel): + """OR""" + + or_: List[object] = FieldInfo(alias="OR") diff --git a/src/supermemory/types/shared_params/__init__.py b/src/supermemory/types/shared_params/__init__.py new file mode 100644 index 00000000..96ecf13e --- /dev/null +++ b/src/supermemory/types/shared_params/__init__.py @@ -0,0 +1,4 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .or_ import Or as Or +from .and_ import And as And diff --git a/src/supermemory/types/shared_params/and_.py b/src/supermemory/types/shared_params/and_.py new file mode 100644 index 00000000..45dc92d8 --- /dev/null +++ b/src/supermemory/types/shared_params/and_.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Iterable +from typing_extensions import Required, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["And"] + + +class And(TypedDict, total=False): + """AND""" + + and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] diff --git a/src/supermemory/types/shared_params/or_.py b/src/supermemory/types/shared_params/or_.py new file mode 100644 index 00000000..448bddc0 --- /dev/null +++ b/src/supermemory/types/shared_params/or_.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Iterable +from typing_extensions import Required, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["Or"] + + +class Or(TypedDict, total=False): + """OR""" + + or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] From 4b3045968d0fccd106e87a1aa3f4c7c49a1475fe Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 02:21:50 +0000 Subject: [PATCH 08/10] feat(api): api update --- .stats.yml | 4 +- api.md | 6 - src/supermemory/types/__init__.py | 1 - src/supermemory/types/document_list_params.py | 3805 +++++++++++++++- src/supermemory/types/memory_list_params.py | 3805 +++++++++++++++- .../types/search_documents_params.py | 3805 +++++++++++++++- .../types/search_execute_params.py | 3805 +++++++++++++++- .../types/search_memories_params.py | 3806 ++++++++++++++++- src/supermemory/types/shared/__init__.py | 4 - src/supermemory/types/shared/and_.py | 15 - src/supermemory/types/shared/or_.py | 15 - .../types/shared_params/__init__.py | 4 - src/supermemory/types/shared_params/and_.py | 16 - src/supermemory/types/shared_params/or_.py | 16 - tests/api_resources/test_documents.py | 26 +- tests/api_resources/test_memories.py | 26 +- tests/api_resources/test_search.py | 78 +- 17 files changed, 19102 insertions(+), 135 deletions(-) delete mode 100644 src/supermemory/types/shared/__init__.py delete mode 100644 src/supermemory/types/shared/and_.py delete mode 100644 src/supermemory/types/shared/or_.py delete mode 100644 src/supermemory/types/shared_params/__init__.py delete mode 100644 src/supermemory/types/shared_params/and_.py delete mode 100644 src/supermemory/types/shared_params/or_.py diff --git a/.stats.yml b/.stats.yml index ddec73c6..f3fa0ecd 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 26 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-3856961a8959b60dbf0b6912d69c23390fbbca1c5e31028dd0decc85234dd285.yml -openapi_spec_hash: 988a7d6d7cef81ceb4acda3ef9f8c21e +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-c42d5f3942d6e32b6d1ed95d40bf6cca87aa8c715343444b97e0c68d44646878.yml +openapi_spec_hash: 952074229d1f810fe95aeee711db8ca4 config_hash: 3a51c51e3bf444bb4ea2421715e214d6 diff --git a/api.md b/api.md index 35f3c7fa..84da60ef 100644 --- a/api.md +++ b/api.md @@ -1,9 +1,3 @@ -# Shared Types - -```python -from supermemory.types import And, Or -``` - # Supermemory Types: diff --git a/src/supermemory/types/__init__.py b/src/supermemory/types/__init__.py index 70e24362..0cdef254 100644 --- a/src/supermemory/types/__init__.py +++ b/src/supermemory/types/__init__.py @@ -2,7 +2,6 @@ from __future__ import annotations -from .shared import Or as Or, And as And from .add_response import AddResponse as AddResponse from .profile_response import ProfileResponse as ProfileResponse from .client_add_params import ClientAddParams as ClientAddParams diff --git a/src/supermemory/types/document_list_params.py b/src/supermemory/types/document_list_params.py index f48c76f1..d37a0e39 100644 --- a/src/supermemory/types/document_list_params.py +++ b/src/supermemory/types/document_list_params.py @@ -2,15 +2,330 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Literal, Annotated, TypeAlias, TypedDict +from typing import Union, Iterable +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And -__all__ = ["DocumentListParams", "Filters"] +__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): @@ -43,4 +358,3482 @@ class DocumentListParams(TypedDict, total=False): """Field to sort by""" -Filters: TypeAlias = Union[Or, And] +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_: 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_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/memory_list_params.py b/src/supermemory/types/memory_list_params.py index 07eb8d9a..2e2cb575 100644 --- a/src/supermemory/types/memory_list_params.py +++ b/src/supermemory/types/memory_list_params.py @@ -2,15 +2,330 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Literal, Annotated, TypeAlias, TypedDict +from typing import Union, Iterable +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And -__all__ = ["MemoryListParams", "Filters"] +__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): @@ -43,4 +358,3482 @@ class MemoryListParams(TypedDict, total=False): """Field to sort by""" -Filters: TypeAlias = Union[Or, And] +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_: 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_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 20f62b3c..87c235d2 100644 --- a/src/supermemory/types/search_documents_params.py +++ b/src/supermemory/types/search_documents_params.py @@ -2,15 +2,330 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Required, Annotated, TypeAlias, TypedDict +from typing import Union, Iterable +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And -__all__ = ["SearchDocumentsParams", "Filters"] +__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): @@ -84,4 +399,3482 @@ class SearchDocumentsParams(TypedDict, total=False): """ -Filters: TypeAlias = Union[Or, And] +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_: 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_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 da786065..56121a3e 100644 --- a/src/supermemory/types/search_execute_params.py +++ b/src/supermemory/types/search_execute_params.py @@ -2,15 +2,330 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Required, Annotated, TypeAlias, TypedDict +from typing import Union, Iterable +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And -__all__ = ["SearchExecuteParams", "Filters"] +__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): @@ -84,4 +399,3482 @@ class SearchExecuteParams(TypedDict, total=False): """ -Filters: TypeAlias = Union[Or, And] +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_: 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_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 7d3bd45b..e5bb7baf 100644 --- a/src/supermemory/types/search_memories_params.py +++ b/src/supermemory/types/search_memories_params.py @@ -2,14 +2,330 @@ from __future__ import annotations -from typing import Union -from typing_extensions import Required, Annotated, TypeAlias, TypedDict +from typing import Union, Iterable +from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._utils import PropertyInfo -from .shared_params.or_ import Or -from .shared_params.and_ import And -__all__ = ["SearchMemoriesParams", "Filters", "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): @@ -51,7 +367,3485 @@ class SearchMemoriesParams(TypedDict, total=False): """ -Filters: TypeAlias = Union[Or, And] +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_: 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] + + 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] + + filter_type: Annotated[ + Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") + ] + + ignore_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] class Include(TypedDict, total=False): diff --git a/src/supermemory/types/shared/__init__.py b/src/supermemory/types/shared/__init__.py deleted file mode 100644 index 96ecf13e..00000000 --- a/src/supermemory/types/shared/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .or_ import Or as Or -from .and_ import And as And diff --git a/src/supermemory/types/shared/and_.py b/src/supermemory/types/shared/and_.py deleted file mode 100644 index 1f41863a..00000000 --- a/src/supermemory/types/shared/and_.py +++ /dev/null @@ -1,15 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List - -from pydantic import Field as FieldInfo - -from ..._models import BaseModel - -__all__ = ["And"] - - -class And(BaseModel): - """AND""" - - and_: List[object] = FieldInfo(alias="AND") diff --git a/src/supermemory/types/shared/or_.py b/src/supermemory/types/shared/or_.py deleted file mode 100644 index c5d66048..00000000 --- a/src/supermemory/types/shared/or_.py +++ /dev/null @@ -1,15 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List - -from pydantic import Field as FieldInfo - -from ..._models import BaseModel - -__all__ = ["Or"] - - -class Or(BaseModel): - """OR""" - - or_: List[object] = FieldInfo(alias="OR") diff --git a/src/supermemory/types/shared_params/__init__.py b/src/supermemory/types/shared_params/__init__.py deleted file mode 100644 index 96ecf13e..00000000 --- a/src/supermemory/types/shared_params/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .or_ import Or as Or -from .and_ import And as And diff --git a/src/supermemory/types/shared_params/and_.py b/src/supermemory/types/shared_params/and_.py deleted file mode 100644 index 45dc92d8..00000000 --- a/src/supermemory/types/shared_params/and_.py +++ /dev/null @@ -1,16 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Iterable -from typing_extensions import Required, Annotated, TypedDict - -from ..._utils import PropertyInfo - -__all__ = ["And"] - - -class And(TypedDict, total=False): - """AND""" - - and_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] diff --git a/src/supermemory/types/shared_params/or_.py b/src/supermemory/types/shared_params/or_.py deleted file mode 100644 index 448bddc0..00000000 --- a/src/supermemory/types/shared_params/or_.py +++ /dev/null @@ -1,16 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Iterable -from typing_extensions import Required, Annotated, TypedDict - -from ..._utils import PropertyInfo - -__all__ = ["Or"] - - -class Or(TypedDict, total=False): - """OR""" - - or_: Required[Annotated[Iterable[object], PropertyInfo(alias="OR")]] diff --git a/tests/api_resources/test_documents.py b/tests/api_resources/test_documents.py index 925bf10f..f18f5ee1 100644 --- a/tests/api_resources/test_documents.py +++ b/tests/api_resources/test_documents.py @@ -102,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": ">", }, ] }, @@ -537,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": ">", }, ] }, diff --git a/tests/api_resources/test_memories.py b/tests/api_resources/test_memories.py index 908ba97a..e6f2a418 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 36860eaa..8352797e 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, From d36e8cf12d13870b8f9a31c7581f62590511336b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 03:18:31 +0000 Subject: [PATCH 09/10] codegen metadata --- .stats.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.stats.yml b/.stats.yml index f3fa0ecd..927f4f31 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ 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: 3a51c51e3bf444bb4ea2421715e214d6 +config_hash: fc55f26858b03415a5838ec2731c1cc3 From 0ba4037690cea158c246a9fb26bf33e484323678 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 10 Dec 2025 03:18:47 +0000 Subject: [PATCH 10/10] release: 3.10.0 --- .release-please-manifest.json | 2 +- CHANGELOG.md | 15 +++++++++++++++ pyproject.toml | 2 +- src/supermemory/_version.py | 2 +- 4 files changed, 18 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 9127b1bd..25709d1b 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/CHANGELOG.md b/CHANGELOG.md index b2e591b1..388705dc 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/pyproject.toml b/pyproject.toml index 8cf16414..7b1807b2 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/_version.py b/src/supermemory/_version.py index 8afdf66f..e8b946f7 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