Search memory entries

search.memories() -> SearchMemoriesResponse

POST/v4/search

Search memory entries - Low latency for conversational

ParametersExpand Collapse

q: str

Search query string

minLength1

aggregate: Optional[bool]

If true, aggregates information from multiple memories to create new synthesized memories. The result will be a mix of aggregated and non-aggregated memories, reranked by relevance to the query. Works in conjunction with reranking.

container_tag: Optional[str]

Optional tag this search should be containerized by. This can be an ID for your user, a project ID, or any other identifier you wish to use to filter memories.

maxLength100

filepath: Optional[str]

Filter search results by filepath. Exact match for full paths, prefix match if ending with /

filters: Optional[Filters]

Optional filters to apply to the search. Can be a JSON string or Query object.

One of the following:

class FiltersOr: …

or_: Iterable[FiltersOrOr]

Array of OR filter expressions

One of the following:

class FiltersOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOr: …

or_: Iterable[FiltersOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOr: …

or_: Iterable[FiltersOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrOr: …

or_: Iterable[FiltersOrOrOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrOrOrOr: …

or_: Iterable[FiltersOrOrOrOrOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrOrOrOrOrOr: …

or_: Iterable[FiltersOrOrOrOrOrOrOrOrOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrOrOrOrOrAnd: …

and_: Iterable[FiltersOrOrOrOrOrOrOrOrOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrOrOrAnd: …

and_: Iterable[FiltersOrOrOrOrOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrOrOrAndAndOr: …

or_: Iterable[FiltersOrOrOrOrOrOrOrOrAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrOrOrAndAndAnd: …

and_: Iterable[FiltersOrOrOrOrOrOrOrOrAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrAnd: …

and_: Iterable[FiltersOrOrOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrAndAndOr: …

or_: Iterable[FiltersOrOrOrOrOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrAndAndOrOrOr: …

or_: Iterable[FiltersOrOrOrOrOrOrAndAndOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrAndAndOrOrAnd: …

and_: Iterable[FiltersOrOrOrOrOrOrAndAndOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrAndAndAnd: …

and_: Iterable[FiltersOrOrOrOrOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrAndAndAndAndOr: …

or_: Iterable[FiltersOrOrOrOrOrOrAndAndAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrOrOrAndAndAndAndAnd: …

and_: Iterable[FiltersOrOrOrOrOrOrAndAndAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAnd: …

and_: Iterable[FiltersOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndOr: …

or_: Iterable[FiltersOrOrOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndOrOrOr: …

or_: Iterable[FiltersOrOrOrOrAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndOrOrOrOrOr: …

or_: Iterable[FiltersOrOrOrOrAndAndOrOrOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndOrOrOrOrAnd: …

and_: Iterable[FiltersOrOrOrOrAndAndOrOrOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndOrOrAnd: …

and_: Iterable[FiltersOrOrOrOrAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndOrOrAndAndOr: …

or_: Iterable[FiltersOrOrOrOrAndAndOrOrAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndOrOrAndAndAnd: …

and_: Iterable[FiltersOrOrOrOrAndAndOrOrAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndAnd: …

and_: Iterable[FiltersOrOrOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndAndAndOr: …

or_: Iterable[FiltersOrOrOrOrAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndAndAndOrOrOr: …

or_: Iterable[FiltersOrOrOrOrAndAndAndAndOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndAndAndOrOrAnd: …

and_: Iterable[FiltersOrOrOrOrAndAndAndAndOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndAndAndAnd: …

and_: Iterable[FiltersOrOrOrOrAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndAndAndAndAndOr: …

or_: Iterable[FiltersOrOrOrOrAndAndAndAndAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrOrOrAndAndAndAndAndAndAnd: …

and_: Iterable[FiltersOrOrOrOrAndAndAndAndAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAnd: …

and_: Iterable[FiltersOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOr: …

or_: Iterable[FiltersOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrOr: …

or_: Iterable[FiltersOrOrAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrOrOrOr: …

or_: Iterable[FiltersOrOrAndAndOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrOrOrOrOrOr: …

or_: Iterable[FiltersOrOrAndAndOrOrOrOrOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrOrOrOrOrAnd: …

and_: Iterable[FiltersOrOrAndAndOrOrOrOrOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrOrOrAnd: …

and_: Iterable[FiltersOrOrAndAndOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrOrOrAndAndOr: …

or_: Iterable[FiltersOrOrAndAndOrOrOrOrAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrOrOrAndAndAnd: …

and_: Iterable[FiltersOrOrAndAndOrOrOrOrAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrAnd: …

and_: Iterable[FiltersOrOrAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrAndAndOr: …

or_: Iterable[FiltersOrOrAndAndOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrAndAndOrOrOr: …

or_: Iterable[FiltersOrOrAndAndOrOrAndAndOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrAndAndOrOrAnd: …

and_: Iterable[FiltersOrOrAndAndOrOrAndAndOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrAndAndAnd: …

and_: Iterable[FiltersOrOrAndAndOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrAndAndAndAndOr: …

or_: Iterable[FiltersOrOrAndAndOrOrAndAndAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndOrOrAndAndAndAndAnd: …

and_: Iterable[FiltersOrOrAndAndOrOrAndAndAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAnd: …

and_: Iterable[FiltersOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndOr: …

or_: Iterable[FiltersOrOrAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndOrOrOr: …

or_: Iterable[FiltersOrOrAndAndAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndOrOrOrOrOr: …

or_: Iterable[FiltersOrOrAndAndAndAndOrOrOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndOrOrOrOrAnd: …

and_: Iterable[FiltersOrOrAndAndAndAndOrOrOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndOrOrAnd: …

and_: Iterable[FiltersOrOrAndAndAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndOrOrAndAndOr: …

or_: Iterable[FiltersOrOrAndAndAndAndOrOrAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndOrOrAndAndAnd: …

and_: Iterable[FiltersOrOrAndAndAndAndOrOrAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndAnd: …

and_: Iterable[FiltersOrOrAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndAndAndOr: …

or_: Iterable[FiltersOrOrAndAndAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndAndAndOrOrOr: …

or_: Iterable[FiltersOrOrAndAndAndAndAndAndOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndAndAndOrOrAnd: …

and_: Iterable[FiltersOrOrAndAndAndAndAndAndOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndAndAndAnd: …

and_: Iterable[FiltersOrOrAndAndAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndAndAndAndAndOr: …

or_: Iterable[FiltersOrOrAndAndAndAndAndAndAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersOrOrAndAndAndAndAndAndAndAndAnd: …

and_: Iterable[FiltersOrOrAndAndAndAndAndAndAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAnd: …

and_: Iterable[FiltersAndAnd]

Array of AND filter expressions

One of the following:

class FiltersAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOr: …

or_: Iterable[FiltersAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOr: …

or_: Iterable[FiltersAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrOr: …

or_: Iterable[FiltersAndAndOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrOrOrOr: …

or_: Iterable[FiltersAndAndOrOrOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrOrOrOrOrOr: …

or_: Iterable[FiltersAndAndOrOrOrOrOrOrOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrOrOrOrOrAnd: …

and_: Iterable[FiltersAndAndOrOrOrOrOrOrOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrOrOrAnd: …

and_: Iterable[FiltersAndAndOrOrOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrOrOrAndAndOr: …

or_: Iterable[FiltersAndAndOrOrOrOrOrOrAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrOrOrAndAndAnd: …

and_: Iterable[FiltersAndAndOrOrOrOrOrOrAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrAnd: …

and_: Iterable[FiltersAndAndOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrAndAndOr: …

or_: Iterable[FiltersAndAndOrOrOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrAndAndOrOrOr: …

or_: Iterable[FiltersAndAndOrOrOrOrAndAndOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrAndAndOrOrAnd: …

and_: Iterable[FiltersAndAndOrOrOrOrAndAndOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrAndAndAnd: …

and_: Iterable[FiltersAndAndOrOrOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrAndAndAndAndOr: …

or_: Iterable[FiltersAndAndOrOrOrOrAndAndAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrOrOrAndAndAndAndAnd: …

and_: Iterable[FiltersAndAndOrOrOrOrAndAndAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAnd: …

and_: Iterable[FiltersAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndOr: …

or_: Iterable[FiltersAndAndOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndOrOrOr: …

or_: Iterable[FiltersAndAndOrOrAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndOrOrOrOrOr: …

or_: Iterable[FiltersAndAndOrOrAndAndOrOrOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndOrOrOrOrAnd: …

and_: Iterable[FiltersAndAndOrOrAndAndOrOrOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndOrOrAnd: …

and_: Iterable[FiltersAndAndOrOrAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndOrOrAndAndOr: …

or_: Iterable[FiltersAndAndOrOrAndAndOrOrAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndOrOrAndAndAnd: …

and_: Iterable[FiltersAndAndOrOrAndAndOrOrAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndAnd: …

and_: Iterable[FiltersAndAndOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndAndAndOr: …

or_: Iterable[FiltersAndAndOrOrAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndAndAndOrOrOr: …

or_: Iterable[FiltersAndAndOrOrAndAndAndAndOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndAndAndOrOrAnd: …

and_: Iterable[FiltersAndAndOrOrAndAndAndAndOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndAndAndAnd: …

and_: Iterable[FiltersAndAndOrOrAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndAndAndAndAndOr: …

or_: Iterable[FiltersAndAndOrOrAndAndAndAndAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndOrOrAndAndAndAndAndAndAnd: …

and_: Iterable[FiltersAndAndOrOrAndAndAndAndAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAnd: …

and_: Iterable[FiltersAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOr: …

or_: Iterable[FiltersAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrOr: …

or_: Iterable[FiltersAndAndAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrOrOrOr: …

or_: Iterable[FiltersAndAndAndAndOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrOrOrOrOrOr: …

or_: Iterable[FiltersAndAndAndAndOrOrOrOrOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrOrOrOrOrAnd: …

and_: Iterable[FiltersAndAndAndAndOrOrOrOrOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrOrOrAnd: …

and_: Iterable[FiltersAndAndAndAndOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrOrOrAndAndOr: …

or_: Iterable[FiltersAndAndAndAndOrOrOrOrAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrOrOrAndAndAnd: …

and_: Iterable[FiltersAndAndAndAndOrOrOrOrAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrAnd: …

and_: Iterable[FiltersAndAndAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrAndAndOr: …

or_: Iterable[FiltersAndAndAndAndOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrAndAndOrOrOr: …

or_: Iterable[FiltersAndAndAndAndOrOrAndAndOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrAndAndOrOrAnd: …

and_: Iterable[FiltersAndAndAndAndOrOrAndAndOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrAndAndAnd: …

and_: Iterable[FiltersAndAndAndAndOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrAndAndAndAndOr: …

or_: Iterable[FiltersAndAndAndAndOrOrAndAndAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndOrOrAndAndAndAndAnd: …

and_: Iterable[FiltersAndAndAndAndOrOrAndAndAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAnd: …

and_: Iterable[FiltersAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndOr: …

or_: Iterable[FiltersAndAndAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndOrOrOr: …

or_: Iterable[FiltersAndAndAndAndAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndOrOrOrOrOr: …

or_: Iterable[FiltersAndAndAndAndAndAndOrOrOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndOrOrOrOrAnd: …

and_: Iterable[FiltersAndAndAndAndAndAndOrOrOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndOrOrAnd: …

and_: Iterable[FiltersAndAndAndAndAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndOrOrAndAndOr: …

or_: Iterable[FiltersAndAndAndAndAndAndOrOrAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndOrOrAndAndAnd: …

and_: Iterable[FiltersAndAndAndAndAndAndOrOrAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndAnd: …

and_: Iterable[FiltersAndAndAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndAndAndOr: …

or_: Iterable[FiltersAndAndAndAndAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndAndAndOrOrOr: …

or_: Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndAndAndOrOrAnd: …

and_: Iterable[FiltersAndAndAndAndAndAndAndAndOrOrAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndAndAndAnd: …

and_: Iterable[FiltersAndAndAndAndAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:

class FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0: …

A single filter condition based on metadata, numeric values, array contents, or string matching

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndAndAndAndAndOr: …

or_: Iterable[FiltersAndAndAndAndAndAndAndAndAndAndOrOr]

OR: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

class FiltersAndAndAndAndAndAndAndAndAndAndAnd: …

and_: Iterable[FiltersAndAndAndAndAndAndAndAndAndAndAndAnd]

AND: Array of conditions

key: str

value: str

filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]

One of the following:

"metadata"

"numeric"

"array_contains"

"string_contains"

ignore_case: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

negate: Optional[Union[bool, Literal["true", "false"]]]

One of the following:

bool

Literal["true", "false"]

One of the following:

"true"

"false"

numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]

One of the following:

">"

"<"

">="

"<="

"="

include: Optional[Include]

Deprecatedchunks: Optional[bool]

DEPRECATED: Use searchMode=‘hybrid’ instead. If true, automatically switches to hybrid mode. This field is kept for backward compatibility only.

documents: Optional[bool]

forgotten_memories: Optional[bool]

If true, include forgotten memories in search results. Forgotten memories are memories that have been explicitly forgotten or have passed their expiration date.

related_memories: Optional[bool]

summaries: Optional[bool]

limit: Optional[int]

Maximum number of results to return

maximum100

minimum1

exclusiveMinimum0

rerank: Optional[bool]

If true, rerank the results based on the query. This is helpful if you want to ensure the most relevant results are returned.

rewrite_query: Optional[bool]

If true, rewrites the query to make it easier to find documents. This increases the latency by about 400ms

search_mode: Optional[Literal["memories", "hybrid", "documents"]]

Search mode. ‘memories’ searches only memory entries (default). ‘hybrid’ searches both memories and document chunks. ‘documents’ searches only document chunks.

One of the following:

"memories"

"hybrid"

"documents"

threshold: Optional[float]

Threshold / sensitivity for memories selection. 0 is least sensitive (returns most memories, more results), 1 is most sensitive (returns lesser memories, accurate results)

maximum1

minimum0

ReturnsExpand Collapse

class SearchMemoriesResponse: …

results: List[Result]

Array of matching memory entries and chunks with similarity scores. Contains memory results when searchMode=‘memories’, both memory and chunk results when searchMode=‘hybrid’, or only chunk results when searchMode=‘documents’. Memory results have ‘memory’ field, chunk results have ‘chunk’ field. BACKWARD COMPATIBILITY: When using deprecated include.chunks=true, only memory results are returned with chunks embedded in them (old format).

id: str

Memory entry ID or chunk ID

metadata: Optional[Dict[str, object]]

Memory metadata

similarity: float

Similarity score between the query and memory entry

maximum1

minimum0

updated_at: str

Memory last update date

formatdatetime

chunk: Optional[str]

The chunk content (only present for chunk results from hybrid search)

chunks: Optional[List[ResultChunk]]

Relevant chunks from associated documents (only included when chunks=true)

content: str

Content of the chunk

document_id: str

ID of the document this chunk belongs to

position: float

Position of chunk in the document (0-indexed)

score: float

Similarity score between the query and chunk

maximum1

minimum0

context: Optional[ResultContext]

Object containing version history (parents/children via updates) and related memories (extends/derives)

children: Optional[List[ResultContextChild]]

memory: str

The contextual memory content

relation: Literal["updates", "extends", "derives"]

Relation type between this memory and its parent/child

One of the following:

"updates"

"extends"

"derives"

updated_at: str

Contextual memory last update date

formatdatetime

metadata: Optional[Dict[str, object]]

Contextual memory metadata

version: Optional[float]

Relative version distance from the primary memory (+1 for direct child, +2 for grand-child, etc.)

parents: Optional[List[ResultContextParent]]

memory: str

The contextual memory content

relation: Literal["updates", "extends", "derives"]

Relation type between this memory and its parent/child

One of the following:

"updates"

"extends"

"derives"

updated_at: str

Contextual memory last update date

formatdatetime

metadata: Optional[Dict[str, object]]

Contextual memory metadata

version: Optional[float]

Relative version distance from the primary memory (-1 for direct parent, -2 for grand-parent, etc.)

One of the following:

documents: Optional[List[ResultDocument]]

Associated documents for this memory entry

id: str

Document ID

created_at: str

Document creation date

formatdatetime

updated_at: str

Document last update date

formatdatetime

metadata: Optional[Dict[str, object]]

Document metadata (only included when documents=true)

summary: Optional[str]

Document summary (only included when summaries=true)

title: Optional[str]

Document title (only included when documents=true)

type: Optional[str]

Document type (only included when documents=true)

filepath: Optional[str]

Filepath of the source document this memory or chunk came from

is_aggregated: Optional[bool]

Indicates if this memory was created by aggregating multiple source memories

memory: Optional[str]

The memory content (only present for memory results)

version: Optional[float]

Version number of this memory entry

timing: float

Search execution time in milliseconds

total: float

Total number of results returned

Search memory entries

import os
from supermemory import Supermemory

client = Supermemory(
    api_key=os.environ.get("SUPERMEMORY_API_KEY"),  # This is the default and can be omitted
)
response = client.search.memories(
    q="what are the API rate limits",
)
print(response.results)

{
  "results": [
    {
      "id": "mem_abc123",
      "metadata": {
        "source": "bar",
        "confidence": "bar"
      },
      "similarity": 0.89,
      "updatedAt": "updatedAt",
      "chunk": "This is a chunk of content from a document...",
      "chunks": [
        {
          "content": "This is a chunk of content from the document...",
          "documentId": "doc_xyz789",
          "position": 0,
          "score": 0.85
        }
      ],
      "context": {
        "children": [
          {
            "memory": "Later version: API rate limit increased to 100 req/min on the free tier.",
            "relation": "extends",
            "updatedAt": "updatedAt",
            "metadata": {
              "foo": "bar"
            },
            "version": 1
          }
        ],
        "parents": [
          {
            "memory": "Earlier version: API rate limit is 50 req/min on the free tier.",
            "relation": "updates",
            "updatedAt": "updatedAt",
            "metadata": {
              "foo": "bar"
            },
            "version": -1
          }
        ],
        "related": [
          {
            "memory": "memory",
            "relation": "extends",
            "updatedAt": "updatedAt",
            "metadata": {
              "foo": "bar"
            }
          }
        ]
      },
      "documents": [
        {
          "id": "doc_xyz789",
          "createdAt": "createdAt",
          "updatedAt": "updatedAt",
          "metadata": {
            "source": "bar",
            "language": "bar"
          },
          "summary": "API rate limit policy: 100 req/min free, 1000 req/min pro.",
          "title": "API Rate Limiting Policy",
          "type": "web"
        }
      ],
      "filepath": "filepath",
      "isAggregated": false,
      "memory": "The user prefers detailed API responses over minimal ones.",
      "version": 3
    }
  ],
  "timing": 245,
  "total": 5
}

Returns Examples

{
  "results": [
    {
      "id": "mem_abc123",
      "metadata": {
        "source": "bar",
        "confidence": "bar"
      },
      "similarity": 0.89,
      "updatedAt": "updatedAt",
      "chunk": "This is a chunk of content from a document...",
      "chunks": [
        {
          "content": "This is a chunk of content from the document...",
          "documentId": "doc_xyz789",
          "position": 0,
          "score": 0.85
        }
      ],
      "context": {
        "children": [
          {
            "memory": "Later version: API rate limit increased to 100 req/min on the free tier.",
            "relation": "extends",
            "updatedAt": "updatedAt",
            "metadata": {
              "foo": "bar"
            },
            "version": 1
          }
        ],
        "parents": [
          {
            "memory": "Earlier version: API rate limit is 50 req/min on the free tier.",
            "relation": "updates",
            "updatedAt": "updatedAt",
            "metadata": {
              "foo": "bar"
            },
            "version": -1
          }
        ],
        "related": [
          {
            "memory": "memory",
            "relation": "extends",
            "updatedAt": "updatedAt",
            "metadata": {
              "foo": "bar"
            }
          }
        ]
      },
      "documents": [
        {
          "id": "doc_xyz789",
          "createdAt": "createdAt",
          "updatedAt": "updatedAt",
          "metadata": {
            "source": "bar",
            "language": "bar"
          },
          "summary": "API rate limit policy: 100 req/min free, 1000 req/min pro.",
          "title": "API Rate Limiting Policy",
          "type": "web"
        }
      ],
      "filepath": "filepath",
      "isAggregated": false,
      "memory": "The user prefers detailed API responses over minimal ones.",
      "version": 3
    }
  ],
  "timing": 245,
  "total": 5
}