diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 22674f5..e5a7023 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "3.56.0" + ".": "3.57.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index e4a02d5..687bfb0 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/supermemory-new-25331f39259c2fda7a617655e01098b23d57e32d668de083fec03546689caa19.yml -openapi_spec_hash: 3a56514128e9dbe7307d7adf338afbe5 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc/supermemory-new-22efc23f9b6792eb4ce96106f7c227a36c008feca20df430490c7b6cb145a703.yml +openapi_spec_hash: f66075689686f6f24a7cb4e47dcffebd config_hash: cde97ef3188581c5f4924c633ec33ddb diff --git a/CHANGELOG.md b/CHANGELOG.md index 94d0c17..db9ca51 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 3.57.0 (2026-08-11) + +Full Changelog: [v3.56.0...v3.57.0](https://github.com/supermemoryai/python-sdk/compare/v3.56.0...v3.57.0) + +### Features + +* **api:** api update ([307c6ac](https://github.com/supermemoryai/python-sdk/commit/307c6ac6f115b9fac6ef7aaa70416e387cabf8e7)) + ## 3.56.0 (2026-07-24) Full Changelog: [v3.55.0...v3.56.0](https://github.com/supermemoryai/python-sdk/compare/v3.55.0...v3.56.0) diff --git a/pyproject.toml b/pyproject.toml index 31a9065..c351de9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "supermemory" -version = "3.56.0" +version = "3.57.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 535e778..c952219 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.56.0" # x-release-please-version +__version__ = "3.57.0" # x-release-please-version diff --git a/src/supermemory/types/client_profile_params.py b/src/supermemory/types/client_profile_params.py index 5e9f03b..93488e7 100644 --- a/src/supermemory/types/client_profile_params.py +++ b/src/supermemory/types/client_profile_params.py @@ -13,318 +13,14 @@ "Filters", "FiltersOr", "FiltersOrOr", - "FiltersOrOrUnionMember0", + "FiltersOrOrFilterCondition", "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", + "FiltersAndAndFilterCondition", "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", ] @@ -365,7 +61,7 @@ class ClientProfileParams(TypedDict, total=False): """ -class FiltersOrOrUnionMember0(TypedDict, total=False): +class FiltersOrOrFilterCondition(TypedDict, total=False): """ A single filter condition based on metadata, numeric values, array contents, or string matching """ @@ -385,3310 +81,25 @@ class FiltersOrOrUnionMember0(TypedDict, total=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")]] +class FiltersOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[object], 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")]] +class FiltersOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[object], 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")] +FiltersOrOr: TypeAlias = Union[FiltersOrOrFilterCondition, FiltersOrOrOr, FiltersOrOrAnd] -class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" +class FiltersOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] + """Array of OR filter expressions""" -class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): +class FiltersAndAndFilterCondition(TypedDict, total=False): """ A single filter condition based on metadata, numeric values, array contents, or string matching """ @@ -3708,134 +119,17 @@ class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=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")]] +class FiltersAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[object], 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_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] """AND: Array of conditions or nested expressions""" -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] +FiltersAndAnd: TypeAlias = Union[FiltersAndAndFilterCondition, FiltersAndAndOr, FiltersAndAndAnd] class FiltersAnd(TypedDict, total=False): diff --git a/src/supermemory/types/document_get_response.py b/src/supermemory/types/document_get_response.py index d313ff3..287a325 100644 --- a/src/supermemory/types/document_get_response.py +++ b/src/supermemory/types/document_get_response.py @@ -7,12 +7,40 @@ from .._models import BaseModel -__all__ = ["DocumentGetResponse"] +__all__ = ["DocumentGetResponse", "Memory"] -class DocumentGetResponse(BaseModel): - """Document object""" +class Memory(BaseModel): + id: str + + created_at: str = FieldInfo(alias="createdAt") + """Creation timestamp""" + + is_forgotten: bool = FieldInfo(alias="isForgotten") + + is_inference: bool = FieldInfo(alias="isInference") + + is_latest: bool = FieldInfo(alias="isLatest") + + is_static: bool = FieldInfo(alias="isStatic") + + memory: str + + metadata: Union[str, float, bool, Dict[str, object], List[object], None] = None + parent_memory_id: Optional[str] = FieldInfo(alias="parentMemoryId", default=None) + + root_memory_id: Optional[str] = FieldInfo(alias="rootMemoryId", default=None) + + source_count: int = FieldInfo(alias="sourceCount") + + updated_at: Optional[str] = FieldInfo(alias="updatedAt", default=None) + """Last update timestamp""" + + version: int + + +class DocumentGetResponse(BaseModel): id: str """Unique identifier of the document.""" @@ -108,5 +136,11 @@ class DocumentGetResponse(BaseModel): to use to group documents. """ + memories: Optional[List[Memory]] = None + """Memories extracted from this document. + + Omitted when the document has no memories (e.g. still processing). + """ + url: Optional[str] = None """URL of the document""" diff --git a/src/supermemory/types/document_list_params.py b/src/supermemory/types/document_list_params.py index 11bd957..ff720ed 100644 --- a/src/supermemory/types/document_list_params.py +++ b/src/supermemory/types/document_list_params.py @@ -13,318 +13,14 @@ "Filters", "FiltersOr", "FiltersOrOr", - "FiltersOrOrUnionMember0", + "FiltersOrOrFilterCondition", "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", + "FiltersAndAndFilterCondition", "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", ] @@ -364,7 +60,7 @@ class DocumentListParams(TypedDict, total=False): """Field to sort by""" -class FiltersOrOrUnionMember0(TypedDict, total=False): +class FiltersOrOrFilterCondition(TypedDict, total=False): """ A single filter condition based on metadata, numeric values, array contents, or string matching """ @@ -384,3310 +80,25 @@ class FiltersOrOrUnionMember0(TypedDict, total=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")]] +class FiltersOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[object], 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")]] +class FiltersOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[object], 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")] +FiltersOrOr: TypeAlias = Union[FiltersOrOrFilterCondition, FiltersOrOrOr, FiltersOrOrAnd] -class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" +class FiltersOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] + """Array of OR filter expressions""" -class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): +class FiltersAndAndFilterCondition(TypedDict, total=False): """ A single filter condition based on metadata, numeric values, array contents, or string matching """ @@ -3707,134 +118,17 @@ class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=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")]] +class FiltersAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[object], 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_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] """AND: Array of conditions or nested expressions""" -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] +FiltersAndAnd: TypeAlias = Union[FiltersAndAndFilterCondition, FiltersAndAndOr, FiltersAndAndAnd] class FiltersAnd(TypedDict, total=False): diff --git a/src/supermemory/types/search_documents_params.py b/src/supermemory/types/search_documents_params.py index 2f68805..6d76041 100644 --- a/src/supermemory/types/search_documents_params.py +++ b/src/supermemory/types/search_documents_params.py @@ -13,318 +13,14 @@ "Filters", "FiltersOr", "FiltersOrOr", - "FiltersOrOrUnionMember0", + "FiltersOrOrFilterCondition", "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", + "FiltersAndAndFilterCondition", "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", ] @@ -408,7 +104,7 @@ class SearchDocumentsParams(TypedDict, total=False): """ -class FiltersOrOrUnionMember0(TypedDict, total=False): +class FiltersOrOrFilterCondition(TypedDict, total=False): """ A single filter condition based on metadata, numeric values, array contents, or string matching """ @@ -428,3310 +124,25 @@ class FiltersOrOrUnionMember0(TypedDict, total=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")]] +class FiltersOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[object], 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")]] +class FiltersOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[object], 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")] +FiltersOrOr: TypeAlias = Union[FiltersOrOrFilterCondition, FiltersOrOrOr, FiltersOrOrAnd] -class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" +class FiltersOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] + """Array of OR filter expressions""" -class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): +class FiltersAndAndFilterCondition(TypedDict, total=False): """ A single filter condition based on metadata, numeric values, array contents, or string matching """ @@ -3751,134 +162,17 @@ class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=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")]] +class FiltersAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[object], 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_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] """AND: Array of conditions or nested expressions""" -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] +FiltersAndAnd: TypeAlias = Union[FiltersAndAndFilterCondition, FiltersAndAndOr, FiltersAndAndAnd] class FiltersAnd(TypedDict, total=False): diff --git a/src/supermemory/types/search_execute_params.py b/src/supermemory/types/search_execute_params.py index 9660a3f..20c85d2 100644 --- a/src/supermemory/types/search_execute_params.py +++ b/src/supermemory/types/search_execute_params.py @@ -13,318 +13,14 @@ "Filters", "FiltersOr", "FiltersOrOr", - "FiltersOrOrUnionMember0", + "FiltersOrOrFilterCondition", "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", + "FiltersAndAndFilterCondition", "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", ] @@ -408,7 +104,7 @@ class SearchExecuteParams(TypedDict, total=False): """ -class FiltersOrOrUnionMember0(TypedDict, total=False): +class FiltersOrOrFilterCondition(TypedDict, total=False): """ A single filter condition based on metadata, numeric values, array contents, or string matching """ @@ -428,3310 +124,25 @@ class FiltersOrOrUnionMember0(TypedDict, total=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")]] +class FiltersOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[object], 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")]] +class FiltersOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[object], 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")] +FiltersOrOr: TypeAlias = Union[FiltersOrOrFilterCondition, FiltersOrOrOr, FiltersOrOrAnd] -class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" +class FiltersOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] + """Array of OR filter expressions""" -class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): +class FiltersAndAndFilterCondition(TypedDict, total=False): """ A single filter condition based on metadata, numeric values, array contents, or string matching """ @@ -3751,134 +162,17 @@ class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=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")]] +class FiltersAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[object], 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_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] """AND: Array of conditions or nested expressions""" -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] +FiltersAndAnd: TypeAlias = Union[FiltersAndAndFilterCondition, FiltersAndAndOr, FiltersAndAndAnd] class FiltersAnd(TypedDict, total=False): diff --git a/src/supermemory/types/search_memories_params.py b/src/supermemory/types/search_memories_params.py index 3ead4d1..0e1b4a4 100644 --- a/src/supermemory/types/search_memories_params.py +++ b/src/supermemory/types/search_memories_params.py @@ -13,318 +13,14 @@ "Filters", "FiltersOr", "FiltersOrOr", - "FiltersOrOrUnionMember0", + "FiltersOrOrFilterCondition", "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", + "FiltersAndAndFilterCondition", "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", ] @@ -394,7 +90,7 @@ class SearchMemoriesParams(TypedDict, total=False): """ -class FiltersOrOrUnionMember0(TypedDict, total=False): +class FiltersOrOrFilterCondition(TypedDict, total=False): """ A single filter condition based on metadata, numeric values, array contents, or string matching """ @@ -414,3310 +110,25 @@ class FiltersOrOrUnionMember0(TypedDict, total=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")]] +class FiltersOrOrOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[object], 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")]] +class FiltersOrOrAnd(TypedDict, total=False): + and_: Required[Annotated[Iterable[object], 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")] +FiltersOrOr: TypeAlias = Union[FiltersOrOrFilterCondition, FiltersOrOrOr, FiltersOrOrAnd] -class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" +class FiltersOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] + """Array of OR filter expressions""" -class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): +class FiltersAndAndFilterCondition(TypedDict, total=False): """ A single filter condition based on metadata, numeric values, array contents, or string matching """ @@ -3737,134 +148,17 @@ class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=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")]] +class FiltersAndAndOr(TypedDict, total=False): + or_: Required[Annotated[Iterable[object], 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_: Required[Annotated[Iterable[object], PropertyInfo(alias="AND")]] """AND: Array of conditions or nested expressions""" -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] +FiltersAndAnd: TypeAlias = Union[FiltersAndAndFilterCondition, FiltersAndAndOr, FiltersAndAndAnd] class FiltersAnd(TypedDict, total=False):