diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 1887bd5..fdd6f7b 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "3.22.0" + ".": "3.23.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index e8722d3..271ce3b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 26 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-c52fac62512bd29d68804cbd226eebe5ad4e6b07a94a0db480e89d0049293e6e.yml -openapi_spec_hash: 655aacb90af901248f2629ede34595da -config_hash: 4bcc46df5333a2be6812a59a40afdb5e +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/supermemory--inc%2Fsupermemory-new-be1ac03255352670ab9b550b6c938f991f3ded14f693bfee49085dab89f99ba6.yml +openapi_spec_hash: ca737bc317ef5d149a555729553d6b97 +config_hash: f3eb5ca71172780678106f6d46f15dda diff --git a/CHANGELOG.md b/CHANGELOG.md index 7ec9944..1b772d2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 3.23.0 (2026-02-04) + +Full Changelog: [v3.22.0...v3.23.0](https://github.com/supermemoryai/python-sdk/compare/v3.22.0...v3.23.0) + +### Features + +* **api:** manual updates ([a3004d4](https://github.com/supermemoryai/python-sdk/commit/a3004d4d01562d4eb38367a6e0a5f42ca9d4bdf7)) + ## 3.22.0 (2026-02-03) Full Changelog: [v3.21.0...v3.22.0](https://github.com/supermemoryai/python-sdk/compare/v3.21.0...v3.22.0) diff --git a/README.md b/README.md index d389a43..e353e70 100644 --- a/README.md +++ b/README.md @@ -147,7 +147,7 @@ from supermemory import Supermemory client = Supermemory() -client.memories.upload_file( +client.documents.upload_file( file=Path("/path/to/file"), ) ``` diff --git a/api.md b/api.md index 84da60e..b762ddd 100644 --- a/api.md +++ b/api.md @@ -16,27 +16,13 @@ Methods: Types: ```python -from supermemory.types import ( - MemoryUpdateResponse, - MemoryListResponse, - MemoryAddResponse, - MemoryForgetResponse, - MemoryGetResponse, - MemoryUpdateMemoryResponse, - MemoryUploadFileResponse, -) +from supermemory.types import MemoryForgetResponse, MemoryUpdateMemoryResponse ``` Methods: -- client.memories.update(id, \*\*params) -> MemoryUpdateResponse -- client.memories.list(\*\*params) -> MemoryListResponse -- client.memories.delete(id) -> None -- client.memories.add(\*\*params) -> MemoryAddResponse - client.memories.forget(\*\*params) -> MemoryForgetResponse -- client.memories.get(id) -> MemoryGetResponse - client.memories.update_memory(\*\*params) -> MemoryUpdateMemoryResponse -- client.memories.upload_file(\*\*params) -> MemoryUploadFileResponse # Documents diff --git a/pyproject.toml b/pyproject.toml index 76db257..64c0e68 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "supermemory" -version = "3.22.0" +version = "3.23.0" description = "The official Python library for the supermemory API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/supermemory/_version.py b/src/supermemory/_version.py index befc3e6..a57352f 100644 --- a/src/supermemory/_version.py +++ b/src/supermemory/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "supermemory" -__version__ = "3.22.0" # x-release-please-version +__version__ = "3.23.0" # x-release-please-version diff --git a/src/supermemory/resources/memories.py b/src/supermemory/resources/memories.py index 77d9830..3bb8710 100644 --- a/src/supermemory/resources/memories.py +++ b/src/supermemory/resources/memories.py @@ -2,21 +2,13 @@ from __future__ import annotations -from typing import Dict, Union, Mapping, cast -from typing_extensions import Literal +from typing import Dict, Union import httpx -from ..types import ( - memory_add_params, - memory_list_params, - memory_forget_params, - memory_update_params, - memory_upload_file_params, - memory_update_memory_params, -) -from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, FileTypes, SequenceNotStr, omit, not_given -from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform +from ..types import memory_forget_params, memory_update_memory_params +from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given +from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource from .._response import ( @@ -26,12 +18,7 @@ async_to_streamed_response_wrapper, ) from .._base_client import make_request_options -from ..types.memory_add_response import MemoryAddResponse -from ..types.memory_get_response import MemoryGetResponse -from ..types.memory_list_response import MemoryListResponse from ..types.memory_forget_response import MemoryForgetResponse -from ..types.memory_update_response import MemoryUpdateResponse -from ..types.memory_upload_file_response import MemoryUploadFileResponse from ..types.memory_update_memory_response import MemoryUpdateMemoryResponse __all__ = ["MemoriesResource", "AsyncMemoriesResource"] @@ -57,241 +44,6 @@ def with_streaming_response(self) -> MemoriesResourceWithStreamingResponse: """ return MemoriesResourceWithStreamingResponse(self) - def update( - self, - id: str, - *, - container_tag: str | Omit = omit, - container_tags: SequenceNotStr[str] | Omit = omit, - content: str | Omit = omit, - custom_id: str | Omit = omit, - metadata: Dict[str, Union[str, float, bool, SequenceNotStr[str]]] | Omit = omit, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> MemoryUpdateResponse: - """ - Update a document with any content type (text, url, file, etc.) and metadata - - Args: - container_tag: 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: (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: 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 custom ID of the document. This could be an ID from your database that - will uniquely identify this document. - - metadata: 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. - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not id: - raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") - return self._patch( - f"/v3/documents/{id}", - body=maybe_transform( - { - "container_tag": container_tag, - "container_tags": container_tags, - "content": content, - "custom_id": custom_id, - "metadata": metadata, - }, - memory_update_params.MemoryUpdateParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=MemoryUpdateResponse, - ) - - def list( - self, - *, - container_tags: SequenceNotStr[str] | Omit = omit, - filters: memory_list_params.Filters | Omit = omit, - include_content: bool | Omit = omit, - limit: Union[str, float] | Omit = omit, - order: Literal["asc", "desc"] | Omit = omit, - page: Union[str, float] | Omit = omit, - sort: Literal["createdAt", "updatedAt"] | Omit = omit, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> MemoryListResponse: - """ - Retrieves a paginated list of documents with their metadata and workflow status - - Args: - container_tags: 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. - - filters: Optional filters to apply to the search. Can be a JSON string or Query object. - - include_content: Whether to include the content field in the response. Warning: This can make - responses significantly larger. - - limit: Number of items per page - - order: Sort order - - page: Page number to fetch - - sort: Field to sort by - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - return self._post( - "/v3/documents/list", - body=maybe_transform( - { - "container_tags": container_tags, - "filters": filters, - "include_content": include_content, - "limit": limit, - "order": order, - "page": page, - "sort": sort, - }, - memory_list_params.MemoryListParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=MemoryListResponse, - ) - - def delete( - self, - id: str, - *, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> None: - """ - Delete a document by ID or customId - - Args: - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not id: - raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") - extra_headers = {"Accept": "*/*", **(extra_headers or {})} - return self._delete( - f"/v3/documents/{id}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=NoneType, - ) - - def add( - self, - *, - content: str, - container_tag: str | Omit = omit, - container_tags: SequenceNotStr[str] | Omit = omit, - custom_id: str | Omit = omit, - entity_context: str | Omit = omit, - metadata: Dict[str, Union[str, float, bool, SequenceNotStr[str]]] | Omit = omit, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> MemoryAddResponse: - """ - Add a document with any content type (text, url, file, etc.) and metadata - - Args: - content: 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 tag this document should be containerized by. Max 100 characters, - alphanumeric with hyphens and underscores only. - - custom_id: Optional custom ID of the document. Max 100 characters, alphanumeric with - hyphens and underscores only. - - entity_context: Optional entity context for this container tag. Max 1500 characters. Used during - document processing to guide memory extraction. - - metadata: Optional metadata for the document. - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - return self._post( - "/v3/documents", - body=maybe_transform( - { - "content": content, - "container_tag": container_tag, - "container_tags": container_tags, - "custom_id": custom_id, - "entity_context": entity_context, - "metadata": metadata, - }, - memory_add_params.MemoryAddParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=MemoryAddResponse, - ) - def forget( self, *, @@ -346,39 +98,6 @@ def forget( cast_to=MemoryForgetResponse, ) - def get( - self, - id: str, - *, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> MemoryGetResponse: - """ - Get a document by ID - - Args: - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not id: - raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") - return self._get( - f"/v3/documents/{id}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=MemoryGetResponse, - ) - def update_memory( self, *, @@ -437,81 +156,6 @@ def update_memory( cast_to=MemoryUpdateMemoryResponse, ) - def upload_file( - self, - *, - file: FileTypes, - container_tags: str | Omit = omit, - file_type: str | Omit = omit, - metadata: str | Omit = omit, - mime_type: str | Omit = omit, - use_advanced_processing: str | Omit = omit, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> MemoryUploadFileResponse: - """ - Upload a file to be processed - - Args: - file: File to upload and process - - container_tags: 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. - - file_type: - 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 - - metadata: 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: Required when fileType is 'image' or 'video'. Specifies the exact MIME type to - use (e.g., 'image/png', 'image/jpeg', 'video/mp4', 'video/webm') - - use_advanced_processing: 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. - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - body = deepcopy_minimal( - { - "file": file, - "container_tags": container_tags, - "file_type": file_type, - "metadata": metadata, - "mime_type": mime_type, - "use_advanced_processing": use_advanced_processing, - } - ) - files = extract_files(cast(Mapping[str, object], body), paths=[["file"]]) - # It should be noted that the actual Content-Type header that will be - # sent to the server will contain a `boundary` parameter, e.g. - # multipart/form-data; boundary=---abc-- - extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})} - return self._post( - "/v3/documents/file", - body=maybe_transform(body, memory_upload_file_params.MemoryUploadFileParams), - files=files, - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=MemoryUploadFileResponse, - ) - class AsyncMemoriesResource(AsyncAPIResource): @cached_property @@ -533,241 +177,6 @@ def with_streaming_response(self) -> AsyncMemoriesResourceWithStreamingResponse: """ return AsyncMemoriesResourceWithStreamingResponse(self) - async def update( - self, - id: str, - *, - container_tag: str | Omit = omit, - container_tags: SequenceNotStr[str] | Omit = omit, - content: str | Omit = omit, - custom_id: str | Omit = omit, - metadata: Dict[str, Union[str, float, bool, SequenceNotStr[str]]] | Omit = omit, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> MemoryUpdateResponse: - """ - Update a document with any content type (text, url, file, etc.) and metadata - - Args: - container_tag: 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: (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: 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 custom ID of the document. This could be an ID from your database that - will uniquely identify this document. - - metadata: 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. - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not id: - raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") - return await self._patch( - f"/v3/documents/{id}", - body=await async_maybe_transform( - { - "container_tag": container_tag, - "container_tags": container_tags, - "content": content, - "custom_id": custom_id, - "metadata": metadata, - }, - memory_update_params.MemoryUpdateParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=MemoryUpdateResponse, - ) - - async def list( - self, - *, - container_tags: SequenceNotStr[str] | Omit = omit, - filters: memory_list_params.Filters | Omit = omit, - include_content: bool | Omit = omit, - limit: Union[str, float] | Omit = omit, - order: Literal["asc", "desc"] | Omit = omit, - page: Union[str, float] | Omit = omit, - sort: Literal["createdAt", "updatedAt"] | Omit = omit, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> MemoryListResponse: - """ - Retrieves a paginated list of documents with their metadata and workflow status - - Args: - container_tags: 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. - - filters: Optional filters to apply to the search. Can be a JSON string or Query object. - - include_content: Whether to include the content field in the response. Warning: This can make - responses significantly larger. - - limit: Number of items per page - - order: Sort order - - page: Page number to fetch - - sort: Field to sort by - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - return await self._post( - "/v3/documents/list", - body=await async_maybe_transform( - { - "container_tags": container_tags, - "filters": filters, - "include_content": include_content, - "limit": limit, - "order": order, - "page": page, - "sort": sort, - }, - memory_list_params.MemoryListParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=MemoryListResponse, - ) - - async def delete( - self, - id: str, - *, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> None: - """ - Delete a document by ID or customId - - Args: - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not id: - raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") - extra_headers = {"Accept": "*/*", **(extra_headers or {})} - return await self._delete( - f"/v3/documents/{id}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=NoneType, - ) - - async def add( - self, - *, - content: str, - container_tag: str | Omit = omit, - container_tags: SequenceNotStr[str] | Omit = omit, - custom_id: str | Omit = omit, - entity_context: str | Omit = omit, - metadata: Dict[str, Union[str, float, bool, SequenceNotStr[str]]] | Omit = omit, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> MemoryAddResponse: - """ - Add a document with any content type (text, url, file, etc.) and metadata - - Args: - content: 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 tag this document should be containerized by. Max 100 characters, - alphanumeric with hyphens and underscores only. - - custom_id: Optional custom ID of the document. Max 100 characters, alphanumeric with - hyphens and underscores only. - - entity_context: Optional entity context for this container tag. Max 1500 characters. Used during - document processing to guide memory extraction. - - metadata: Optional metadata for the document. - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - return await self._post( - "/v3/documents", - body=await async_maybe_transform( - { - "content": content, - "container_tag": container_tag, - "container_tags": container_tags, - "custom_id": custom_id, - "entity_context": entity_context, - "metadata": metadata, - }, - memory_add_params.MemoryAddParams, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=MemoryAddResponse, - ) - async def forget( self, *, @@ -822,39 +231,6 @@ async def forget( cast_to=MemoryForgetResponse, ) - async def get( - self, - id: str, - *, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> MemoryGetResponse: - """ - Get a document by ID - - Args: - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not id: - raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") - return await self._get( - f"/v3/documents/{id}", - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=MemoryGetResponse, - ) - async def update_memory( self, *, @@ -913,197 +289,50 @@ async def update_memory( cast_to=MemoryUpdateMemoryResponse, ) - async def upload_file( - self, - *, - file: FileTypes, - container_tags: str | Omit = omit, - file_type: str | Omit = omit, - metadata: str | Omit = omit, - mime_type: str | Omit = omit, - use_advanced_processing: str | Omit = omit, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> MemoryUploadFileResponse: - """ - Upload a file to be processed - - Args: - file: File to upload and process - - container_tags: 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. - - file_type: - 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 - - metadata: 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: Required when fileType is 'image' or 'video'. Specifies the exact MIME type to - use (e.g., 'image/png', 'image/jpeg', 'video/mp4', 'video/webm') - - use_advanced_processing: 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. - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - body = deepcopy_minimal( - { - "file": file, - "container_tags": container_tags, - "file_type": file_type, - "metadata": metadata, - "mime_type": mime_type, - "use_advanced_processing": use_advanced_processing, - } - ) - files = extract_files(cast(Mapping[str, object], body), paths=[["file"]]) - # It should be noted that the actual Content-Type header that will be - # sent to the server will contain a `boundary` parameter, e.g. - # multipart/form-data; boundary=---abc-- - extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})} - return await self._post( - "/v3/documents/file", - body=await async_maybe_transform(body, memory_upload_file_params.MemoryUploadFileParams), - files=files, - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=MemoryUploadFileResponse, - ) - class MemoriesResourceWithRawResponse: def __init__(self, memories: MemoriesResource) -> None: self._memories = memories - self.update = to_raw_response_wrapper( - memories.update, - ) - self.list = to_raw_response_wrapper( - memories.list, - ) - self.delete = to_raw_response_wrapper( - memories.delete, - ) - self.add = to_raw_response_wrapper( - memories.add, - ) self.forget = to_raw_response_wrapper( memories.forget, ) - self.get = to_raw_response_wrapper( - memories.get, - ) self.update_memory = to_raw_response_wrapper( memories.update_memory, ) - self.upload_file = to_raw_response_wrapper( - memories.upload_file, - ) class AsyncMemoriesResourceWithRawResponse: def __init__(self, memories: AsyncMemoriesResource) -> None: self._memories = memories - self.update = async_to_raw_response_wrapper( - memories.update, - ) - self.list = async_to_raw_response_wrapper( - memories.list, - ) - self.delete = async_to_raw_response_wrapper( - memories.delete, - ) - self.add = async_to_raw_response_wrapper( - memories.add, - ) self.forget = async_to_raw_response_wrapper( memories.forget, ) - self.get = async_to_raw_response_wrapper( - memories.get, - ) self.update_memory = async_to_raw_response_wrapper( memories.update_memory, ) - self.upload_file = async_to_raw_response_wrapper( - memories.upload_file, - ) class MemoriesResourceWithStreamingResponse: def __init__(self, memories: MemoriesResource) -> None: self._memories = memories - self.update = to_streamed_response_wrapper( - memories.update, - ) - self.list = to_streamed_response_wrapper( - memories.list, - ) - self.delete = to_streamed_response_wrapper( - memories.delete, - ) - self.add = to_streamed_response_wrapper( - memories.add, - ) self.forget = to_streamed_response_wrapper( memories.forget, ) - self.get = to_streamed_response_wrapper( - memories.get, - ) self.update_memory = to_streamed_response_wrapper( memories.update_memory, ) - self.upload_file = to_streamed_response_wrapper( - memories.upload_file, - ) class AsyncMemoriesResourceWithStreamingResponse: def __init__(self, memories: AsyncMemoriesResource) -> None: self._memories = memories - self.update = async_to_streamed_response_wrapper( - memories.update, - ) - self.list = async_to_streamed_response_wrapper( - memories.list, - ) - self.delete = async_to_streamed_response_wrapper( - memories.delete, - ) - self.add = async_to_streamed_response_wrapper( - memories.add, - ) self.forget = async_to_streamed_response_wrapper( memories.forget, ) - self.get = async_to_streamed_response_wrapper( - memories.get, - ) self.update_memory = async_to_streamed_response_wrapper( memories.update_memory, ) - self.upload_file = async_to_streamed_response_wrapper( - memories.upload_file, - ) diff --git a/src/supermemory/types/__init__.py b/src/supermemory/types/__init__.py index 0cdef25..6b7b372 100644 --- a/src/supermemory/types/__init__.py +++ b/src/supermemory/types/__init__.py @@ -5,15 +5,9 @@ from .add_response import AddResponse as AddResponse from .profile_response import ProfileResponse as ProfileResponse from .client_add_params import ClientAddParams as ClientAddParams -from .memory_add_params import MemoryAddParams as MemoryAddParams -from .memory_list_params import MemoryListParams as MemoryListParams from .document_add_params import DocumentAddParams as DocumentAddParams -from .memory_add_response import MemoryAddResponse as MemoryAddResponse -from .memory_get_response import MemoryGetResponse as MemoryGetResponse from .document_list_params import DocumentListParams as DocumentListParams from .memory_forget_params import MemoryForgetParams as MemoryForgetParams -from .memory_list_response import MemoryListResponse as MemoryListResponse -from .memory_update_params import MemoryUpdateParams as MemoryUpdateParams from .setting_get_response import SettingGetResponse as SettingGetResponse from .client_profile_params import ClientProfileParams as ClientProfileParams from .document_add_response import DocumentAddResponse as DocumentAddResponse @@ -24,7 +18,6 @@ from .document_list_response import DocumentListResponse as DocumentListResponse from .document_update_params import DocumentUpdateParams as DocumentUpdateParams from .memory_forget_response import MemoryForgetResponse as MemoryForgetResponse -from .memory_update_response import MemoryUpdateResponse as MemoryUpdateResponse from .search_memories_params import SearchMemoriesParams as SearchMemoriesParams from .search_documents_params import SearchDocumentsParams as SearchDocumentsParams from .search_execute_response import SearchExecuteResponse as SearchExecuteResponse @@ -35,7 +28,6 @@ from .document_update_response import DocumentUpdateResponse as DocumentUpdateResponse from .search_memories_response import SearchMemoriesResponse as SearchMemoriesResponse from .document_batch_add_params import DocumentBatchAddParams as DocumentBatchAddParams -from .memory_upload_file_params import MemoryUploadFileParams as MemoryUploadFileParams from .search_documents_response import SearchDocumentsResponse as SearchDocumentsResponse from .connection_create_response import ConnectionCreateResponse as ConnectionCreateResponse from .connection_import_response import ConnectionImportResponse as ConnectionImportResponse @@ -45,7 +37,6 @@ from .document_delete_bulk_params import DocumentDeleteBulkParams as DocumentDeleteBulkParams from .document_upload_file_params import DocumentUploadFileParams as DocumentUploadFileParams from .memory_update_memory_params import MemoryUpdateMemoryParams as MemoryUpdateMemoryParams -from .memory_upload_file_response import MemoryUploadFileResponse as MemoryUploadFileResponse from .connection_get_by_tag_params import ConnectionGetByTagParams as ConnectionGetByTagParams from .connection_configure_response import ConnectionConfigureResponse as ConnectionConfigureResponse from .connection_get_by_id_response import ConnectionGetByIDResponse as ConnectionGetByIDResponse diff --git a/src/supermemory/types/memory_add_params.py b/src/supermemory/types/memory_add_params.py deleted file mode 100644 index 932bf19..0000000 --- a/src/supermemory/types/memory_add_params.py +++ /dev/null @@ -1,42 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Dict, Union -from typing_extensions import Required, Annotated, TypedDict - -from .._types import SequenceNotStr -from .._utils import PropertyInfo - -__all__ = ["MemoryAddParams"] - - -class MemoryAddParams(TypedDict, total=False): - content: Required[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: Annotated[str, PropertyInfo(alias="containerTag")] - """Optional tag this document should be containerized by. - - Max 100 characters, alphanumeric with hyphens and underscores only. - """ - - container_tags: Annotated[SequenceNotStr[str], PropertyInfo(alias="containerTags")] - - custom_id: Annotated[str, PropertyInfo(alias="customId")] - """Optional custom ID of the document. - - Max 100 characters, alphanumeric with hyphens and underscores only. - """ - - entity_context: Annotated[str, PropertyInfo(alias="entityContext")] - """Optional entity context for this container tag. - - Max 1500 characters. Used during document processing to guide memory extraction. - """ - - metadata: Dict[str, Union[str, float, bool, SequenceNotStr[str]]] - """Optional metadata for the document.""" diff --git a/src/supermemory/types/memory_add_response.py b/src/supermemory/types/memory_add_response.py deleted file mode 100644 index 6a1d7f3..0000000 --- a/src/supermemory/types/memory_add_response.py +++ /dev/null @@ -1,13 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .._models import BaseModel - -__all__ = ["MemoryAddResponse"] - - -class MemoryAddResponse(BaseModel): - id: str - """Unique identifier of the document""" - - status: str - """Status of the document""" diff --git a/src/supermemory/types/memory_get_response.py b/src/supermemory/types/memory_get_response.py deleted file mode 100644 index 4c6309b..0000000 --- a/src/supermemory/types/memory_get_response.py +++ /dev/null @@ -1,100 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Dict, List, Union, Optional -from typing_extensions import Literal - -from pydantic import Field as FieldInfo - -from .._models import BaseModel - -__all__ = ["MemoryGetResponse"] - - -class MemoryGetResponse(BaseModel): - """Document object""" - - id: str - """Unique identifier of the document.""" - - connection_id: Optional[str] = FieldInfo(alias="connectionId", default=None) - """Optional ID of connection the document was created from. - - This is useful for identifying the source of the document. - """ - - content: Optional[str] = None - """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 = FieldInfo(alias="createdAt") - """Creation timestamp""" - - custom_id: Optional[str] = FieldInfo(alias="customId", default=None) - """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, Dict[str, object], List[object], None] = None - """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. - """ - - og_image: Optional[str] = FieldInfo(alias="ogImage", default=None) - - raw: object - """Raw content of the document""" - - source: Optional[str] = None - """Source of the document""" - - status: Literal["unknown", "queued", "extracting", "chunking", "embedding", "indexing", "done", "failed"] - """Status of the document""" - - summary: Optional[str] = None - """Summary of the document content""" - - title: Optional[str] = None - """Title of the document""" - - type: Literal[ - "text", - "pdf", - "tweet", - "google_doc", - "google_slide", - "google_sheet", - "image", - "video", - "notion_doc", - "webpage", - "onedrive", - "github_markdown", - ] - """Type of the document""" - - updated_at: str = FieldInfo(alias="updatedAt") - """Last update timestamp""" - - container_tags: Optional[List[str]] = FieldInfo(alias="containerTags", default=None) - """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] = None - """URL of the document""" diff --git a/src/supermemory/types/memory_list_params.py b/src/supermemory/types/memory_list_params.py deleted file mode 100644 index 2e2cb57..0000000 --- a/src/supermemory/types/memory_list_params.py +++ /dev/null @@ -1,3839 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Union, Iterable -from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict - -from .._types import SequenceNotStr -from .._utils import PropertyInfo - -__all__ = [ - "MemoryListParams", - "Filters", - "FiltersOr", - "FiltersOrOr", - "FiltersOrOrUnionMember0", - "FiltersOrOrOr", - "FiltersOrOrOrOr", - "FiltersOrOrOrOrUnionMember0", - "FiltersOrOrOrOrOr", - "FiltersOrOrOrOrOrOr", - "FiltersOrOrOrOrOrOrUnionMember0", - "FiltersOrOrOrOrOrOrOr", - "FiltersOrOrOrOrOrOrOrOr", - "FiltersOrOrOrOrOrOrOrOrUnionMember0", - "FiltersOrOrOrOrOrOrOrOrOr", - "FiltersOrOrOrOrOrOrOrOrOrOr", - "FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0", - "FiltersOrOrOrOrOrOrOrOrOrOrOr", - "FiltersOrOrOrOrOrOrOrOrOrOrOrOr", - "FiltersOrOrOrOrOrOrOrOrOrOrAnd", - "FiltersOrOrOrOrOrOrOrOrOrOrAndAnd", - "FiltersOrOrOrOrOrOrOrOrAnd", - "FiltersOrOrOrOrOrOrOrOrAndAnd", - "FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0", - "FiltersOrOrOrOrOrOrOrOrAndAndOr", - "FiltersOrOrOrOrOrOrOrOrAndAndOrOr", - "FiltersOrOrOrOrOrOrOrOrAndAndAnd", - "FiltersOrOrOrOrOrOrOrOrAndAndAndAnd", - "FiltersOrOrOrOrOrOrAnd", - "FiltersOrOrOrOrOrOrAndAnd", - "FiltersOrOrOrOrOrOrAndAndUnionMember0", - "FiltersOrOrOrOrOrOrAndAndOr", - "FiltersOrOrOrOrOrOrAndAndOrOr", - "FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0", - "FiltersOrOrOrOrOrOrAndAndOrOrOr", - "FiltersOrOrOrOrOrOrAndAndOrOrOrOr", - "FiltersOrOrOrOrOrOrAndAndOrOrAnd", - "FiltersOrOrOrOrOrOrAndAndOrOrAndAnd", - "FiltersOrOrOrOrOrOrAndAndAnd", - "FiltersOrOrOrOrOrOrAndAndAndAnd", - "FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0", - "FiltersOrOrOrOrOrOrAndAndAndAndOr", - "FiltersOrOrOrOrOrOrAndAndAndAndOrOr", - "FiltersOrOrOrOrOrOrAndAndAndAndAnd", - "FiltersOrOrOrOrOrOrAndAndAndAndAndAnd", - "FiltersOrOrOrOrAnd", - "FiltersOrOrOrOrAndAnd", - "FiltersOrOrOrOrAndAndUnionMember0", - "FiltersOrOrOrOrAndAndOr", - "FiltersOrOrOrOrAndAndOrOr", - "FiltersOrOrOrOrAndAndOrOrUnionMember0", - "FiltersOrOrOrOrAndAndOrOrOr", - "FiltersOrOrOrOrAndAndOrOrOrOr", - "FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0", - "FiltersOrOrOrOrAndAndOrOrOrOrOr", - "FiltersOrOrOrOrAndAndOrOrOrOrOrOr", - "FiltersOrOrOrOrAndAndOrOrOrOrAnd", - "FiltersOrOrOrOrAndAndOrOrOrOrAndAnd", - "FiltersOrOrOrOrAndAndOrOrAnd", - "FiltersOrOrOrOrAndAndOrOrAndAnd", - "FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0", - "FiltersOrOrOrOrAndAndOrOrAndAndOr", - "FiltersOrOrOrOrAndAndOrOrAndAndOrOr", - "FiltersOrOrOrOrAndAndOrOrAndAndAnd", - "FiltersOrOrOrOrAndAndOrOrAndAndAndAnd", - "FiltersOrOrOrOrAndAndAnd", - "FiltersOrOrOrOrAndAndAndAnd", - "FiltersOrOrOrOrAndAndAndAndUnionMember0", - "FiltersOrOrOrOrAndAndAndAndOr", - "FiltersOrOrOrOrAndAndAndAndOrOr", - "FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0", - "FiltersOrOrOrOrAndAndAndAndOrOrOr", - "FiltersOrOrOrOrAndAndAndAndOrOrOrOr", - "FiltersOrOrOrOrAndAndAndAndOrOrAnd", - "FiltersOrOrOrOrAndAndAndAndOrOrAndAnd", - "FiltersOrOrOrOrAndAndAndAndAnd", - "FiltersOrOrOrOrAndAndAndAndAndAnd", - "FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0", - "FiltersOrOrOrOrAndAndAndAndAndAndOr", - "FiltersOrOrOrOrAndAndAndAndAndAndOrOr", - "FiltersOrOrOrOrAndAndAndAndAndAndAnd", - "FiltersOrOrOrOrAndAndAndAndAndAndAndAnd", - "FiltersOrOrAnd", - "FiltersOrOrAndAnd", - "FiltersOrOrAndAndUnionMember0", - "FiltersOrOrAndAndOr", - "FiltersOrOrAndAndOrOr", - "FiltersOrOrAndAndOrOrUnionMember0", - "FiltersOrOrAndAndOrOrOr", - "FiltersOrOrAndAndOrOrOrOr", - "FiltersOrOrAndAndOrOrOrOrUnionMember0", - "FiltersOrOrAndAndOrOrOrOrOr", - "FiltersOrOrAndAndOrOrOrOrOrOr", - "FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0", - "FiltersOrOrAndAndOrOrOrOrOrOrOr", - "FiltersOrOrAndAndOrOrOrOrOrOrOrOr", - "FiltersOrOrAndAndOrOrOrOrOrOrAnd", - "FiltersOrOrAndAndOrOrOrOrOrOrAndAnd", - "FiltersOrOrAndAndOrOrOrOrAnd", - "FiltersOrOrAndAndOrOrOrOrAndAnd", - "FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0", - "FiltersOrOrAndAndOrOrOrOrAndAndOr", - "FiltersOrOrAndAndOrOrOrOrAndAndOrOr", - "FiltersOrOrAndAndOrOrOrOrAndAndAnd", - "FiltersOrOrAndAndOrOrOrOrAndAndAndAnd", - "FiltersOrOrAndAndOrOrAnd", - "FiltersOrOrAndAndOrOrAndAnd", - "FiltersOrOrAndAndOrOrAndAndUnionMember0", - "FiltersOrOrAndAndOrOrAndAndOr", - "FiltersOrOrAndAndOrOrAndAndOrOr", - "FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0", - "FiltersOrOrAndAndOrOrAndAndOrOrOr", - "FiltersOrOrAndAndOrOrAndAndOrOrOrOr", - "FiltersOrOrAndAndOrOrAndAndOrOrAnd", - "FiltersOrOrAndAndOrOrAndAndOrOrAndAnd", - "FiltersOrOrAndAndOrOrAndAndAnd", - "FiltersOrOrAndAndOrOrAndAndAndAnd", - "FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0", - "FiltersOrOrAndAndOrOrAndAndAndAndOr", - "FiltersOrOrAndAndOrOrAndAndAndAndOrOr", - "FiltersOrOrAndAndOrOrAndAndAndAndAnd", - "FiltersOrOrAndAndOrOrAndAndAndAndAndAnd", - "FiltersOrOrAndAndAnd", - "FiltersOrOrAndAndAndAnd", - "FiltersOrOrAndAndAndAndUnionMember0", - "FiltersOrOrAndAndAndAndOr", - "FiltersOrOrAndAndAndAndOrOr", - "FiltersOrOrAndAndAndAndOrOrUnionMember0", - "FiltersOrOrAndAndAndAndOrOrOr", - "FiltersOrOrAndAndAndAndOrOrOrOr", - "FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0", - "FiltersOrOrAndAndAndAndOrOrOrOrOr", - "FiltersOrOrAndAndAndAndOrOrOrOrOrOr", - "FiltersOrOrAndAndAndAndOrOrOrOrAnd", - "FiltersOrOrAndAndAndAndOrOrOrOrAndAnd", - "FiltersOrOrAndAndAndAndOrOrAnd", - "FiltersOrOrAndAndAndAndOrOrAndAnd", - "FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0", - "FiltersOrOrAndAndAndAndOrOrAndAndOr", - "FiltersOrOrAndAndAndAndOrOrAndAndOrOr", - "FiltersOrOrAndAndAndAndOrOrAndAndAnd", - "FiltersOrOrAndAndAndAndOrOrAndAndAndAnd", - "FiltersOrOrAndAndAndAndAnd", - "FiltersOrOrAndAndAndAndAndAnd", - "FiltersOrOrAndAndAndAndAndAndUnionMember0", - "FiltersOrOrAndAndAndAndAndAndOr", - "FiltersOrOrAndAndAndAndAndAndOrOr", - "FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0", - "FiltersOrOrAndAndAndAndAndAndOrOrOr", - "FiltersOrOrAndAndAndAndAndAndOrOrOrOr", - "FiltersOrOrAndAndAndAndAndAndOrOrAnd", - "FiltersOrOrAndAndAndAndAndAndOrOrAndAnd", - "FiltersOrOrAndAndAndAndAndAndAnd", - "FiltersOrOrAndAndAndAndAndAndAndAnd", - "FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0", - "FiltersOrOrAndAndAndAndAndAndAndAndOr", - "FiltersOrOrAndAndAndAndAndAndAndAndOrOr", - "FiltersOrOrAndAndAndAndAndAndAndAndAnd", - "FiltersOrOrAndAndAndAndAndAndAndAndAndAnd", - "FiltersAnd", - "FiltersAndAnd", - "FiltersAndAndUnionMember0", - "FiltersAndAndOr", - "FiltersAndAndOrOr", - "FiltersAndAndOrOrUnionMember0", - "FiltersAndAndOrOrOr", - "FiltersAndAndOrOrOrOr", - "FiltersAndAndOrOrOrOrUnionMember0", - "FiltersAndAndOrOrOrOrOr", - "FiltersAndAndOrOrOrOrOrOr", - "FiltersAndAndOrOrOrOrOrOrUnionMember0", - "FiltersAndAndOrOrOrOrOrOrOr", - "FiltersAndAndOrOrOrOrOrOrOrOr", - "FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0", - "FiltersAndAndOrOrOrOrOrOrOrOrOr", - "FiltersAndAndOrOrOrOrOrOrOrOrOrOr", - "FiltersAndAndOrOrOrOrOrOrOrOrAnd", - "FiltersAndAndOrOrOrOrOrOrOrOrAndAnd", - "FiltersAndAndOrOrOrOrOrOrAnd", - "FiltersAndAndOrOrOrOrOrOrAndAnd", - "FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0", - "FiltersAndAndOrOrOrOrOrOrAndAndOr", - "FiltersAndAndOrOrOrOrOrOrAndAndOrOr", - "FiltersAndAndOrOrOrOrOrOrAndAndAnd", - "FiltersAndAndOrOrOrOrOrOrAndAndAndAnd", - "FiltersAndAndOrOrOrOrAnd", - "FiltersAndAndOrOrOrOrAndAnd", - "FiltersAndAndOrOrOrOrAndAndUnionMember0", - "FiltersAndAndOrOrOrOrAndAndOr", - "FiltersAndAndOrOrOrOrAndAndOrOr", - "FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0", - "FiltersAndAndOrOrOrOrAndAndOrOrOr", - "FiltersAndAndOrOrOrOrAndAndOrOrOrOr", - "FiltersAndAndOrOrOrOrAndAndOrOrAnd", - "FiltersAndAndOrOrOrOrAndAndOrOrAndAnd", - "FiltersAndAndOrOrOrOrAndAndAnd", - "FiltersAndAndOrOrOrOrAndAndAndAnd", - "FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0", - "FiltersAndAndOrOrOrOrAndAndAndAndOr", - "FiltersAndAndOrOrOrOrAndAndAndAndOrOr", - "FiltersAndAndOrOrOrOrAndAndAndAndAnd", - "FiltersAndAndOrOrOrOrAndAndAndAndAndAnd", - "FiltersAndAndOrOrAnd", - "FiltersAndAndOrOrAndAnd", - "FiltersAndAndOrOrAndAndUnionMember0", - "FiltersAndAndOrOrAndAndOr", - "FiltersAndAndOrOrAndAndOrOr", - "FiltersAndAndOrOrAndAndOrOrUnionMember0", - "FiltersAndAndOrOrAndAndOrOrOr", - "FiltersAndAndOrOrAndAndOrOrOrOr", - "FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0", - "FiltersAndAndOrOrAndAndOrOrOrOrOr", - "FiltersAndAndOrOrAndAndOrOrOrOrOrOr", - "FiltersAndAndOrOrAndAndOrOrOrOrAnd", - "FiltersAndAndOrOrAndAndOrOrOrOrAndAnd", - "FiltersAndAndOrOrAndAndOrOrAnd", - "FiltersAndAndOrOrAndAndOrOrAndAnd", - "FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0", - "FiltersAndAndOrOrAndAndOrOrAndAndOr", - "FiltersAndAndOrOrAndAndOrOrAndAndOrOr", - "FiltersAndAndOrOrAndAndOrOrAndAndAnd", - "FiltersAndAndOrOrAndAndOrOrAndAndAndAnd", - "FiltersAndAndOrOrAndAndAnd", - "FiltersAndAndOrOrAndAndAndAnd", - "FiltersAndAndOrOrAndAndAndAndUnionMember0", - "FiltersAndAndOrOrAndAndAndAndOr", - "FiltersAndAndOrOrAndAndAndAndOrOr", - "FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0", - "FiltersAndAndOrOrAndAndAndAndOrOrOr", - "FiltersAndAndOrOrAndAndAndAndOrOrOrOr", - "FiltersAndAndOrOrAndAndAndAndOrOrAnd", - "FiltersAndAndOrOrAndAndAndAndOrOrAndAnd", - "FiltersAndAndOrOrAndAndAndAndAnd", - "FiltersAndAndOrOrAndAndAndAndAndAnd", - "FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0", - "FiltersAndAndOrOrAndAndAndAndAndAndOr", - "FiltersAndAndOrOrAndAndAndAndAndAndOrOr", - "FiltersAndAndOrOrAndAndAndAndAndAndAnd", - "FiltersAndAndOrOrAndAndAndAndAndAndAndAnd", - "FiltersAndAndAnd", - "FiltersAndAndAndAnd", - "FiltersAndAndAndAndUnionMember0", - "FiltersAndAndAndAndOr", - "FiltersAndAndAndAndOrOr", - "FiltersAndAndAndAndOrOrUnionMember0", - "FiltersAndAndAndAndOrOrOr", - "FiltersAndAndAndAndOrOrOrOr", - "FiltersAndAndAndAndOrOrOrOrUnionMember0", - "FiltersAndAndAndAndOrOrOrOrOr", - "FiltersAndAndAndAndOrOrOrOrOrOr", - "FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0", - "FiltersAndAndAndAndOrOrOrOrOrOrOr", - "FiltersAndAndAndAndOrOrOrOrOrOrOrOr", - "FiltersAndAndAndAndOrOrOrOrOrOrAnd", - "FiltersAndAndAndAndOrOrOrOrOrOrAndAnd", - "FiltersAndAndAndAndOrOrOrOrAnd", - "FiltersAndAndAndAndOrOrOrOrAndAnd", - "FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0", - "FiltersAndAndAndAndOrOrOrOrAndAndOr", - "FiltersAndAndAndAndOrOrOrOrAndAndOrOr", - "FiltersAndAndAndAndOrOrOrOrAndAndAnd", - "FiltersAndAndAndAndOrOrOrOrAndAndAndAnd", - "FiltersAndAndAndAndOrOrAnd", - "FiltersAndAndAndAndOrOrAndAnd", - "FiltersAndAndAndAndOrOrAndAndUnionMember0", - "FiltersAndAndAndAndOrOrAndAndOr", - "FiltersAndAndAndAndOrOrAndAndOrOr", - "FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0", - "FiltersAndAndAndAndOrOrAndAndOrOrOr", - "FiltersAndAndAndAndOrOrAndAndOrOrOrOr", - "FiltersAndAndAndAndOrOrAndAndOrOrAnd", - "FiltersAndAndAndAndOrOrAndAndOrOrAndAnd", - "FiltersAndAndAndAndOrOrAndAndAnd", - "FiltersAndAndAndAndOrOrAndAndAndAnd", - "FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0", - "FiltersAndAndAndAndOrOrAndAndAndAndOr", - "FiltersAndAndAndAndOrOrAndAndAndAndOrOr", - "FiltersAndAndAndAndOrOrAndAndAndAndAnd", - "FiltersAndAndAndAndOrOrAndAndAndAndAndAnd", - "FiltersAndAndAndAndAnd", - "FiltersAndAndAndAndAndAnd", - "FiltersAndAndAndAndAndAndUnionMember0", - "FiltersAndAndAndAndAndAndOr", - "FiltersAndAndAndAndAndAndOrOr", - "FiltersAndAndAndAndAndAndOrOrUnionMember0", - "FiltersAndAndAndAndAndAndOrOrOr", - "FiltersAndAndAndAndAndAndOrOrOrOr", - "FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0", - "FiltersAndAndAndAndAndAndOrOrOrOrOr", - "FiltersAndAndAndAndAndAndOrOrOrOrOrOr", - "FiltersAndAndAndAndAndAndOrOrOrOrAnd", - "FiltersAndAndAndAndAndAndOrOrOrOrAndAnd", - "FiltersAndAndAndAndAndAndOrOrAnd", - "FiltersAndAndAndAndAndAndOrOrAndAnd", - "FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0", - "FiltersAndAndAndAndAndAndOrOrAndAndOr", - "FiltersAndAndAndAndAndAndOrOrAndAndOrOr", - "FiltersAndAndAndAndAndAndOrOrAndAndAnd", - "FiltersAndAndAndAndAndAndOrOrAndAndAndAnd", - "FiltersAndAndAndAndAndAndAnd", - "FiltersAndAndAndAndAndAndAndAnd", - "FiltersAndAndAndAndAndAndAndAndUnionMember0", - "FiltersAndAndAndAndAndAndAndAndOr", - "FiltersAndAndAndAndAndAndAndAndOrOr", - "FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0", - "FiltersAndAndAndAndAndAndAndAndOrOrOr", - "FiltersAndAndAndAndAndAndAndAndOrOrOrOr", - "FiltersAndAndAndAndAndAndAndAndOrOrAnd", - "FiltersAndAndAndAndAndAndAndAndOrOrAndAnd", - "FiltersAndAndAndAndAndAndAndAndAnd", - "FiltersAndAndAndAndAndAndAndAndAndAnd", - "FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0", - "FiltersAndAndAndAndAndAndAndAndAndAndOr", - "FiltersAndAndAndAndAndAndAndAndAndAndOrOr", - "FiltersAndAndAndAndAndAndAndAndAndAndAnd", - "FiltersAndAndAndAndAndAndAndAndAndAndAndAnd", -] - - -class MemoryListParams(TypedDict, total=False): - container_tags: Annotated[SequenceNotStr[str], PropertyInfo(alias="containerTags")] - """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. - """ - - filters: Filters - """Optional filters to apply to the search. Can be a JSON string or Query object.""" - - include_content: Annotated[bool, PropertyInfo(alias="includeContent")] - """Whether to include the content field in the response. - - Warning: This can make responses significantly larger. - """ - - limit: Union[str, float] - """Number of items per page""" - - order: Literal["asc", "desc"] - """Sort order""" - - page: Union[str, float] - """Page number to fetch""" - - sort: Literal["createdAt", "updatedAt"] - """Field to sort by""" - - -class FiltersOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrOrOrOrOrOrOrOrOr: TypeAlias = Union[ - FiltersOrOrOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrOrOrAnd -] - - -class FiltersOrOrOrOrOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrOrOrOrOrOrOrAndAnd: TypeAlias = Union[ - FiltersOrOrOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrOrOrAndAndAnd -] - - -class FiltersOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrOrOrOrOrOrOr: TypeAlias = Union[ - FiltersOrOrOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrOrOrAnd -] - - -class FiltersOrOrOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrOrOrOrOrAndAndOrOr: TypeAlias = Union[ - FiltersOrOrOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrOrOrAndAndOrOrAnd -] - - -class FiltersOrOrOrOrOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrOrOrOrOrAndAndAndAnd: TypeAlias = Union[ - FiltersOrOrOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrOrOrAndAndAndAndAnd -] - - -class FiltersOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrOrOrOrOrAndAnd: TypeAlias = Union[ - FiltersOrOrOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrOrOrAndAndOr, FiltersOrOrOrOrOrOrAndAndAnd -] - - -class FiltersOrOrOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrOrOrUnionMember0, FiltersOrOrOrOrOrOrOr, FiltersOrOrOrOrOrOrAnd] - - -class FiltersOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrOrOrAndAndOrOrOrOr: TypeAlias = Union[ - FiltersOrOrOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOrOrOr, FiltersOrOrOrOrAndAndOrOrOrOrAnd -] - - -class FiltersOrOrOrOrAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrOrOrAndAndOrOrAndAnd: TypeAlias = Union[ - FiltersOrOrOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOrOrAndAndOr, FiltersOrOrOrOrAndAndOrOrAndAndAnd -] - - -class FiltersOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrOrOrAndAndOrOr: TypeAlias = Union[ - FiltersOrOrOrOrAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndOrOrOr, FiltersOrOrOrOrAndAndOrOrAnd -] - - -class FiltersOrOrOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrOrOrAndAndAndAndOrOr: TypeAlias = Union[ - FiltersOrOrOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrOrOrAndAndAndAndOrOrOr, FiltersOrOrOrOrAndAndAndAndOrOrAnd -] - - -class FiltersOrOrOrOrAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrOrOrAndAndAndAndAndAnd: TypeAlias = Union[ - FiltersOrOrOrOrAndAndAndAndAndAndUnionMember0, - FiltersOrOrOrOrAndAndAndAndAndAndOr, - FiltersOrOrOrOrAndAndAndAndAndAndAnd, -] - - -class FiltersOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrOrOrAndAndAndAnd: TypeAlias = Union[ - FiltersOrOrOrOrAndAndAndAndUnionMember0, FiltersOrOrOrOrAndAndAndAndOr, FiltersOrOrOrOrAndAndAndAndAnd -] - - -class FiltersOrOrOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrOrOrAndAnd: TypeAlias = Union[ - FiltersOrOrOrOrAndAndUnionMember0, FiltersOrOrOrOrAndAndOr, FiltersOrOrOrOrAndAndAnd -] - - -class FiltersOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrOrOr: TypeAlias = Union[FiltersOrOrOrOrUnionMember0, FiltersOrOrOrOrOr, FiltersOrOrOrOrAnd] - - -class FiltersOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrAndAndOrOrOrOrOrOr: TypeAlias = Union[ - FiltersOrOrAndAndOrOrOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrOrOrAnd -] - - -class FiltersOrOrAndAndOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrAndAndOrOrOrOrAndAnd: TypeAlias = Union[ - FiltersOrOrAndAndOrOrOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrOrOrAndAndOr, FiltersOrOrAndAndOrOrOrOrAndAndAnd -] - - -class FiltersOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrAndAndOrOrOrOr: TypeAlias = Union[ - FiltersOrOrAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndOrOrOrOrOr, FiltersOrOrAndAndOrOrOrOrAnd -] - - -class FiltersOrOrAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrAndAndOrOrAndAndOrOr: TypeAlias = Union[ - FiltersOrOrAndAndOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAndAndOrOrAnd -] - - -class FiltersOrOrAndAndOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrAndAndOrOrAndAndAndAnd: TypeAlias = Union[ - FiltersOrOrAndAndOrOrAndAndAndAndUnionMember0, - FiltersOrOrAndAndOrOrAndAndAndAndOr, - FiltersOrOrAndAndOrOrAndAndAndAndAnd, -] - - -class FiltersOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrAndAndOrOrAndAnd: TypeAlias = Union[ - FiltersOrOrAndAndOrOrAndAndUnionMember0, FiltersOrOrAndAndOrOrAndAndOr, FiltersOrOrAndAndOrOrAndAndAnd -] - - -class FiltersOrOrAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrAndAndOrOr: TypeAlias = Union[ - FiltersOrOrAndAndOrOrUnionMember0, FiltersOrOrAndAndOrOrOr, FiltersOrOrAndAndOrOrAnd -] - - -class FiltersOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrAndAndAndAndOrOrOrOr: TypeAlias = Union[ - FiltersOrOrAndAndAndAndOrOrOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOrOrOr, FiltersOrOrAndAndAndAndOrOrOrOrAnd -] - - -class FiltersOrOrAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrAndAndAndAndOrOrAndAnd: TypeAlias = Union[ - FiltersOrOrAndAndAndAndOrOrAndAndUnionMember0, - FiltersOrOrAndAndAndAndOrOrAndAndOr, - FiltersOrOrAndAndAndAndOrOrAndAndAnd, -] - - -class FiltersOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrAndAndAndAndOrOr: TypeAlias = Union[ - FiltersOrOrAndAndAndAndOrOrUnionMember0, FiltersOrOrAndAndAndAndOrOrOr, FiltersOrOrAndAndAndAndOrOrAnd -] - - -class FiltersOrOrAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrAndAndAndAndAndAndOrOr: TypeAlias = Union[ - FiltersOrOrAndAndAndAndAndAndOrOrUnionMember0, - FiltersOrOrAndAndAndAndAndAndOrOrOr, - FiltersOrOrAndAndAndAndAndAndOrOrAnd, -] - - -class FiltersOrOrAndAndAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersOrOrAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersOrOrAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersOrOrAndAndAndAndAndAndAndAnd: TypeAlias = Union[ - FiltersOrOrAndAndAndAndAndAndAndAndUnionMember0, - FiltersOrOrAndAndAndAndAndAndAndAndOr, - FiltersOrOrAndAndAndAndAndAndAndAndAnd, -] - - -class FiltersOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrAndAndAndAndAndAnd: TypeAlias = Union[ - FiltersOrOrAndAndAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndAndAndOr, FiltersOrOrAndAndAndAndAndAndAnd -] - - -class FiltersOrOrAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrAndAndAndAnd: TypeAlias = Union[ - FiltersOrOrAndAndAndAndUnionMember0, FiltersOrOrAndAndAndAndOr, FiltersOrOrAndAndAndAndAnd -] - - -class FiltersOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOrAndAnd: TypeAlias = Union[FiltersOrOrAndAndUnionMember0, FiltersOrOrAndAndOr, FiltersOrOrAndAndAnd] - - -class FiltersOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersOrOr: TypeAlias = Union[FiltersOrOrUnionMember0, FiltersOrOrOr, FiltersOrOrAnd] - - -class FiltersOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersOrOr], PropertyInfo(alias="OR")]] - """Array of OR filter expressions""" - - -class FiltersAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrOrOrOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndOrOrOrOrOrOrOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndOrOrOrOrOrOrOrOr: TypeAlias = Union[ - FiltersAndAndOrOrOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrOrOrAnd -] - - -class FiltersAndAndOrOrOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrOrOrAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndOrOrOrOrOrOrAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndOrOrOrOrOrOrAndAnd: TypeAlias = Union[ - FiltersAndAndOrOrOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrOrOrAndAndAnd -] - - -class FiltersAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndOrOrOrOrOrOr: TypeAlias = Union[ - FiltersAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOrOrOr, FiltersAndAndOrOrOrOrOrOrAnd -] - - -class FiltersAndAndOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrAndAndOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndOrOrOrOrAndAndOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndOrOrOrOrAndAndOrOr: TypeAlias = Union[ - FiltersAndAndOrOrOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrOrOrAndAndOrOrOr, FiltersAndAndOrOrOrOrAndAndOrOrAnd -] - - -class FiltersAndAndOrOrOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrAndAndAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndOrOrOrOrAndAndAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrOrOrAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndOrOrOrOrAndAndAndAnd: TypeAlias = Union[ - FiltersAndAndOrOrOrOrAndAndAndAndUnionMember0, - FiltersAndAndOrOrOrOrAndAndAndAndOr, - FiltersAndAndOrOrOrOrAndAndAndAndAnd, -] - - -class FiltersAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndOrOrOrOrAndAnd: TypeAlias = Union[ - FiltersAndAndOrOrOrOrAndAndUnionMember0, FiltersAndAndOrOrOrOrAndAndOr, FiltersAndAndOrOrOrOrAndAndAnd -] - - -class FiltersAndAndOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndOrOrOrOr: TypeAlias = Union[ - FiltersAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrOrOrOr, FiltersAndAndOrOrOrOrAnd -] - - -class FiltersAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndOrOrOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndOrOrAndAndOrOrOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndOrOrAndAndOrOrOrOr: TypeAlias = Union[ - FiltersAndAndOrOrAndAndOrOrOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOrOrOr, FiltersAndAndOrOrAndAndOrOrOrOrAnd -] - - -class FiltersAndAndOrOrAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndOrOrAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndOrOrAndAndOrOrAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndOrOrAndAndOrOrAndAnd: TypeAlias = Union[ - FiltersAndAndOrOrAndAndOrOrAndAndUnionMember0, - FiltersAndAndOrOrAndAndOrOrAndAndOr, - FiltersAndAndOrOrAndAndOrOrAndAndAnd, -] - - -class FiltersAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndOrOrAndAndOrOr: TypeAlias = Union[ - FiltersAndAndOrOrAndAndOrOrUnionMember0, FiltersAndAndOrOrAndAndOrOrOr, FiltersAndAndOrOrAndAndOrOrAnd -] - - -class FiltersAndAndOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndAndAndOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndOrOrAndAndAndAndOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndOrOrAndAndAndAndOrOr: TypeAlias = Union[ - FiltersAndAndOrOrAndAndAndAndOrOrUnionMember0, - FiltersAndAndOrOrAndAndAndAndOrOrOr, - FiltersAndAndOrOrAndAndAndAndOrOrAnd, -] - - -class FiltersAndAndOrOrAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndAndAndAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndOrOrAndAndAndAndAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndOrOrAndAndAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndOrOrAndAndAndAndAndAnd: TypeAlias = Union[ - FiltersAndAndOrOrAndAndAndAndAndAndUnionMember0, - FiltersAndAndOrOrAndAndAndAndAndAndOr, - FiltersAndAndOrOrAndAndAndAndAndAndAnd, -] - - -class FiltersAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndOrOrAndAndAndAnd: TypeAlias = Union[ - FiltersAndAndOrOrAndAndAndAndUnionMember0, FiltersAndAndOrOrAndAndAndAndOr, FiltersAndAndOrOrAndAndAndAndAnd -] - - -class FiltersAndAndOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndOrOrAndAnd: TypeAlias = Union[ - FiltersAndAndOrOrAndAndUnionMember0, FiltersAndAndOrOrAndAndOr, FiltersAndAndOrOrAndAndAnd -] - - -class FiltersAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndOrOr: TypeAlias = Union[FiltersAndAndOrOrUnionMember0, FiltersAndAndOrOrOr, FiltersAndAndOrOrAnd] - - -class FiltersAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrOrOrOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndAndAndOrOrOrOrOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndAndAndOrOrOrOrOrOr: TypeAlias = Union[ - FiltersAndAndAndAndOrOrOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrOrOrAnd -] - - -class FiltersAndAndAndAndOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrOrOrAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndAndAndOrOrOrOrAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndAndAndOrOrOrOrAndAnd: TypeAlias = Union[ - FiltersAndAndAndAndOrOrOrOrAndAndUnionMember0, - FiltersAndAndAndAndOrOrOrOrAndAndOr, - FiltersAndAndAndAndOrOrOrOrAndAndAnd, -] - - -class FiltersAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndAndAndOrOrOrOr: TypeAlias = Union[ - FiltersAndAndAndAndOrOrOrOrUnionMember0, FiltersAndAndAndAndOrOrOrOrOr, FiltersAndAndAndAndOrOrOrOrAnd -] - - -class FiltersAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrAndAndOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndAndAndOrOrAndAndOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndAndAndOrOrAndAndOrOr: TypeAlias = Union[ - FiltersAndAndAndAndOrOrAndAndOrOrUnionMember0, - FiltersAndAndAndAndOrOrAndAndOrOrOr, - FiltersAndAndAndAndOrOrAndAndOrOrAnd, -] - - -class FiltersAndAndAndAndOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrAndAndAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndAndAndOrOrAndAndAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndOrOrAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndAndAndOrOrAndAndAndAnd: TypeAlias = Union[ - FiltersAndAndAndAndOrOrAndAndAndAndUnionMember0, - FiltersAndAndAndAndOrOrAndAndAndAndOr, - FiltersAndAndAndAndOrOrAndAndAndAndAnd, -] - - -class FiltersAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndAndAndOrOrAndAnd: TypeAlias = Union[ - FiltersAndAndAndAndOrOrAndAndUnionMember0, FiltersAndAndAndAndOrOrAndAndOr, FiltersAndAndAndAndOrOrAndAndAnd -] - - -class FiltersAndAndAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndAndAndOrOr: TypeAlias = Union[ - FiltersAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndOrOrOr, FiltersAndAndAndAndOrOrAnd -] - - -class FiltersAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndOrOrOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndOrOrOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndAndAndAndAndOrOrOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndOrOrOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndAndAndAndAndOrOrOrOr: TypeAlias = Union[ - FiltersAndAndAndAndAndAndOrOrOrOrUnionMember0, - FiltersAndAndAndAndAndAndOrOrOrOrOr, - FiltersAndAndAndAndAndAndOrOrOrOrAnd, -] - - -class FiltersAndAndAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndOrOrAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndOrOrAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndAndAndAndAndOrOrAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndOrOrAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndAndAndAndAndOrOrAndAnd: TypeAlias = Union[ - FiltersAndAndAndAndAndAndOrOrAndAndUnionMember0, - FiltersAndAndAndAndAndAndOrOrAndAndOr, - FiltersAndAndAndAndAndAndOrOrAndAndAnd, -] - - -class FiltersAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndAndAndAndAndOrOr: TypeAlias = Union[ - FiltersAndAndAndAndAndAndOrOrUnionMember0, FiltersAndAndAndAndAndAndOrOrOr, FiltersAndAndAndAndAndAndOrOrAnd -] - - -class FiltersAndAndAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndAndAndOrOrOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndAndAndOrOrOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndAndAndAndAndAndAndOrOrAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndAndAndOrOrAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOrAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndAndAndAndAndAndAndOrOr: TypeAlias = Union[ - FiltersAndAndAndAndAndAndAndAndOrOrUnionMember0, - FiltersAndAndAndAndAndAndAndAndOrOrOr, - FiltersAndAndAndAndAndAndAndAndOrOrAnd, -] - - -class FiltersAndAndAndAndAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions or nested expressions""" - - -class FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndAndAndAndAndOrOr(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndAndAndAndAndOr(TypedDict, total=False): - or_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndOrOr], PropertyInfo(alias="OR")]] - """OR: Array of conditions""" - - -class FiltersAndAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): - """ - A single filter condition based on metadata, numeric values, array contents, or string matching - """ - - key: Required[str] - - value: Required[str] - - filter_type: Annotated[ - Literal["metadata", "numeric", "array_contains", "string_contains"], PropertyInfo(alias="filterType") - ] - - ignore_case: Annotated[Union[bool, Literal["true", "false"]], PropertyInfo(alias="ignoreCase")] - - negate: Union[bool, Literal["true", "false"]] - - numeric_operator: Annotated[Literal[">", "<", ">=", "<=", "="], PropertyInfo(alias="numericOperator")] - - -class FiltersAndAndAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions""" - - -FiltersAndAndAndAndAndAndAndAndAndAnd: TypeAlias = Union[ - FiltersAndAndAndAndAndAndAndAndAndAndUnionMember0, - FiltersAndAndAndAndAndAndAndAndAndAndOr, - FiltersAndAndAndAndAndAndAndAndAndAndAnd, -] - - -class FiltersAndAndAndAndAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndAndAndAndAndAndAnd: TypeAlias = Union[ - FiltersAndAndAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAndAndAnd -] - - -class FiltersAndAndAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndAndAndAndAnd: TypeAlias = Union[ - FiltersAndAndAndAndAndAndUnionMember0, FiltersAndAndAndAndAndAndOr, FiltersAndAndAndAndAndAndAnd -] - - -class FiltersAndAndAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAndAndAnd: TypeAlias = Union[FiltersAndAndAndAndUnionMember0, FiltersAndAndAndAndOr, FiltersAndAndAndAndAnd] - - -class FiltersAndAndAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAndAndAnd], PropertyInfo(alias="AND")]] - """AND: Array of conditions or nested expressions""" - - -FiltersAndAnd: TypeAlias = Union[FiltersAndAndUnionMember0, FiltersAndAndOr, FiltersAndAndAnd] - - -class FiltersAnd(TypedDict, total=False): - and_: Required[Annotated[Iterable[FiltersAndAnd], PropertyInfo(alias="AND")]] - """Array of AND filter expressions""" - - -Filters: TypeAlias = Union[FiltersOr, FiltersAnd] diff --git a/src/supermemory/types/memory_list_response.py b/src/supermemory/types/memory_list_response.py deleted file mode 100644 index d6dbc69..0000000 --- a/src/supermemory/types/memory_list_response.py +++ /dev/null @@ -1,99 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import Dict, List, Union, Optional -from typing_extensions import Literal - -from pydantic import Field as FieldInfo - -from .._models import BaseModel - -__all__ = ["MemoryListResponse", "Memory", "Pagination"] - - -class Memory(BaseModel): - id: str - """Unique identifier of the document.""" - - connection_id: Optional[str] = FieldInfo(alias="connectionId", default=None) - """Optional ID of connection the document was created from. - - This is useful for identifying the source of the document. - """ - - created_at: str = FieldInfo(alias="createdAt") - """Creation timestamp""" - - custom_id: Optional[str] = FieldInfo(alias="customId", default=None) - """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, Dict[str, object], List[object], None] = None - """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. - """ - - status: Literal["unknown", "queued", "extracting", "chunking", "embedding", "indexing", "done", "failed"] - """Status of the document""" - - summary: Optional[str] = None - """Summary of the document content""" - - title: Optional[str] = None - """Title of the document""" - - type: Literal[ - "text", - "pdf", - "tweet", - "google_doc", - "google_slide", - "google_sheet", - "image", - "video", - "notion_doc", - "webpage", - "onedrive", - "github_markdown", - ] - """Type of the document""" - - updated_at: str = FieldInfo(alias="updatedAt") - """Last update timestamp""" - - container_tags: Optional[List[str]] = FieldInfo(alias="containerTags", default=None) - """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] = None - """Content of the document (only included when includeContent=true)""" - - -class Pagination(BaseModel): - """Pagination metadata""" - - current_page: float = FieldInfo(alias="currentPage") - - total_items: float = FieldInfo(alias="totalItems") - - total_pages: float = FieldInfo(alias="totalPages") - - limit: Optional[float] = None - - -class MemoryListResponse(BaseModel): - """List of documents""" - - memories: List[Memory] - - pagination: Pagination - """Pagination metadata""" diff --git a/src/supermemory/types/memory_update_params.py b/src/supermemory/types/memory_update_params.py deleted file mode 100644 index 1d7fe79..0000000 --- a/src/supermemory/types/memory_update_params.py +++ /dev/null @@ -1,55 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Dict, Union -from typing_extensions import Annotated, TypedDict - -from .._types import SequenceNotStr -from .._utils import PropertyInfo - -__all__ = ["MemoryUpdateParams"] - - -class MemoryUpdateParams(TypedDict, total=False): - container_tag: Annotated[str, PropertyInfo(alias="containerTag")] - """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: Annotated[SequenceNotStr[str], PropertyInfo(alias="containerTags")] - """ - (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: 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: Annotated[str, PropertyInfo(alias="customId")] - """Optional custom ID of the document. - - This could be an ID from your database that will uniquely identify this - document. - """ - - metadata: Dict[str, Union[str, float, bool, SequenceNotStr[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. - """ diff --git a/src/supermemory/types/memory_update_response.py b/src/supermemory/types/memory_update_response.py deleted file mode 100644 index e2e6ed4..0000000 --- a/src/supermemory/types/memory_update_response.py +++ /dev/null @@ -1,13 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .._models import BaseModel - -__all__ = ["MemoryUpdateResponse"] - - -class MemoryUpdateResponse(BaseModel): - id: str - """Unique identifier of the document""" - - status: str - """Status of the document""" diff --git a/src/supermemory/types/memory_upload_file_params.py b/src/supermemory/types/memory_upload_file_params.py deleted file mode 100644 index 5e95e43..0000000 --- a/src/supermemory/types/memory_upload_file_params.py +++ /dev/null @@ -1,52 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing_extensions import Required, Annotated, TypedDict - -from .._types import FileTypes -from .._utils import PropertyInfo - -__all__ = ["MemoryUploadFileParams"] - - -class MemoryUploadFileParams(TypedDict, total=False): - file: Required[FileTypes] - """File to upload and process""" - - container_tags: Annotated[str, PropertyInfo(alias="containerTags")] - """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. - """ - - file_type: Annotated[str, PropertyInfo(alias="fileType")] - """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 - """ - - metadata: 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: Annotated[str, PropertyInfo(alias="mimeType")] - """Required when fileType is 'image' or 'video'. - - Specifies the exact MIME type to use (e.g., 'image/png', 'image/jpeg', - 'video/mp4', 'video/webm') - """ - - use_advanced_processing: Annotated[str, PropertyInfo(alias="useAdvancedProcessing")] - """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. - """ diff --git a/src/supermemory/types/memory_upload_file_response.py b/src/supermemory/types/memory_upload_file_response.py deleted file mode 100644 index 0f2e6ed..0000000 --- a/src/supermemory/types/memory_upload_file_response.py +++ /dev/null @@ -1,13 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .._models import BaseModel - -__all__ = ["MemoryUploadFileResponse"] - - -class MemoryUploadFileResponse(BaseModel): - id: str - """Unique identifier of the document""" - - status: str - """Status of the document""" diff --git a/tests/api_resources/test_memories.py b/tests/api_resources/test_memories.py index ad89944..2490644 100644 --- a/tests/api_resources/test_memories.py +++ b/tests/api_resources/test_memories.py @@ -10,12 +10,7 @@ from supermemory import Supermemory, AsyncSupermemory from tests.utils import assert_matches_type from supermemory.types import ( - MemoryAddResponse, - MemoryGetResponse, - MemoryListResponse, MemoryForgetResponse, - MemoryUpdateResponse, - MemoryUploadFileResponse, MemoryUpdateMemoryResponse, ) @@ -25,218 +20,6 @@ class TestMemories: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_update(self, client: Supermemory) -> None: - memory = client.memories.update( - id="id", - ) - assert_matches_type(MemoryUpdateResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_update_with_all_params(self, client: Supermemory) -> None: - memory = client.memories.update( - id="id", - container_tag="user_123", - container_tags=["user_123", "project_123"], - content="This is a detailed article about machine learning concepts...", - custom_id="mem_abc123", - metadata={ - "category": "technology", - "isPublic": True, - "readingTime": 5, - "source": "web", - "tag_1": "ai", - "tag_2": "machine-learning", - }, - ) - assert_matches_type(MemoryUpdateResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_raw_response_update(self, client: Supermemory) -> None: - response = client.memories.with_raw_response.update( - id="id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = response.parse() - assert_matches_type(MemoryUpdateResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_streaming_response_update(self, client: Supermemory) -> None: - with client.memories.with_streaming_response.update( - id="id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = response.parse() - assert_matches_type(MemoryUpdateResponse, memory, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_path_params_update(self, client: Supermemory) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): - client.memories.with_raw_response.update( - id="", - ) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_list(self, client: Supermemory) -> None: - memory = client.memories.list() - assert_matches_type(MemoryListResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_list_with_all_params(self, client: Supermemory) -> None: - memory = client.memories.list( - container_tags=["user_123", "project_123"], - filters={ - "and_": [ - { - "key": "group", - "value": "jira_users", - "filter_type": "metadata", - "ignore_case": True, - "negate": False, - "numeric_operator": ">", - }, - { - "key": "timestamp", - "value": "1742745777", - "filter_type": "numeric", - "ignore_case": True, - "negate": False, - "numeric_operator": ">", - }, - ] - }, - include_content=False, - limit=10, - order="desc", - page=1, - sort="createdAt", - ) - assert_matches_type(MemoryListResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_raw_response_list(self, client: Supermemory) -> None: - response = client.memories.with_raw_response.list() - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = response.parse() - assert_matches_type(MemoryListResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_streaming_response_list(self, client: Supermemory) -> None: - with client.memories.with_streaming_response.list() as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = response.parse() - assert_matches_type(MemoryListResponse, memory, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_delete(self, client: Supermemory) -> None: - memory = client.memories.delete( - "id", - ) - assert memory is None - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_raw_response_delete(self, client: Supermemory) -> None: - response = client.memories.with_raw_response.delete( - "id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = response.parse() - assert memory is None - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_streaming_response_delete(self, client: Supermemory) -> None: - with client.memories.with_streaming_response.delete( - "id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = response.parse() - assert memory is None - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_path_params_delete(self, client: Supermemory) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): - client.memories.with_raw_response.delete( - "", - ) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_add(self, client: Supermemory) -> None: - memory = client.memories.add( - content="content", - ) - assert_matches_type(MemoryAddResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_add_with_all_params(self, client: Supermemory) -> None: - memory = client.memories.add( - content="content", - container_tag="containerTag", - container_tags=["string"], - custom_id="customId", - entity_context="entityContext", - metadata={"foo": "string"}, - ) - assert_matches_type(MemoryAddResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_raw_response_add(self, client: Supermemory) -> None: - response = client.memories.with_raw_response.add( - content="content", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = response.parse() - assert_matches_type(MemoryAddResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_streaming_response_add(self, client: Supermemory) -> None: - with client.memories.with_streaming_response.add( - content="content", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = response.parse() - assert_matches_type(MemoryAddResponse, memory, path=["response"]) - - assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_forget(self, client: Supermemory) -> None: @@ -282,48 +65,6 @@ def test_streaming_response_forget(self, client: Supermemory) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_get(self, client: Supermemory) -> None: - memory = client.memories.get( - "id", - ) - assert_matches_type(MemoryGetResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_raw_response_get(self, client: Supermemory) -> None: - response = client.memories.with_raw_response.get( - "id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = response.parse() - assert_matches_type(MemoryGetResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_streaming_response_get(self, client: Supermemory) -> None: - with client.memories.with_streaming_response.get( - "id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = response.parse() - assert_matches_type(MemoryGetResponse, memory, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_path_params_get(self, client: Supermemory) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): - client.memories.with_raw_response.get( - "", - ) - @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_update_memory(self, client: Supermemory) -> None: @@ -373,271 +114,12 @@ def test_streaming_response_update_memory(self, client: Supermemory) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_upload_file(self, client: Supermemory) -> None: - memory = client.memories.upload_file( - file=b"raw file contents", - ) - assert_matches_type(MemoryUploadFileResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_method_upload_file_with_all_params(self, client: Supermemory) -> None: - memory = client.memories.upload_file( - file=b"raw file contents", - container_tags='["user_123", "project_123"]', - file_type="image", - metadata='{"category": "technology", "isPublic": true, "readingTime": 5}', - mime_type="mimeType", - use_advanced_processing="true", - ) - assert_matches_type(MemoryUploadFileResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_raw_response_upload_file(self, client: Supermemory) -> None: - response = client.memories.with_raw_response.upload_file( - file=b"raw file contents", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = response.parse() - assert_matches_type(MemoryUploadFileResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - def test_streaming_response_upload_file(self, client: Supermemory) -> None: - with client.memories.with_streaming_response.upload_file( - file=b"raw file contents", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = response.parse() - assert_matches_type(MemoryUploadFileResponse, memory, path=["response"]) - - assert cast(Any, response.is_closed) is True - class TestAsyncMemories: parametrize = pytest.mark.parametrize( "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_update(self, async_client: AsyncSupermemory) -> None: - memory = await async_client.memories.update( - id="id", - ) - assert_matches_type(MemoryUpdateResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_update_with_all_params(self, async_client: AsyncSupermemory) -> None: - memory = await async_client.memories.update( - id="id", - container_tag="user_123", - container_tags=["user_123", "project_123"], - content="This is a detailed article about machine learning concepts...", - custom_id="mem_abc123", - metadata={ - "category": "technology", - "isPublic": True, - "readingTime": 5, - "source": "web", - "tag_1": "ai", - "tag_2": "machine-learning", - }, - ) - assert_matches_type(MemoryUpdateResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_raw_response_update(self, async_client: AsyncSupermemory) -> None: - response = await async_client.memories.with_raw_response.update( - id="id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = await response.parse() - assert_matches_type(MemoryUpdateResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_streaming_response_update(self, async_client: AsyncSupermemory) -> None: - async with async_client.memories.with_streaming_response.update( - id="id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = await response.parse() - assert_matches_type(MemoryUpdateResponse, memory, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_path_params_update(self, async_client: AsyncSupermemory) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): - await async_client.memories.with_raw_response.update( - id="", - ) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_list(self, async_client: AsyncSupermemory) -> None: - memory = await async_client.memories.list() - assert_matches_type(MemoryListResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_list_with_all_params(self, async_client: AsyncSupermemory) -> None: - memory = await async_client.memories.list( - container_tags=["user_123", "project_123"], - filters={ - "and_": [ - { - "key": "group", - "value": "jira_users", - "filter_type": "metadata", - "ignore_case": True, - "negate": False, - "numeric_operator": ">", - }, - { - "key": "timestamp", - "value": "1742745777", - "filter_type": "numeric", - "ignore_case": True, - "negate": False, - "numeric_operator": ">", - }, - ] - }, - include_content=False, - limit=10, - order="desc", - page=1, - sort="createdAt", - ) - assert_matches_type(MemoryListResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_raw_response_list(self, async_client: AsyncSupermemory) -> None: - response = await async_client.memories.with_raw_response.list() - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = await response.parse() - assert_matches_type(MemoryListResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_streaming_response_list(self, async_client: AsyncSupermemory) -> None: - async with async_client.memories.with_streaming_response.list() as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = await response.parse() - assert_matches_type(MemoryListResponse, memory, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_delete(self, async_client: AsyncSupermemory) -> None: - memory = await async_client.memories.delete( - "id", - ) - assert memory is None - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_raw_response_delete(self, async_client: AsyncSupermemory) -> None: - response = await async_client.memories.with_raw_response.delete( - "id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = await response.parse() - assert memory is None - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_streaming_response_delete(self, async_client: AsyncSupermemory) -> None: - async with async_client.memories.with_streaming_response.delete( - "id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = await response.parse() - assert memory is None - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_path_params_delete(self, async_client: AsyncSupermemory) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): - await async_client.memories.with_raw_response.delete( - "", - ) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_add(self, async_client: AsyncSupermemory) -> None: - memory = await async_client.memories.add( - content="content", - ) - assert_matches_type(MemoryAddResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_add_with_all_params(self, async_client: AsyncSupermemory) -> None: - memory = await async_client.memories.add( - content="content", - container_tag="containerTag", - container_tags=["string"], - custom_id="customId", - entity_context="entityContext", - metadata={"foo": "string"}, - ) - assert_matches_type(MemoryAddResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_raw_response_add(self, async_client: AsyncSupermemory) -> None: - response = await async_client.memories.with_raw_response.add( - content="content", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = await response.parse() - assert_matches_type(MemoryAddResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_streaming_response_add(self, async_client: AsyncSupermemory) -> None: - async with async_client.memories.with_streaming_response.add( - content="content", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = await response.parse() - assert_matches_type(MemoryAddResponse, memory, path=["response"]) - - assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_forget(self, async_client: AsyncSupermemory) -> None: @@ -683,48 +165,6 @@ async def test_streaming_response_forget(self, async_client: AsyncSupermemory) - assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_get(self, async_client: AsyncSupermemory) -> None: - memory = await async_client.memories.get( - "id", - ) - assert_matches_type(MemoryGetResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_raw_response_get(self, async_client: AsyncSupermemory) -> None: - response = await async_client.memories.with_raw_response.get( - "id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = await response.parse() - assert_matches_type(MemoryGetResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_streaming_response_get(self, async_client: AsyncSupermemory) -> None: - async with async_client.memories.with_streaming_response.get( - "id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = await response.parse() - assert_matches_type(MemoryGetResponse, memory, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_path_params_get(self, async_client: AsyncSupermemory) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): - await async_client.memories.with_raw_response.get( - "", - ) - @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_update_memory(self, async_client: AsyncSupermemory) -> None: @@ -773,50 +213,3 @@ async def test_streaming_response_update_memory(self, async_client: AsyncSuperme assert_matches_type(MemoryUpdateMemoryResponse, memory, path=["response"]) assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_upload_file(self, async_client: AsyncSupermemory) -> None: - memory = await async_client.memories.upload_file( - file=b"raw file contents", - ) - assert_matches_type(MemoryUploadFileResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_method_upload_file_with_all_params(self, async_client: AsyncSupermemory) -> None: - memory = await async_client.memories.upload_file( - file=b"raw file contents", - container_tags='["user_123", "project_123"]', - file_type="image", - metadata='{"category": "technology", "isPublic": true, "readingTime": 5}', - mime_type="mimeType", - use_advanced_processing="true", - ) - assert_matches_type(MemoryUploadFileResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_raw_response_upload_file(self, async_client: AsyncSupermemory) -> None: - response = await async_client.memories.with_raw_response.upload_file( - file=b"raw file contents", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - memory = await response.parse() - assert_matches_type(MemoryUploadFileResponse, memory, path=["response"]) - - @pytest.mark.skip(reason="Prism tests are disabled") - @parametrize - async def test_streaming_response_upload_file(self, async_client: AsyncSupermemory) -> None: - async with async_client.memories.with_streaming_response.upload_file( - file=b"raw file contents", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - memory = await response.parse() - assert_matches_type(MemoryUploadFileResponse, memory, path=["response"]) - - assert cast(Any, response.is_closed) is True