Skip to content
supermemory-new
Get started
API Reference
Documents

List documents

documents.list(DocumentListParams**kwargs) -> DocumentListResponse
POST/v3/documents/list

Retrieves a paginated list of documents with their metadata and workflow status

ParametersExpand Collapse
Deprecatedcontainer_tags: Optional[Sequence[str]]

Optional tags this document should be containerized by. This can be an ID for your user, a project ID, or any other identifier you wish to use to group documents.

filepath: Optional[str]

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

filters: Optional[Filters]

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

One of the following:
class FiltersOr: …
or_: Iterable[FiltersOrOr]

Array of OR filter expressions

One of the following:
class FiltersOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOr: …
or_: Iterable[FiltersOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOr: …
or_: Iterable[FiltersOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrOr: …
or_: Iterable[FiltersOrOrOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrOrOrOr: …
or_: Iterable[FiltersOrOrOrOrOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrOrOrOrOrOr: …
or_: Iterable[FiltersOrOrOrOrOrOrOrOrOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrOrOrOrOrAnd: …
and_: Iterable[FiltersOrOrOrOrOrOrOrOrOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrOrOrAnd: …
and_: Iterable[FiltersOrOrOrOrOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrOrOrAndAndOr: …
or_: Iterable[FiltersOrOrOrOrOrOrOrOrAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrOrOrAndAndAnd: …
and_: Iterable[FiltersOrOrOrOrOrOrOrOrAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrAnd: …
and_: Iterable[FiltersOrOrOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrAndAndOr: …
or_: Iterable[FiltersOrOrOrOrOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrAndAndOrOrOr: …
or_: Iterable[FiltersOrOrOrOrOrOrAndAndOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrAndAndOrOrAnd: …
and_: Iterable[FiltersOrOrOrOrOrOrAndAndOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrAndAndAnd: …
and_: Iterable[FiltersOrOrOrOrOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrAndAndAndAndOr: …
or_: Iterable[FiltersOrOrOrOrOrOrAndAndAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrOrOrAndAndAndAndAnd: …
and_: Iterable[FiltersOrOrOrOrOrOrAndAndAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAnd: …
and_: Iterable[FiltersOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndOr: …
or_: Iterable[FiltersOrOrOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndOrOrOr: …
or_: Iterable[FiltersOrOrOrOrAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndOrOrOrOrOr: …
or_: Iterable[FiltersOrOrOrOrAndAndOrOrOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndOrOrOrOrAnd: …
and_: Iterable[FiltersOrOrOrOrAndAndOrOrOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndOrOrAnd: …
and_: Iterable[FiltersOrOrOrOrAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndOrOrAndAndOr: …
or_: Iterable[FiltersOrOrOrOrAndAndOrOrAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndOrOrAndAndAnd: …
and_: Iterable[FiltersOrOrOrOrAndAndOrOrAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndAnd: …
and_: Iterable[FiltersOrOrOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndAndAndOr: …
or_: Iterable[FiltersOrOrOrOrAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndAndAndOrOrOr: …
or_: Iterable[FiltersOrOrOrOrAndAndAndAndOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndAndAndOrOrAnd: …
and_: Iterable[FiltersOrOrOrOrAndAndAndAndOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndAndAndAnd: …
and_: Iterable[FiltersOrOrOrOrAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndAndAndAndAndOr: …
or_: Iterable[FiltersOrOrOrOrAndAndAndAndAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrOrOrAndAndAndAndAndAndAnd: …
and_: Iterable[FiltersOrOrOrOrAndAndAndAndAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAnd: …
and_: Iterable[FiltersOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOr: …
or_: Iterable[FiltersOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrOr: …
or_: Iterable[FiltersOrOrAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrOrOrOr: …
or_: Iterable[FiltersOrOrAndAndOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrOrOrOrOrOr: …
or_: Iterable[FiltersOrOrAndAndOrOrOrOrOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrOrOrOrOrAnd: …
and_: Iterable[FiltersOrOrAndAndOrOrOrOrOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrOrOrAnd: …
and_: Iterable[FiltersOrOrAndAndOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrOrOrAndAndOr: …
or_: Iterable[FiltersOrOrAndAndOrOrOrOrAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrOrOrAndAndAnd: …
and_: Iterable[FiltersOrOrAndAndOrOrOrOrAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrAnd: …
and_: Iterable[FiltersOrOrAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrAndAndOr: …
or_: Iterable[FiltersOrOrAndAndOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrAndAndOrOrOr: …
or_: Iterable[FiltersOrOrAndAndOrOrAndAndOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrAndAndOrOrAnd: …
and_: Iterable[FiltersOrOrAndAndOrOrAndAndOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrAndAndAnd: …
and_: Iterable[FiltersOrOrAndAndOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrAndAndAndAndOr: …
or_: Iterable[FiltersOrOrAndAndOrOrAndAndAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndOrOrAndAndAndAndAnd: …
and_: Iterable[FiltersOrOrAndAndOrOrAndAndAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAnd: …
and_: Iterable[FiltersOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndOr: …
or_: Iterable[FiltersOrOrAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndOrOrOr: …
or_: Iterable[FiltersOrOrAndAndAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndOrOrOrOrOr: …
or_: Iterable[FiltersOrOrAndAndAndAndOrOrOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndOrOrOrOrAnd: …
and_: Iterable[FiltersOrOrAndAndAndAndOrOrOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndOrOrAnd: …
and_: Iterable[FiltersOrOrAndAndAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndOrOrAndAndOr: …
or_: Iterable[FiltersOrOrAndAndAndAndOrOrAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndOrOrAndAndAnd: …
and_: Iterable[FiltersOrOrAndAndAndAndOrOrAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndAnd: …
and_: Iterable[FiltersOrOrAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndAndAndOr: …
or_: Iterable[FiltersOrOrAndAndAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndAndAndOrOrOr: …
or_: Iterable[FiltersOrOrAndAndAndAndAndAndOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndAndAndOrOrAnd: …
and_: Iterable[FiltersOrOrAndAndAndAndAndAndOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndAndAndAnd: …
and_: Iterable[FiltersOrOrAndAndAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndAndAndAndAndOr: …
or_: Iterable[FiltersOrOrAndAndAndAndAndAndAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersOrOrAndAndAndAndAndAndAndAndAnd: …
and_: Iterable[FiltersOrOrAndAndAndAndAndAndAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAnd: …
and_: Iterable[FiltersAndAnd]

Array of AND filter expressions

One of the following:
class FiltersAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOr: …
or_: Iterable[FiltersAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOr: …
or_: Iterable[FiltersAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrOr: …
or_: Iterable[FiltersAndAndOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrOrOrOr: …
or_: Iterable[FiltersAndAndOrOrOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrOrOrOrOrOr: …
or_: Iterable[FiltersAndAndOrOrOrOrOrOrOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrOrOrOrOrAnd: …
and_: Iterable[FiltersAndAndOrOrOrOrOrOrOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrOrOrAnd: …
and_: Iterable[FiltersAndAndOrOrOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrOrOrAndAndOr: …
or_: Iterable[FiltersAndAndOrOrOrOrOrOrAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrOrOrAndAndAnd: …
and_: Iterable[FiltersAndAndOrOrOrOrOrOrAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrAnd: …
and_: Iterable[FiltersAndAndOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrAndAndOr: …
or_: Iterable[FiltersAndAndOrOrOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrAndAndOrOrOr: …
or_: Iterable[FiltersAndAndOrOrOrOrAndAndOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrAndAndOrOrAnd: …
and_: Iterable[FiltersAndAndOrOrOrOrAndAndOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrAndAndAnd: …
and_: Iterable[FiltersAndAndOrOrOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrAndAndAndAndOr: …
or_: Iterable[FiltersAndAndOrOrOrOrAndAndAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrOrOrAndAndAndAndAnd: …
and_: Iterable[FiltersAndAndOrOrOrOrAndAndAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAnd: …
and_: Iterable[FiltersAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndOr: …
or_: Iterable[FiltersAndAndOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndOrOrOr: …
or_: Iterable[FiltersAndAndOrOrAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndOrOrOrOrOr: …
or_: Iterable[FiltersAndAndOrOrAndAndOrOrOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndOrOrOrOrAnd: …
and_: Iterable[FiltersAndAndOrOrAndAndOrOrOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndOrOrAnd: …
and_: Iterable[FiltersAndAndOrOrAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndOrOrAndAndOr: …
or_: Iterable[FiltersAndAndOrOrAndAndOrOrAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndOrOrAndAndAnd: …
and_: Iterable[FiltersAndAndOrOrAndAndOrOrAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndAnd: …
and_: Iterable[FiltersAndAndOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndAndAndOr: …
or_: Iterable[FiltersAndAndOrOrAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndAndAndOrOrOr: …
or_: Iterable[FiltersAndAndOrOrAndAndAndAndOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndAndAndOrOrAnd: …
and_: Iterable[FiltersAndAndOrOrAndAndAndAndOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndAndAndAnd: …
and_: Iterable[FiltersAndAndOrOrAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndAndAndAndAndOr: …
or_: Iterable[FiltersAndAndOrOrAndAndAndAndAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndOrOrAndAndAndAndAndAndAnd: …
and_: Iterable[FiltersAndAndOrOrAndAndAndAndAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAnd: …
and_: Iterable[FiltersAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOr: …
or_: Iterable[FiltersAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrOr: …
or_: Iterable[FiltersAndAndAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrOrOrOr: …
or_: Iterable[FiltersAndAndAndAndOrOrOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrOrOrOrOrOr: …
or_: Iterable[FiltersAndAndAndAndOrOrOrOrOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrOrOrOrOrAnd: …
and_: Iterable[FiltersAndAndAndAndOrOrOrOrOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrOrOrAnd: …
and_: Iterable[FiltersAndAndAndAndOrOrOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrOrOrAndAndOr: …
or_: Iterable[FiltersAndAndAndAndOrOrOrOrAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrOrOrAndAndAnd: …
and_: Iterable[FiltersAndAndAndAndOrOrOrOrAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrAnd: …
and_: Iterable[FiltersAndAndAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrAndAndOr: …
or_: Iterable[FiltersAndAndAndAndOrOrAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrAndAndOrOrOr: …
or_: Iterable[FiltersAndAndAndAndOrOrAndAndOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrAndAndOrOrAnd: …
and_: Iterable[FiltersAndAndAndAndOrOrAndAndOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrAndAndAnd: …
and_: Iterable[FiltersAndAndAndAndOrOrAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrAndAndAndAndOr: …
or_: Iterable[FiltersAndAndAndAndOrOrAndAndAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndOrOrAndAndAndAndAnd: …
and_: Iterable[FiltersAndAndAndAndOrOrAndAndAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAnd: …
and_: Iterable[FiltersAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndOr: …
or_: Iterable[FiltersAndAndAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndOrOrOr: …
or_: Iterable[FiltersAndAndAndAndAndAndOrOrOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndOrOrOrOrOr: …
or_: Iterable[FiltersAndAndAndAndAndAndOrOrOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndOrOrOrOrAnd: …
and_: Iterable[FiltersAndAndAndAndAndAndOrOrOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndOrOrAnd: …
and_: Iterable[FiltersAndAndAndAndAndAndOrOrAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndOrOrAndAndOr: …
or_: Iterable[FiltersAndAndAndAndAndAndOrOrAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndOrOrAndAndAnd: …
and_: Iterable[FiltersAndAndAndAndAndAndOrOrAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndAnd: …
and_: Iterable[FiltersAndAndAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndAndAndOr: …
or_: Iterable[FiltersAndAndAndAndAndAndAndAndOrOr]

OR: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndAndAndOrOrOr: …
or_: Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndAndAndOrOrAnd: …
and_: Iterable[FiltersAndAndAndAndAndAndAndAndOrOrAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndAndAndAnd: …
and_: Iterable[FiltersAndAndAndAndAndAndAndAndAndAnd]

AND: Array of conditions or nested expressions

One of the following:
class FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0: …

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

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndAndAndAndAndOr: …
or_: Iterable[FiltersAndAndAndAndAndAndAndAndAndAndOrOr]

OR: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
class FiltersAndAndAndAndAndAndAndAndAndAndAnd: …
and_: Iterable[FiltersAndAndAndAndAndAndAndAndAndAndAndAnd]

AND: Array of conditions

key: str
value: str
filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]
One of the following:
"metadata"
"numeric"
"array_contains"
"string_contains"
ignore_case: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
negate: Optional[Union[bool, Literal["true", "false"]]]
One of the following:
bool
Literal["true", "false"]
One of the following:
"true"
"false"
numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]
One of the following:
">"
"<"
">="
"<="
"="
include_content: Optional[bool]

Whether to include the content field in the response. Warning: This can make responses significantly larger.

limit: Optional[Union[str, float]]

Number of items per page

One of the following:
str
float
order: Optional[Literal["asc", "desc"]]

Sort order

One of the following:
"asc"
"desc"
page: Optional[Union[str, float]]

Page number to fetch

One of the following:
str
float
sort: Optional[Literal["createdAt", "updatedAt"]]

Field to sort by

One of the following:
"createdAt"
"updatedAt"
ReturnsExpand Collapse
class DocumentListResponse: …

List of documents

memories: List[Memory]
id: str

Unique identifier of the document.

minLength22
maxLength22
connection_id: Optional[str]

Optional ID of connection the document was created from. This is useful for identifying the source of the document.

minLength22
maxLength22
created_at: str

Creation timestamp

formatdatetime
custom_id: Optional[str]

Optional custom ID of the document. This could be an ID from your database that will uniquely identify this document.

maxLength255
filepath: Optional[str]
metadata: Union[str, float, bool, 3 more]

Optional metadata for the document. This is used to store additional information about the document. You can use this to store any additional information you need about the document. Metadata can be filtered through. Keys must be strings and are case sensitive. Values can be strings, numbers, or booleans. You cannot nest objects.

One of the following:
str
float
bool
Dict[str, object]
List[object]
status: Literal["unknown", "queued", "extracting", 5 more]

Status of the document

One of the following:
"unknown"
"queued"
"extracting"
"chunking"
"embedding"
"indexing"
"done"
"failed"
summary: Optional[str]

Summary of the document content

title: Optional[str]

Title of the document

type: Literal["text", "pdf", "tweet", 10 more]

Type of the document

One of the following:
"text"
"pdf"
"tweet"
"google_doc"
"google_slide"
"google_sheet"
"image"
"video"
"audio"
"notion_doc"
"webpage"
"onedrive"
"github_markdown"
updated_at: str

Last update timestamp

formatdatetime
Deprecatedcontainer_tags: Optional[List[str]]

Optional tags this document should be containerized by. This can be an ID for your user, a project ID, or any other identifier you wish to use to group documents.

content: Optional[str]

Content of the document (only included when includeContent=true)

url: Optional[str]

URL of the document

List documents

import os
from supermemory import Supermemory

client = Supermemory(
    api_key=os.environ.get("SUPERMEMORY_API_KEY"),  # This is the default and can be omitted
)
documents = client.documents.list()
print(documents.memories)
{
  "memories": [
    {
      "id": "acxV5LHMEsG2hMSNb4umbn",
      "connectionId": "xxxxxxxxxxxxxxxxxxxxxx",
      "createdAt": "2025-04-15T09:30:00.000Z",
      "customId": "doc-api-rate-limits",
      "filepath": "filepath",
      "metadata": {
        "source": "bar",
        "language": "bar"
      },
      "status": "done",
      "summary": "API rate limit policy: 100 req/min free, 1000 req/min pro.",
      "title": "API Rate Limiting Policy",
      "type": "text",
      "updatedAt": "2025-04-15T09:31:00.000Z",
      "containerTags": [
        "string"
      ],
      "content": "This is the content of the document...",
      "url": "https://docs.example.com/guides/rate-limits"
    }
  ],
  "pagination": {
    "currentPage": 1,
    "totalItems": 100,
    "totalPages": 10,
    "limit": 10
  }
}
Returns Examples
{
  "memories": [
    {
      "id": "acxV5LHMEsG2hMSNb4umbn",
      "connectionId": "xxxxxxxxxxxxxxxxxxxxxx",
      "createdAt": "2025-04-15T09:30:00.000Z",
      "customId": "doc-api-rate-limits",
      "filepath": "filepath",
      "metadata": {
        "source": "bar",
        "language": "bar"
      },
      "status": "done",
      "summary": "API rate limit policy: 100 req/min free, 1000 req/min pro.",
      "title": "API Rate Limiting Policy",
      "type": "text",
      "updatedAt": "2025-04-15T09:31:00.000Z",
      "containerTags": [
        "string"
      ],
      "content": "This is the content of the document...",
      "url": "https://docs.example.com/guides/rate-limits"
    }
  ],
  "pagination": {
    "currentPage": 1,
    "totalItems": 100,
    "totalPages": 10,
    "limit": 10
  }
}