supermemory 3.0.0a2__py3-none-any.whl → 3.0.0a20__py3-none-any.whl

{supermemory → supermemory_new}/resources/memories.py

@@ -3,10 +3,11 @@
 from __future__ import annotations
 
 from typing import Dict, List, Union
+from typing_extensions import Literal
 
 import httpx
 
-from ..types import memory_add_params, memory_update_params
+from ..types import memory_add_params, memory_list_params, memory_update_params
 from .._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
@@ -20,6 +21,7 @@ from .._response import (
 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_update_response import MemoryUpdateResponse
 
 __all__ = ["MemoriesResource", "AsyncMemoriesResource"]
@@ -112,6 +114,66 @@ class MemoriesResource(SyncAPIResource):
             cast_to=MemoryUpdateResponse,
         )
 
+    def list(
+        self,
+        *,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        filters: str | NotGiven = NOT_GIVEN,
+        limit: Union[str, float] | NotGiven = NOT_GIVEN,
+        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        page: Union[str, float] | NotGiven = NOT_GIVEN,
+        sort: Literal["createdAt", "updatedAt"] | NotGiven = NOT_GIVEN,
+        # 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 memories with their metadata and workflow status
+
+        Args:
+          container_tags: Optional tags this memory 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 memories.
+
+          filters: Optional filters to apply to the search
+
+          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/memories/list",
+            body=maybe_transform(
+                {
+                    "container_tags": container_tags,
+                    "filters": filters,
+                    "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,
@@ -331,6 +393,66 @@ class AsyncMemoriesResource(AsyncAPIResource):
             cast_to=MemoryUpdateResponse,
         )
 
+    async def list(
+        self,
+        *,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        filters: str | NotGiven = NOT_GIVEN,
+        limit: Union[str, float] | NotGiven = NOT_GIVEN,
+        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        page: Union[str, float] | NotGiven = NOT_GIVEN,
+        sort: Literal["createdAt", "updatedAt"] | NotGiven = NOT_GIVEN,
+        # 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 memories with their metadata and workflow status
+
+        Args:
+          container_tags: Optional tags this memory 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 memories.
+
+          filters: Optional filters to apply to the search
+
+          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/memories/list",
+            body=await async_maybe_transform(
+                {
+                    "container_tags": container_tags,
+                    "filters": filters,
+                    "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,
@@ -470,6 +592,9 @@ class MemoriesResourceWithRawResponse:
         self.update = to_raw_response_wrapper(
             memories.update,
         )
+        self.list = to_raw_response_wrapper(
+            memories.list,
+        )
         self.delete = to_raw_response_wrapper(
             memories.delete,
         )
@@ -488,6 +613,9 @@ class AsyncMemoriesResourceWithRawResponse:
         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,
         )
@@ -506,6 +634,9 @@ class MemoriesResourceWithStreamingResponse:
         self.update = to_streamed_response_wrapper(
             memories.update,
         )
+        self.list = to_streamed_response_wrapper(
+            memories.list,
+        )
         self.delete = to_streamed_response_wrapper(
             memories.delete,
         )
@@ -524,6 +655,9 @@ class AsyncMemoriesResourceWithStreamingResponse:
         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,
         )

supermemory_new/resources/search.py

@@ -0,0 +1,300 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import search_execute_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.search_execute_response import SearchExecuteResponse
+
+__all__ = ["SearchResource", "AsyncSearchResource"]
+
+
+class SearchResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> SearchResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/supermemoryai/python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return SearchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SearchResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/supermemoryai/python-sdk#with_streaming_response
+        """
+        return SearchResourceWithStreamingResponse(self)
+
+    def execute(
+        self,
+        *,
+        q: str,
+        categories_filter: List[Literal["technology", "science", "business", "health"]] | NotGiven = NOT_GIVEN,
+        chunk_threshold: float | NotGiven = NOT_GIVEN,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        doc_id: str | NotGiven = NOT_GIVEN,
+        document_threshold: float | NotGiven = NOT_GIVEN,
+        filters: search_execute_params.Filters | NotGiven = NOT_GIVEN,
+        include_full_docs: bool | NotGiven = NOT_GIVEN,
+        include_summary: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        only_matching_chunks: bool | NotGiven = NOT_GIVEN,
+        rerank: bool | NotGiven = NOT_GIVEN,
+        rewrite_query: bool | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> SearchExecuteResponse:
+        """
+        Search memories with advanced filtering
+
+        Args:
+          q: Search query string
+
+          categories_filter: Optional category filters
+
+          chunk_threshold: Threshold / sensitivity for chunk selection. 0 is least sensitive (returns most
+              chunks, more results), 1 is most sensitive (returns lesser chunks, accurate
+              results)
+
+          container_tags: Optional tags this search should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to filter memories.
+
+          doc_id: Optional document ID to search within. You can use this to find chunks in a very
+              large document.
+
+          document_threshold: Threshold / sensitivity for document selection. 0 is least sensitive (returns
+              most documents, more results), 1 is most sensitive (returns lesser documents,
+              accurate results)
+
+          filters: Optional filters to apply to the search
+
+          include_full_docs: If true, include full document in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          include_summary: If true, include document summary in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          limit: Maximum number of results to return
+
+          only_matching_chunks: If true, only return matching chunks without context. Normally, we send the
+              previous and next chunk to provide more context for LLMs. If you only want the
+              matching chunk, set this to true.
+
+          rerank: If true, rerank the results based on the query. This is helpful if you want to
+              ensure the most relevant results are returned.
+
+          rewrite_query: If true, rewrites the query to make it easier to find documents. This increases
+              the latency by about 400ms
+
+          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/search",
+            body=maybe_transform(
+                {
+                    "q": q,
+                    "categories_filter": categories_filter,
+                    "chunk_threshold": chunk_threshold,
+                    "container_tags": container_tags,
+                    "doc_id": doc_id,
+                    "document_threshold": document_threshold,
+                    "filters": filters,
+                    "include_full_docs": include_full_docs,
+                    "include_summary": include_summary,
+                    "limit": limit,
+                    "only_matching_chunks": only_matching_chunks,
+                    "rerank": rerank,
+                    "rewrite_query": rewrite_query,
+                },
+                search_execute_params.SearchExecuteParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchExecuteResponse,
+        )
+
+
+class AsyncSearchResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncSearchResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/supermemoryai/python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSearchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSearchResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/supermemoryai/python-sdk#with_streaming_response
+        """
+        return AsyncSearchResourceWithStreamingResponse(self)
+
+    async def execute(
+        self,
+        *,
+        q: str,
+        categories_filter: List[Literal["technology", "science", "business", "health"]] | NotGiven = NOT_GIVEN,
+        chunk_threshold: float | NotGiven = NOT_GIVEN,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        doc_id: str | NotGiven = NOT_GIVEN,
+        document_threshold: float | NotGiven = NOT_GIVEN,
+        filters: search_execute_params.Filters | NotGiven = NOT_GIVEN,
+        include_full_docs: bool | NotGiven = NOT_GIVEN,
+        include_summary: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        only_matching_chunks: bool | NotGiven = NOT_GIVEN,
+        rerank: bool | NotGiven = NOT_GIVEN,
+        rewrite_query: bool | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> SearchExecuteResponse:
+        """
+        Search memories with advanced filtering
+
+        Args:
+          q: Search query string
+
+          categories_filter: Optional category filters
+
+          chunk_threshold: Threshold / sensitivity for chunk selection. 0 is least sensitive (returns most
+              chunks, more results), 1 is most sensitive (returns lesser chunks, accurate
+              results)
+
+          container_tags: Optional tags this search should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to filter memories.
+
+          doc_id: Optional document ID to search within. You can use this to find chunks in a very
+              large document.
+
+          document_threshold: Threshold / sensitivity for document selection. 0 is least sensitive (returns
+              most documents, more results), 1 is most sensitive (returns lesser documents,
+              accurate results)
+
+          filters: Optional filters to apply to the search
+
+          include_full_docs: If true, include full document in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          include_summary: If true, include document summary in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          limit: Maximum number of results to return
+
+          only_matching_chunks: If true, only return matching chunks without context. Normally, we send the
+              previous and next chunk to provide more context for LLMs. If you only want the
+              matching chunk, set this to true.
+
+          rerank: If true, rerank the results based on the query. This is helpful if you want to
+              ensure the most relevant results are returned.
+
+          rewrite_query: If true, rewrites the query to make it easier to find documents. This increases
+              the latency by about 400ms
+
+          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/search",
+            body=await async_maybe_transform(
+                {
+                    "q": q,
+                    "categories_filter": categories_filter,
+                    "chunk_threshold": chunk_threshold,
+                    "container_tags": container_tags,
+                    "doc_id": doc_id,
+                    "document_threshold": document_threshold,
+                    "filters": filters,
+                    "include_full_docs": include_full_docs,
+                    "include_summary": include_summary,
+                    "limit": limit,
+                    "only_matching_chunks": only_matching_chunks,
+                    "rerank": rerank,
+                    "rewrite_query": rewrite_query,
+                },
+                search_execute_params.SearchExecuteParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchExecuteResponse,
+        )
+
+
+class SearchResourceWithRawResponse:
+    def __init__(self, search: SearchResource) -> None:
+        self._search = search
+
+        self.execute = to_raw_response_wrapper(
+            search.execute,
+        )
+
+
+class AsyncSearchResourceWithRawResponse:
+    def __init__(self, search: AsyncSearchResource) -> None:
+        self._search = search
+
+        self.execute = async_to_raw_response_wrapper(
+            search.execute,
+        )
+
+
+class SearchResourceWithStreamingResponse:
+    def __init__(self, search: SearchResource) -> None:
+        self._search = search
+
+        self.execute = to_streamed_response_wrapper(
+            search.execute,
+        )
+
+
+class AsyncSearchResourceWithStreamingResponse:
+    def __init__(self, search: AsyncSearchResource) -> None:
+        self._search = search
+
+        self.execute = async_to_streamed_response_wrapper(
+            search.execute,
+        )

supermemory_new/types/__init__.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .memory_add_params import MemoryAddParams as MemoryAddParams
+from .memory_list_params import MemoryListParams as MemoryListParams
+from .memory_add_response import MemoryAddResponse as MemoryAddResponse
+from .memory_get_response import MemoryGetResponse as MemoryGetResponse
+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 .search_execute_params import SearchExecuteParams as SearchExecuteParams
+from .setting_update_params import SettingUpdateParams as SettingUpdateParams
+from .connection_list_params import ConnectionListParams as ConnectionListParams
+from .memory_update_response import MemoryUpdateResponse as MemoryUpdateResponse
+from .search_execute_response import SearchExecuteResponse as SearchExecuteResponse
+from .setting_update_response import SettingUpdateResponse as SettingUpdateResponse
+from .connection_create_params import ConnectionCreateParams as ConnectionCreateParams
+from .connection_import_params import ConnectionImportParams as ConnectionImportParams
+from .connection_list_response import ConnectionListResponse as ConnectionListResponse
+from .connection_create_response import ConnectionCreateResponse as ConnectionCreateResponse
+from .connection_get_by_id_response import ConnectionGetByIDResponse as ConnectionGetByIDResponse
+from .connection_get_by_tags_params import ConnectionGetByTagsParams as ConnectionGetByTagsParams
+from .connection_get_by_tags_response import ConnectionGetByTagsResponse as ConnectionGetByTagsResponse
+from .connection_list_documents_params import ConnectionListDocumentsParams as ConnectionListDocumentsParams
+from .connection_list_documents_response import ConnectionListDocumentsResponse as ConnectionListDocumentsResponse
+from .connection_delete_by_provider_params import ConnectionDeleteByProviderParams as ConnectionDeleteByProviderParams
+from .connection_delete_by_provider_response import (
+    ConnectionDeleteByProviderResponse as ConnectionDeleteByProviderResponse,
+)

supermemory_new/types/connection_delete_by_provider_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ConnectionDeleteByProviderParams"]
+
+
+class ConnectionDeleteByProviderParams(TypedDict, total=False):
+    container_tags: Required[Annotated[List[str], PropertyInfo(alias="containerTags")]]
+    """Optional comma-separated list of container tags to filter connections by"""

supermemory_new/types/connection_delete_by_provider_response.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["ConnectionDeleteByProviderResponse"]
+
+
+class ConnectionDeleteByProviderResponse(BaseModel):
+    id: str
+
+    provider: str

supermemory/types/connection_get_response.py → supermemory_new/types/connection_get_by_id_response.py

@@ -6,10 +6,10 @@ from pydantic import Field as FieldInfo
 
 from .._models import BaseModel
 
-__all__ = ["ConnectionGetResponse"]
+__all__ = ["ConnectionGetByIDResponse"]
 
 
-class ConnectionGetResponse(BaseModel):
+class ConnectionGetByIDResponse(BaseModel):
     id: str
 
     created_at: float = FieldInfo(alias="createdAt")

supermemory_new/types/connection_get_by_tags_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ConnectionGetByTagsParams"]
+
+
+class ConnectionGetByTagsParams(TypedDict, total=False):
+    container_tags: Required[Annotated[List[str], PropertyInfo(alias="containerTags")]]
+    """Comma-separated list of container tags to filter connection by"""

supermemory_new/types/connection_get_by_tags_response.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["ConnectionGetByTagsResponse"]
+
+
+class ConnectionGetByTagsResponse(BaseModel):
+    id: str
+
+    created_at: float = FieldInfo(alias="createdAt")
+
+    provider: str
+
+    document_limit: Optional[float] = FieldInfo(alias="documentLimit", default=None)
+
+    email: Optional[str] = None
+
+    expires_at: Optional[float] = FieldInfo(alias="expiresAt", default=None)
+
+    metadata: Optional[Dict[str, object]] = None

supermemory_new/types/connection_import_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ConnectionImportParams"]
+
+
+class ConnectionImportParams(TypedDict, total=False):
+    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    """Optional comma-separated list of container tags to filter connections by"""

supermemory_new/types/connection_list_documents_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ConnectionListDocumentsParams"]
+
+
+class ConnectionListDocumentsParams(TypedDict, total=False):
+    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    """Optional comma-separated list of container tags to filter documents by"""

supermemory_new/types/connection_list_documents_response.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["ConnectionListDocumentsResponse", "ConnectionListDocumentsResponseItem"]
+
+
+class ConnectionListDocumentsResponseItem(BaseModel):
+    id: str
+
+    created_at: str = FieldInfo(alias="createdAt")
+
+    status: str
+
+    summary: Optional[str] = None
+
+    title: Optional[str] = None
+
+    type: str
+
+    updated_at: str = FieldInfo(alias="updatedAt")
+
+
+ConnectionListDocumentsResponse: TypeAlias = List[ConnectionListDocumentsResponseItem]