API Reference

Client

Copy Markdown

Open in Claude

Open in ChatGPT

Open in Cursor

---

Copy Markdown

View as Markdown

Get user profile

profile(ClientProfileParams**kwargs) -> ProfileResponse

POST/v4/profile

Get user profile with optional search results

ParametersExpand Collapse

container_tag: str

Tag to filter the profile by. This can be an ID for your user, a project ID, or any other identifier you wish to use to filter memories.

filters: Optional[Filters]

Optional metadata filters to apply to profile results and search results. Supports complex AND/OR queries with multiple conditions.

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:

">"

"<"

">="

"<="

"="

q: Optional[str]

Optional search query to include search results in the response

threshold: Optional[float]

Threshold for search results. Only results with a score above this threshold will be included.

minimum0

maximum1

ReturnsExpand Collapse

class ProfileResponse: …

profile: Profile

dynamic: List[str]

Dynamic profile information (recent memories)

static: List[str]

Static profile information that remains relevant long-term

search_results: Optional[SearchResults]

Search results if a search query was provided

results: List[object]

Search results for the provided query

timing: float

Search timing in milliseconds

total: float

Total number of search results

Get user profile

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.profile(
    container_tag="containerTag",
)
print(response.profile)

200 example

{
  "profile": {
    "dynamic": [
      "string"
    ],
    "static": [
      "string"
    ]
  },
  "searchResults": {
    "results": [
      {}
    ],
    "timing": 0,
    "total": 0
  }
}

Returns Examples

200 example

{
  "profile": {
    "dynamic": [
      "string"
    ],
    "static": [
      "string"
    ]
  },
  "searchResults": {
    "results": [
      {}
    ],
    "timing": 0,
    "total": 0
  }
}