API Reference

Search

Copy Markdown

Open in Claude

Open in ChatGPT

Open in Cursor

---

Copy Markdown

View as Markdown

Search documents

search.documents(SearchDocumentsParams**kwargs) -> SearchDocumentsResponse

POST/v3/search

Search memories with advanced filtering

ParametersExpand Collapse

q: str

Search query string

minLength1

Deprecatedcategories_filter: Optional[Sequence[str]]

DEPRECATED: Optional category filters

chunk_threshold: Optional[float]

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

maximum1

minimum0

container_tag: Optional[str]

Optional single container tag. Use this or containerTags.

maxLength100

container_tags: Optional[Sequence[str]]

Optional tags 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 documents.

doc_id: Optional[str]

Optional document ID to search within. You can use this to find chunks in a very large document.

maxLength255

Deprecateddocument_threshold: Optional[float]

DEPRECATED: This field is no longer used in v3 search. The search now uses chunkThreshold only. This parameter will be ignored.

maximum1

minimum0

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_full_docs: Optional[bool]

If true, include full document in the response. This is helpful if you want a chatbot to know the full context of the document.

include_summary: Optional[bool]

If true, include document summary in the response. This is helpful if you want a chatbot to know the full context of the document.

limit: Optional[int]

Maximum number of results to return

maximum100

minimum1

exclusiveMinimum0

only_matching_chunks: Optional[bool]

If true, only return matching chunks without context. Normally, we send the previous and next chunk to provide more context for LLMs. If you only want the matching chunk, set this to true.

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

ReturnsExpand Collapse

class SearchDocumentsResponse: …

results: List[Result]

chunks: List[ResultChunk]

Matching content chunks from the document

content: str

Content of the matching chunk

is_relevant: bool

Whether this chunk is relevant to the query

score: float

Similarity score for this chunk

maximum1

minimum0

created_at: str

Document creation date

formatdatetime

document_id: str

ID of the matching document

metadata: Optional[Dict[str, object]]

Document metadata

score: float

Relevance score of the match

maximum1

minimum0

title: Optional[str]

Document title

type: Optional[str]

Document type

updated_at: str

Document last update date

formatdatetime

content: Optional[str]

Full document content (only included when includeFullDocs=true)

summary: Optional[str]

Document summary

timing: float

total: float

Search documents

Python

HTTP

TypeScript

Python

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.documents(
    q="what are the API rate limits",
)
print(response.results)

200 example

{
  "results": [
    {
      "chunks": [
        {
          "content": "Rate limit headers are included in every response. Clients should implement exponential backoff when receiving 429 responses.",
          "isRelevant": true,
          "score": 0.85
        }
      ],
      "createdAt": "1970-01-01T00:00:00.000Z",
      "documentId": "doc_xyz789",
      "metadata": {
        "source": "bar",
        "language": "bar"
      },
      "score": 0.95,
      "title": "API Rate Limiting Policy",
      "type": "web",
      "updatedAt": "1970-01-01T00:00:00.000Z",
      "content": "Our API rate limits are 100 req/min on free and 1000 on pro. Clients should use exponential backoff on 429s.",
      "summary": "API rate limit policy: 100 req/min free, 1000 req/min pro."
    }
  ],
  "timing": 0,
  "total": 0
}

Returns Examples

200 example

{
  "results": [
    {
      "chunks": [
        {
          "content": "Rate limit headers are included in every response. Clients should implement exponential backoff when receiving 429 responses.",
          "isRelevant": true,
          "score": 0.85
        }
      ],
      "createdAt": "1970-01-01T00:00:00.000Z",
      "documentId": "doc_xyz789",
      "metadata": {
        "source": "bar",
        "language": "bar"
      },
      "score": 0.95,
      "title": "API Rate Limiting Policy",
      "type": "web",
      "updatedAt": "1970-01-01T00:00:00.000Z",
      "content": "Our API rate limits are 100 req/min on free and 1000 on pro. Clients should use exponential backoff on 429s.",
      "summary": "API rate limit policy: 100 req/min free, 1000 req/min pro."
    }
  ],
  "timing": 0,
  "total": 0
}