# Documents ## Add document `documents.add(DocumentAddParams**kwargs) -> DocumentAddResponse` **post** `/v3/documents` Add a document with any content type (text, url, file, etc.) and metadata ### Parameters - `content: str` The content to extract and process into a document. This can be a URL to a website, a PDF, an image, or a video. - `container_tag: Optional[str]` Optional tag this document should be containerized by. Max 100 characters, alphanumeric with hyphens, underscores, and dots only. - `container_tags: Optional[Sequence[str]]` - `custom_id: Optional[str]` Optional custom ID of the document. Max 100 characters, alphanumeric with hyphens, underscores, and dots only. - `entity_context: Optional[str]` Optional entity context for this container tag. Max 1500 characters. Used during document processing to guide memory extraction. - `filepath: Optional[str]` Optional file path for the document. Used by supermemoryfs to store the full path of the file. - `filter_by_metadata: Optional[Dict[str, Union[str, float, bool, Sequence[str]]]]` Optional metadata filter to apply when pulling related memories and profile during ingestion. Only memories matching these filters will be used as context. - `str` - `float` - `bool` - `Sequence[str]` - `metadata: Optional[Dict[str, Union[str, float, bool, Sequence[str]]]]` Optional metadata for the document. - `str` - `float` - `bool` - `Sequence[str]` - `task_type: Optional[Literal["memory", "superrag"]]` Task type: "memory" (default) for full context layer with SuperRAG built in, "superrag" for managed RAG as a service. - `"memory"` - `"superrag"` ### Returns - `class DocumentAddResponse: …` - `id: str` Unique identifier of the document - `status: str` Status of the document ### Example ```python import os from supermemory import Supermemory client = Supermemory( api_key=os.environ.get("SUPERMEMORY_API_KEY"), # This is the default and can be omitted ) response = client.documents.add( content="content", ) print(response.id) ``` #### Response ```json { "id": "id", "status": "status" } ``` ## List documents `documents.list(DocumentListParams**kwargs) -> DocumentListResponse` **post** `/v3/documents/list` Retrieves a paginated list of documents with their metadata and workflow status ### Parameters - `container_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. - `class FiltersOr: …` - `or_: Iterable[FiltersOrOr]` Array of OR filter expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOr: …` - `or_: Iterable[FiltersOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOr: …` - `or_: Iterable[FiltersOrOrOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrOr: …` - `or_: Iterable[FiltersOrOrOrOrOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrOrOrOr: …` - `or_: Iterable[FiltersOrOrOrOrOrOrOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrOrOrOrOrOr: …` - `or_: Iterable[FiltersOrOrOrOrOrOrOrOrOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrOrOrOrOrAnd: …` - `and_: Iterable[FiltersOrOrOrOrOrOrOrOrOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrOrOrAnd: …` - `and_: Iterable[FiltersOrOrOrOrOrOrOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrOrOrAndAndOr: …` - `or_: Iterable[FiltersOrOrOrOrOrOrOrOrAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrOrOrAndAndAnd: …` - `and_: Iterable[FiltersOrOrOrOrOrOrOrOrAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrAnd: …` - `and_: Iterable[FiltersOrOrOrOrOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrAndAndOr: …` - `or_: Iterable[FiltersOrOrOrOrOrOrAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrAndAndOrOrOr: …` - `or_: Iterable[FiltersOrOrOrOrOrOrAndAndOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrAndAndOrOrAnd: …` - `and_: Iterable[FiltersOrOrOrOrOrOrAndAndOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrAndAndAnd: …` - `and_: Iterable[FiltersOrOrOrOrOrOrAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrAndAndAndAndOr: …` - `or_: Iterable[FiltersOrOrOrOrOrOrAndAndAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrOrOrAndAndAndAndAnd: …` - `and_: Iterable[FiltersOrOrOrOrOrOrAndAndAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAnd: …` - `and_: Iterable[FiltersOrOrOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndOr: …` - `or_: Iterable[FiltersOrOrOrOrAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndOrOrOr: …` - `or_: Iterable[FiltersOrOrOrOrAndAndOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndOrOrOrOrOr: …` - `or_: Iterable[FiltersOrOrOrOrAndAndOrOrOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndOrOrOrOrAnd: …` - `and_: Iterable[FiltersOrOrOrOrAndAndOrOrOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndOrOrAnd: …` - `and_: Iterable[FiltersOrOrOrOrAndAndOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndOrOrAndAndOr: …` - `or_: Iterable[FiltersOrOrOrOrAndAndOrOrAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndOrOrAndAndAnd: …` - `and_: Iterable[FiltersOrOrOrOrAndAndOrOrAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndAnd: …` - `and_: Iterable[FiltersOrOrOrOrAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndAndAndOr: …` - `or_: Iterable[FiltersOrOrOrOrAndAndAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndAndAndOrOrOr: …` - `or_: Iterable[FiltersOrOrOrOrAndAndAndAndOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndAndAndOrOrAnd: …` - `and_: Iterable[FiltersOrOrOrOrAndAndAndAndOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndAndAndAnd: …` - `and_: Iterable[FiltersOrOrOrOrAndAndAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndAndAndAndAndOr: …` - `or_: Iterable[FiltersOrOrOrOrAndAndAndAndAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrOrOrAndAndAndAndAndAndAnd: …` - `and_: Iterable[FiltersOrOrOrOrAndAndAndAndAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAnd: …` - `and_: Iterable[FiltersOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOr: …` - `or_: Iterable[FiltersOrOrAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrOr: …` - `or_: Iterable[FiltersOrOrAndAndOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrOrOrOr: …` - `or_: Iterable[FiltersOrOrAndAndOrOrOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrOrOrOrOrOr: …` - `or_: Iterable[FiltersOrOrAndAndOrOrOrOrOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrOrOrOrOrAnd: …` - `and_: Iterable[FiltersOrOrAndAndOrOrOrOrOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrOrOrAnd: …` - `and_: Iterable[FiltersOrOrAndAndOrOrOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrOrOrAndAndOr: …` - `or_: Iterable[FiltersOrOrAndAndOrOrOrOrAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrOrOrAndAndAnd: …` - `and_: Iterable[FiltersOrOrAndAndOrOrOrOrAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrAnd: …` - `and_: Iterable[FiltersOrOrAndAndOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrAndAndOr: …` - `or_: Iterable[FiltersOrOrAndAndOrOrAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrAndAndOrOrOr: …` - `or_: Iterable[FiltersOrOrAndAndOrOrAndAndOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrAndAndOrOrAnd: …` - `and_: Iterable[FiltersOrOrAndAndOrOrAndAndOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrAndAndAnd: …` - `and_: Iterable[FiltersOrOrAndAndOrOrAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrAndAndAndAndOr: …` - `or_: Iterable[FiltersOrOrAndAndOrOrAndAndAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndOrOrAndAndAndAndAnd: …` - `and_: Iterable[FiltersOrOrAndAndOrOrAndAndAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAnd: …` - `and_: Iterable[FiltersOrOrAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndOr: …` - `or_: Iterable[FiltersOrOrAndAndAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndOrOrOr: …` - `or_: Iterable[FiltersOrOrAndAndAndAndOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndOrOrOrOrOr: …` - `or_: Iterable[FiltersOrOrAndAndAndAndOrOrOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndOrOrOrOrAnd: …` - `and_: Iterable[FiltersOrOrAndAndAndAndOrOrOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndOrOrAnd: …` - `and_: Iterable[FiltersOrOrAndAndAndAndOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndOrOrAndAndOr: …` - `or_: Iterable[FiltersOrOrAndAndAndAndOrOrAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndOrOrAndAndAnd: …` - `and_: Iterable[FiltersOrOrAndAndAndAndOrOrAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndAnd: …` - `and_: Iterable[FiltersOrOrAndAndAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndAndAndOr: …` - `or_: Iterable[FiltersOrOrAndAndAndAndAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndAndAndOrOrOr: …` - `or_: Iterable[FiltersOrOrAndAndAndAndAndAndOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndAndAndOrOrAnd: …` - `and_: Iterable[FiltersOrOrAndAndAndAndAndAndOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndAndAndAnd: …` - `and_: Iterable[FiltersOrOrAndAndAndAndAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndAndAndAndAndOr: …` - `or_: Iterable[FiltersOrOrAndAndAndAndAndAndAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersOrOrAndAndAndAndAndAndAndAndAnd: …` - `and_: Iterable[FiltersOrOrAndAndAndAndAndAndAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAnd: …` - `and_: Iterable[FiltersAndAnd]` Array of AND filter expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOr: …` - `or_: Iterable[FiltersAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOr: …` - `or_: Iterable[FiltersAndAndOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrOr: …` - `or_: Iterable[FiltersAndAndOrOrOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrOrOrOr: …` - `or_: Iterable[FiltersAndAndOrOrOrOrOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrOrOrOrOrOr: …` - `or_: Iterable[FiltersAndAndOrOrOrOrOrOrOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrOrOrOrOrAnd: …` - `and_: Iterable[FiltersAndAndOrOrOrOrOrOrOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrOrOrAnd: …` - `and_: Iterable[FiltersAndAndOrOrOrOrOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrOrOrAndAndOr: …` - `or_: Iterable[FiltersAndAndOrOrOrOrOrOrAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrOrOrAndAndAnd: …` - `and_: Iterable[FiltersAndAndOrOrOrOrOrOrAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrAnd: …` - `and_: Iterable[FiltersAndAndOrOrOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrAndAndOr: …` - `or_: Iterable[FiltersAndAndOrOrOrOrAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrAndAndOrOrOr: …` - `or_: Iterable[FiltersAndAndOrOrOrOrAndAndOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrAndAndOrOrAnd: …` - `and_: Iterable[FiltersAndAndOrOrOrOrAndAndOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrAndAndAnd: …` - `and_: Iterable[FiltersAndAndOrOrOrOrAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrAndAndAndAndOr: …` - `or_: Iterable[FiltersAndAndOrOrOrOrAndAndAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrOrOrAndAndAndAndAnd: …` - `and_: Iterable[FiltersAndAndOrOrOrOrAndAndAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAnd: …` - `and_: Iterable[FiltersAndAndOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndOr: …` - `or_: Iterable[FiltersAndAndOrOrAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndOrOrOr: …` - `or_: Iterable[FiltersAndAndOrOrAndAndOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndOrOrOrOrOr: …` - `or_: Iterable[FiltersAndAndOrOrAndAndOrOrOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndOrOrOrOrAnd: …` - `and_: Iterable[FiltersAndAndOrOrAndAndOrOrOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndOrOrAnd: …` - `and_: Iterable[FiltersAndAndOrOrAndAndOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndOrOrAndAndOr: …` - `or_: Iterable[FiltersAndAndOrOrAndAndOrOrAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndOrOrAndAndAnd: …` - `and_: Iterable[FiltersAndAndOrOrAndAndOrOrAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndAnd: …` - `and_: Iterable[FiltersAndAndOrOrAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndAndAndOr: …` - `or_: Iterable[FiltersAndAndOrOrAndAndAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndAndAndOrOrOr: …` - `or_: Iterable[FiltersAndAndOrOrAndAndAndAndOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndAndAndOrOrAnd: …` - `and_: Iterable[FiltersAndAndOrOrAndAndAndAndOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndAndAndAnd: …` - `and_: Iterable[FiltersAndAndOrOrAndAndAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndAndAndAndAndOr: …` - `or_: Iterable[FiltersAndAndOrOrAndAndAndAndAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndOrOrAndAndAndAndAndAndAnd: …` - `and_: Iterable[FiltersAndAndOrOrAndAndAndAndAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAnd: …` - `and_: Iterable[FiltersAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOr: …` - `or_: Iterable[FiltersAndAndAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrOr: …` - `or_: Iterable[FiltersAndAndAndAndOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrOrOrOr: …` - `or_: Iterable[FiltersAndAndAndAndOrOrOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrOrOrOrOrOr: …` - `or_: Iterable[FiltersAndAndAndAndOrOrOrOrOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrOrOrOrOrAnd: …` - `and_: Iterable[FiltersAndAndAndAndOrOrOrOrOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrOrOrAnd: …` - `and_: Iterable[FiltersAndAndAndAndOrOrOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrOrOrAndAndOr: …` - `or_: Iterable[FiltersAndAndAndAndOrOrOrOrAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrOrOrAndAndAnd: …` - `and_: Iterable[FiltersAndAndAndAndOrOrOrOrAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrAnd: …` - `and_: Iterable[FiltersAndAndAndAndOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrAndAndOr: …` - `or_: Iterable[FiltersAndAndAndAndOrOrAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrAndAndOrOrOr: …` - `or_: Iterable[FiltersAndAndAndAndOrOrAndAndOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrAndAndOrOrAnd: …` - `and_: Iterable[FiltersAndAndAndAndOrOrAndAndOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrAndAndAnd: …` - `and_: Iterable[FiltersAndAndAndAndOrOrAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrAndAndAndAndOr: …` - `or_: Iterable[FiltersAndAndAndAndOrOrAndAndAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndOrOrAndAndAndAndAnd: …` - `and_: Iterable[FiltersAndAndAndAndOrOrAndAndAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAnd: …` - `and_: Iterable[FiltersAndAndAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndOr: …` - `or_: Iterable[FiltersAndAndAndAndAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndOrOrOr: …` - `or_: Iterable[FiltersAndAndAndAndAndAndOrOrOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndOrOrOrOrOr: …` - `or_: Iterable[FiltersAndAndAndAndAndAndOrOrOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndOrOrOrOrAnd: …` - `and_: Iterable[FiltersAndAndAndAndAndAndOrOrOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndOrOrAnd: …` - `and_: Iterable[FiltersAndAndAndAndAndAndOrOrAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndOrOrAndAndOr: …` - `or_: Iterable[FiltersAndAndAndAndAndAndOrOrAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndOrOrAndAndAnd: …` - `and_: Iterable[FiltersAndAndAndAndAndAndOrOrAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndAnd: …` - `and_: Iterable[FiltersAndAndAndAndAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndAndAndOr: …` - `or_: Iterable[FiltersAndAndAndAndAndAndAndAndOrOr]` OR: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndAndAndOrOrOr: …` - `or_: Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndAndAndOrOrAnd: …` - `and_: Iterable[FiltersAndAndAndAndAndAndAndAndOrOrAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndAndAndAnd: …` - `and_: Iterable[FiltersAndAndAndAndAndAndAndAndAndAnd]` AND: Array of conditions or nested expressions - `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"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndAndAndAndAndOr: …` - `or_: Iterable[FiltersAndAndAndAndAndAndAndAndAndAndOrOr]` OR: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `class FiltersAndAndAndAndAndAndAndAndAndAndAnd: …` - `and_: Iterable[FiltersAndAndAndAndAndAndAndAndAndAndAndAnd]` AND: Array of conditions - `key: str` - `value: str` - `filter_type: Optional[Literal["metadata", "numeric", "array_contains", "string_contains"]]` - `"metadata"` - `"numeric"` - `"array_contains"` - `"string_contains"` - `ignore_case: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `negate: Optional[Union[bool, Literal["true", "false"]]]` - `bool` - `Literal["true", "false"]` - `"true"` - `"false"` - `numeric_operator: Optional[Literal[">", "<", ">=", 2 more]]` - `">"` - `"<"` - `">="` - `"<="` - `"="` - `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 - `str` - `float` - `order: Optional[Literal["asc", "desc"]]` Sort order - `"asc"` - `"desc"` - `page: Optional[Union[str, float]]` Page number to fetch - `str` - `float` - `sort: Optional[Literal["createdAt", "updatedAt"]]` Field to sort by - `"createdAt"` - `"updatedAt"` ### Returns - `class DocumentListResponse: …` List of documents - `memories: List[Memory]` - `id: str` Unique identifier of the document. - `connection_id: Optional[str]` Optional ID of connection the document was created from. This is useful for identifying the source of the document. - `created_at: str` Creation timestamp - `custom_id: Optional[str]` Optional custom ID of the document. This could be an ID from your database that will uniquely identify this document. - `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. - `str` - `float` - `bool` - `Dict[str, object]` - `List[object]` - `status: Literal["unknown", "queued", "extracting", 5 more]` Status of the document - `"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 - `"text"` - `"pdf"` - `"tweet"` - `"google_doc"` - `"google_slide"` - `"google_sheet"` - `"image"` - `"video"` - `"audio"` - `"notion_doc"` - `"webpage"` - `"onedrive"` - `"github_markdown"` - `updated_at: str` Last update timestamp - `container_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 - `pagination: Pagination` Pagination metadata - `current_page: float` - `total_items: float` - `total_pages: float` - `limit: Optional[float]` ### Example ```python import os from supermemory import Supermemory client = Supermemory( api_key=os.environ.get("SUPERMEMORY_API_KEY"), # This is the default and can be omitted ) documents = client.documents.list() print(documents.memories) ``` #### Response ```json { "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 } } ``` ## Update document `documents.update(strid, DocumentUpdateParams**kwargs) -> DocumentUpdateResponse` **patch** `/v3/documents/{id}` Update a document with any content type (text, url, file, etc.) and metadata ### Parameters - `id: str` - `container_tag: Optional[str]` Optional tag 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. - `container_tags: Optional[Sequence[str]]` (DEPRECATED: Use containerTag instead) 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]` The content to extract and process into a document. This can be a URL to a website, a PDF, an image, or a video. Plaintext: Any plaintext format URL: A URL to a website, PDF, image, or video We automatically detect the content type from the url's response format. - `custom_id: Optional[str]` Optional custom ID of the document. This could be an ID from your database that will uniquely identify this document. - `filepath: Optional[str]` Optional file path for the document (e.g., '/documents/reports/file.pdf'). Used by supermemoryfs to map documents to filesystem paths. - `filter_by_metadata: Optional[Dict[str, Union[str, float, bool, Sequence[str]]]]` Optional metadata filter scoping which existing memories are pulled as context during ingestion. Scalar values match exactly (AND across keys); array values match ANY (OR within key). Only memories whose source documents match this filter are used as context. - `str` - `float` - `bool` - `Sequence[str]` - `metadata: Optional[Dict[str, Union[str, float, bool, Sequence[str]]]]` 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. - `str` - `float` - `bool` - `Sequence[str]` - `task_type: Optional[Literal["memory", "superrag"]]` Task type: "memory" (default) for full context layer with SuperRAG built in, "superrag" for managed RAG as a service. - `"memory"` - `"superrag"` ### Returns - `class DocumentUpdateResponse: …` - `id: str` Unique identifier of the document - `status: str` Status of the document ### Example ```python import os from supermemory import Supermemory client = Supermemory( api_key=os.environ.get("SUPERMEMORY_API_KEY"), # This is the default and can be omitted ) document = client.documents.update( id="id", ) print(document.id) ``` #### Response ```json { "id": "id", "status": "status" } ``` ## Get document `documents.get(strid) -> DocumentGetResponse` **get** `/v3/documents/{id}` Get a document by ID ### Parameters - `id: str` ### Returns - `class DocumentGetResponse: …` Document object - `id: str` Unique identifier of the document. - `connection_id: Optional[str]` Optional ID of connection the document was created from. This is useful for identifying the source of the document. - `content: Optional[str]` The content to extract and process into a document. This can be a URL to a website, a PDF, an image, or a video. Plaintext: Any plaintext format URL: A URL to a website, PDF, image, or video We automatically detect the content type from the url's response format. - `created_at: str` Creation timestamp - `custom_id: Optional[str]` Optional custom ID of the document. This could be an ID from your database that will uniquely identify this document. - `dreaming_status: Literal["dreaming", "done"]` - `"dreaming"` - `"done"` - `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. - `str` - `float` - `bool` - `Dict[str, object]` - `List[object]` - `og_image: Optional[str]` - `raw: object` Raw content of the document - `source: Optional[str]` Source of the document - `status: Literal["unknown", "queued", "extracting", 5 more]` Status of the document - `"unknown"` - `"queued"` - `"extracting"` - `"chunking"` - `"embedding"` - `"indexing"` - `"done"` - `"failed"` - `summary: Optional[str]` Summary of the document content - `task_type: Literal["memory", "superrag"]` Task type: "memory" (default) for full context layer with SuperRAG built in, "superrag" for managed RAG as a service. - `"memory"` - `"superrag"` - `title: Optional[str]` Title of the document - `type: Literal["text", "pdf", "tweet", 10 more]` Type of the document - `"text"` - `"pdf"` - `"tweet"` - `"google_doc"` - `"google_slide"` - `"google_sheet"` - `"image"` - `"video"` - `"audio"` - `"notion_doc"` - `"webpage"` - `"onedrive"` - `"github_markdown"` - `updated_at: str` Last update timestamp - `container_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. - `url: Optional[str]` URL of the document ### Example ```python import os from supermemory import Supermemory client = Supermemory( api_key=os.environ.get("SUPERMEMORY_API_KEY"), # This is the default and can be omitted ) document = client.documents.get( "id", ) print(document.id) ``` #### Response ```json { "id": "acxV5LHMEsG2hMSNb4umbn", "connectionId": "xxxxxxxxxxxxxxxxxxxxxx", "content": "Our API rate limits are 100 req/min on free and 1000 on pro.", "createdAt": "2025-04-15T09:30:00.000Z", "customId": "doc-api-rate-limits", "dreamingStatus": "dreaming", "filepath": "filepath", "metadata": { "source": "bar", "language": "bar" }, "ogImage": "ogImage", "raw": "Our API rate limits are 100 req/min on free and 1000 on pro. Clients should use exponential backoff on 429s.", "source": "text", "status": "done", "summary": "API rate limit policy: 100 req/min free, 1000 req/min pro.", "taskType": "memory", "title": "API Rate Limiting Policy", "type": "text", "updatedAt": "2025-04-15T09:31:00.000Z", "containerTags": [ "string" ], "url": "https://docs.example.com/guides/rate-limits" } ``` ## Delete document by ID or customId `documents.delete(strid)` **delete** `/v3/documents/{id}` Delete a document by ID or customId ### Parameters - `id: str` ### Example ```python import os from supermemory import Supermemory client = Supermemory( api_key=os.environ.get("SUPERMEMORY_API_KEY"), # This is the default and can be omitted ) client.documents.delete( "id", ) ``` ## Bulk delete documents `documents.delete_bulk(DocumentDeleteBulkParams**kwargs) -> DocumentDeleteBulkResponse` **delete** `/v3/documents/bulk` Bulk delete documents by IDs or container tags ### Parameters - `container_tags: Optional[Sequence[str]]` Array of container tags - all documents in these containers will be deleted - `filepath: Optional[str]` Delete documents matching this filepath. Exact match for full paths, prefix match if ending with / - `ids: Optional[Sequence[str]]` Array of document IDs to delete (max 100 at once) ### Returns - `class DocumentDeleteBulkResponse: …` Response for bulk document deletion - `deleted_count: float` Number of documents successfully deleted - `success: bool` Whether the bulk deletion was successful - `container_tags: Optional[List[str]]` Container tags that were processed (only applicable when deleting by container tags) - `errors: Optional[List[Error]]` Array of errors for documents that couldn't be deleted (only applicable when deleting by IDs) - `id: str` - `error: str` ### Example ```python import os from supermemory import Supermemory client = Supermemory( api_key=os.environ.get("SUPERMEMORY_API_KEY"), # This is the default and can be omitted ) response = client.documents.delete_bulk() print(response.deleted_count) ``` #### Response ```json { "deletedCount": 2, "success": true, "containerTags": [ "string" ], "errors": [ { "id": "id", "error": "error" } ] } ``` ## Upload a file `documents.upload_file(DocumentUploadFileParams**kwargs) -> DocumentUploadFileResponse` **post** `/v3/documents/file` Upload a file to be processed ### Parameters - `file: FileTypes` File to upload and process - `container_tag: Optional[str]` Optional container tag (e.g., 'user_123'). Use this for a single tag. - `container_tags: Optional[str]` Optional container tags. Can be either a JSON string of an array (e.g., '["user_123", "project_123"]') or a single string (e.g., 'user_123'). Single strings will be automatically converted to an array. - `custom_id: Optional[str]` Optional custom ID of the document. Max 100 characters, alphanumeric with hyphens, underscores, and colons only. - `entity_context: Optional[str]` Optional entity context for this container tag. Max 1500 characters. Used during document processing to guide memory extraction. - `filepath: Optional[str]` Optional file path for the uploaded file (e.g., '/documents/reports/file.pdf'). Used by supermemoryfs to map documents to filesystem paths. - `file_type: Optional[str]` Optional file type override to force specific processing behavior. Valid values: text, pdf, tweet, google_doc, google_slide, google_sheet, image, video, notion_doc, webpage, onedrive - `filter_by_metadata: Optional[str]` Optional metadata filter as a JSON string. Scopes which existing memories are pulled as context during ingestion. Scalar values match exactly (AND across keys); array values match ANY (OR within key). - `metadata: Optional[str]` Optional metadata for the document as a JSON string. This is used to store additional information about the document. Keys must be strings and values can be strings, numbers, or booleans. - `mime_type: Optional[str]` Required when fileType is 'image' or 'video'. Specifies the exact MIME type to use (e.g., 'image/png', 'image/jpeg', 'video/mp4', 'video/webm') - `task_type: Optional[Literal["memory", "superrag"]]` Task type: "memory" (default) for full context layer with SuperRAG built in, "superrag" for managed RAG as a service. - `"memory"` - `"superrag"` - `use_advanced_processing: Optional[str]` DEPRECATED: This field is no longer used. Advanced PDF processing is now automatic with our hybrid Mistral OCR + Gemini pipeline. This parameter will be accepted but ignored for backwards compatibility. ### Returns - `class DocumentUploadFileResponse: …` - `id: str` Unique identifier of the document - `status: str` Status of the document ### Example ```python import os from supermemory import Supermemory client = Supermemory( api_key=os.environ.get("SUPERMEMORY_API_KEY"), # This is the default and can be omitted ) response = client.documents.upload_file( file=b"Example data", ) print(response.id) ``` #### Response ```json { "id": "id", "status": "status" } ``` ## Batch add documents `documents.batch_add(DocumentBatchAddParams**kwargs) -> DocumentBatchAddResponse` **post** `/v3/documents/batch` Add multiple documents in a single request. Each document can have any content type (text, url, file, etc.) and metadata ### Parameters - `documents: Union[Iterable[DocumentsUnionMember0], Sequence[str]]` - `Iterable[DocumentsUnionMember0]` - `content: str` The content to extract and process into a document. This can be a URL to a website, a PDF, an image, or a video. Plaintext: Any plaintext format URL: A URL to a website, PDF, image, or video We automatically detect the content type from the url's response format. - `container_tag: Optional[str]` Optional tag 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. - `container_tags: Optional[Sequence[str]]` (DEPRECATED: Use containerTag instead) 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. - `custom_id: Optional[str]` Optional custom ID of the document. This could be an ID from your database that will uniquely identify this document. - `entity_context: Optional[str]` Optional entity context for this container tag. Max 1500 characters. Used during document processing to guide memory extraction. - `filepath: Optional[str]` Optional file path for the document (e.g., '/documents/reports/file.pdf'). Used by supermemoryfs to map documents to filesystem paths. - `filter_by_metadata: Optional[Dict[str, Union[str, float, bool, Sequence[str]]]]` Optional metadata filter scoping which existing memories are pulled as context during ingestion. Scalar values match exactly (AND across keys); array values match ANY (OR within key). Only memories whose source documents match this filter are used as context. - `str` - `float` - `bool` - `Sequence[str]` - `metadata: Optional[Dict[str, Union[str, float, bool, Sequence[str]]]]` 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. - `str` - `float` - `bool` - `Sequence[str]` - `task_type: Optional[Literal["memory", "superrag"]]` Task type: "memory" (default) for full context layer with SuperRAG built in, "superrag" for managed RAG as a service. - `"memory"` - `"superrag"` - `Sequence[str]` - `container_tag: Optional[str]` Optional tag 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. - `container_tags: Optional[Sequence[str]]` (DEPRECATED: Use containerTag instead) 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[None]` - `entity_context: Optional[str]` Optional entity context for this container tag. Max 1500 characters. Used during document processing to guide memory extraction. - `filepath: Optional[str]` Optional file path for the document (e.g., '/documents/reports/file.pdf'). Used by supermemoryfs to map documents to filesystem paths. - `filter_by_metadata: Optional[Dict[str, Union[str, float, bool, Sequence[str]]]]` Optional metadata filter scoping which existing memories are pulled as context during ingestion. Scalar values match exactly (AND across keys); array values match ANY (OR within key). Only memories whose source documents match this filter are used as context. - `str` - `float` - `bool` - `Sequence[str]` - `metadata: Optional[Dict[str, Union[str, float, bool, Sequence[str]]]]` 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. - `str` - `float` - `bool` - `Sequence[str]` - `task_type: Optional[Literal["memory", "superrag"]]` Task type: "memory" (default) for full context layer with SuperRAG built in, "superrag" for managed RAG as a service. - `"memory"` - `"superrag"` ### Returns - `class DocumentBatchAddResponse: …` - `failed: float` Count of documents that failed to add - `results: List[Result]` Array of results for each document in the batch - `id: str` Unique identifier of the document (empty string for failed items) - `status: str` Status of the document (e.g. 'done', 'queued', 'error') - `details: Optional[str]` Additional error details when status is 'error' - `error: Optional[str]` Error message when status is 'error' - `success: float` Count of documents successfully added ### Example ```python import os from supermemory import Supermemory client = Supermemory( api_key=os.environ.get("SUPERMEMORY_API_KEY"), # This is the default and can be omitted ) response = client.documents.batch_add( documents=[{ "content": "Our API rate limits are 100 req/min on free and 1000 on pro. Clients should use exponential backoff on 429s." }], ) print(response.failed) ``` #### Response ```json { "failed": 0, "results": [ { "id": "id", "status": "status", "details": "details", "error": "error" } ], "success": 0 } ``` ## Get processing documents `documents.list_processing() -> DocumentListProcessingResponse` **get** `/v3/documents/processing` Get documents that are currently being processed ### Returns - `class DocumentListProcessingResponse: …` List of documents currently being processed - `documents: List[Document]` - `id: str` Unique identifier of the document. - `created_at: str` Creation timestamp - `custom_id: Optional[str]` Optional custom ID of the document. This could be an ID from your database that will uniquely identify this document. - `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. - `str` - `float` - `bool` - `Dict[str, object]` - `List[object]` - `status: Literal["unknown", "queued", "extracting", 5 more]` Status of the document - `"unknown"` - `"queued"` - `"extracting"` - `"chunking"` - `"embedding"` - `"indexing"` - `"done"` - `"failed"` - `title: Optional[str]` Title of the document - `type: Literal["text", "pdf", "tweet", 10 more]` Type of the document - `"text"` - `"pdf"` - `"tweet"` - `"google_doc"` - `"google_slide"` - `"google_sheet"` - `"image"` - `"video"` - `"audio"` - `"notion_doc"` - `"webpage"` - `"onedrive"` - `"github_markdown"` - `updated_at: str` Last update timestamp - `container_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. - `total_count: float` Total number of processing documents ### Example ```python import os from supermemory import Supermemory client = Supermemory( api_key=os.environ.get("SUPERMEMORY_API_KEY"), # This is the default and can be omitted ) response = client.documents.list_processing() print(response.documents) ``` #### Response ```json { "documents": [ { "id": "xxxxxxxxxxxxxxxxxxxxxx", "createdAt": "2024-12-27T12:00:00Z", "customId": "doc-api-rate-limits", "metadata": { "source": "bar", "language": "bar" }, "status": "extracting", "title": "My Document", "type": "text", "updatedAt": "2024-12-27T12:01:00Z", "containerTags": [ "string" ] } ], "totalCount": 5 } ``` ## Domain Types ### Document Add Response - `class DocumentAddResponse: …` - `id: str` Unique identifier of the document - `status: str` Status of the document ### Document List Response - `class DocumentListResponse: …` List of documents - `memories: List[Memory]` - `id: str` Unique identifier of the document. - `connection_id: Optional[str]` Optional ID of connection the document was created from. This is useful for identifying the source of the document. - `created_at: str` Creation timestamp - `custom_id: Optional[str]` Optional custom ID of the document. This could be an ID from your database that will uniquely identify this document. - `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. - `str` - `float` - `bool` - `Dict[str, object]` - `List[object]` - `status: Literal["unknown", "queued", "extracting", 5 more]` Status of the document - `"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 - `"text"` - `"pdf"` - `"tweet"` - `"google_doc"` - `"google_slide"` - `"google_sheet"` - `"image"` - `"video"` - `"audio"` - `"notion_doc"` - `"webpage"` - `"onedrive"` - `"github_markdown"` - `updated_at: str` Last update timestamp - `container_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 - `pagination: Pagination` Pagination metadata - `current_page: float` - `total_items: float` - `total_pages: float` - `limit: Optional[float]` ### Document Update Response - `class DocumentUpdateResponse: …` - `id: str` Unique identifier of the document - `status: str` Status of the document ### Document Get Response - `class DocumentGetResponse: …` Document object - `id: str` Unique identifier of the document. - `connection_id: Optional[str]` Optional ID of connection the document was created from. This is useful for identifying the source of the document. - `content: Optional[str]` The content to extract and process into a document. This can be a URL to a website, a PDF, an image, or a video. Plaintext: Any plaintext format URL: A URL to a website, PDF, image, or video We automatically detect the content type from the url's response format. - `created_at: str` Creation timestamp - `custom_id: Optional[str]` Optional custom ID of the document. This could be an ID from your database that will uniquely identify this document. - `dreaming_status: Literal["dreaming", "done"]` - `"dreaming"` - `"done"` - `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. - `str` - `float` - `bool` - `Dict[str, object]` - `List[object]` - `og_image: Optional[str]` - `raw: object` Raw content of the document - `source: Optional[str]` Source of the document - `status: Literal["unknown", "queued", "extracting", 5 more]` Status of the document - `"unknown"` - `"queued"` - `"extracting"` - `"chunking"` - `"embedding"` - `"indexing"` - `"done"` - `"failed"` - `summary: Optional[str]` Summary of the document content - `task_type: Literal["memory", "superrag"]` Task type: "memory" (default) for full context layer with SuperRAG built in, "superrag" for managed RAG as a service. - `"memory"` - `"superrag"` - `title: Optional[str]` Title of the document - `type: Literal["text", "pdf", "tweet", 10 more]` Type of the document - `"text"` - `"pdf"` - `"tweet"` - `"google_doc"` - `"google_slide"` - `"google_sheet"` - `"image"` - `"video"` - `"audio"` - `"notion_doc"` - `"webpage"` - `"onedrive"` - `"github_markdown"` - `updated_at: str` Last update timestamp - `container_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. - `url: Optional[str]` URL of the document ### Document Delete Bulk Response - `class DocumentDeleteBulkResponse: …` Response for bulk document deletion - `deleted_count: float` Number of documents successfully deleted - `success: bool` Whether the bulk deletion was successful - `container_tags: Optional[List[str]]` Container tags that were processed (only applicable when deleting by container tags) - `errors: Optional[List[Error]]` Array of errors for documents that couldn't be deleted (only applicable when deleting by IDs) - `id: str` - `error: str` ### Document Upload File Response - `class DocumentUploadFileResponse: …` - `id: str` Unique identifier of the document - `status: str` Status of the document ### Document Batch Add Response - `class DocumentBatchAddResponse: …` - `failed: float` Count of documents that failed to add - `results: List[Result]` Array of results for each document in the batch - `id: str` Unique identifier of the document (empty string for failed items) - `status: str` Status of the document (e.g. 'done', 'queued', 'error') - `details: Optional[str]` Additional error details when status is 'error' - `error: Optional[str]` Error message when status is 'error' - `success: float` Count of documents successfully added ### Document List Processing Response - `class DocumentListProcessingResponse: …` List of documents currently being processed - `documents: List[Document]` - `id: str` Unique identifier of the document. - `created_at: str` Creation timestamp - `custom_id: Optional[str]` Optional custom ID of the document. This could be an ID from your database that will uniquely identify this document. - `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. - `str` - `float` - `bool` - `Dict[str, object]` - `List[object]` - `status: Literal["unknown", "queued", "extracting", 5 more]` Status of the document - `"unknown"` - `"queued"` - `"extracting"` - `"chunking"` - `"embedding"` - `"indexing"` - `"done"` - `"failed"` - `title: Optional[str]` Title of the document - `type: Literal["text", "pdf", "tweet", 10 more]` Type of the document - `"text"` - `"pdf"` - `"tweet"` - `"google_doc"` - `"google_slide"` - `"google_sheet"` - `"image"` - `"video"` - `"audio"` - `"notion_doc"` - `"webpage"` - `"onedrive"` - `"github_markdown"` - `updated_at: str` Last update timestamp - `container_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. - `total_count: float` Total number of processing documents