groundx 2.0.20__py3-none-any.whl → 2.0.21__py3-none-any.whl

groundx/documents/client.py

@@ -2,22 +2,21 @@
 
 import typing
 from ..core.client_wrapper import SyncClientWrapper
-from ..types.sort import Sort
-from ..types.sort_order import SortOrder
-from ..types.processing_status import ProcessingStatus
+from ..types.ingest_remote_document import IngestRemoteDocument
 from ..core.request_options import RequestOptions
-from ..types.document_list_response import DocumentListResponse
-from ..core.pydantic_utilities import parse_obj_as
-from json.decoder import JSONDecodeError
-from ..core.api_error import ApiError
-from ..types.document import Document
 from ..types.ingest_response import IngestResponse
 from ..core.serialization import convert_and_respect_annotation_metadata
+from ..core.pydantic_utilities import parse_obj_as
 from ..errors.bad_request_error import BadRequestError
 from ..errors.unauthorized_error import UnauthorizedError
-from ..types.ingest_remote_document import IngestRemoteDocument
-from ..types.ingest_local_document import IngestLocalDocument
+from json.decoder import JSONDecodeError
+from ..core.api_error import ApiError
+from ..types.document_local_ingest_request import DocumentLocalIngestRequest
 from ..types.website_source import WebsiteSource
+from ..types.sort import Sort
+from ..types.sort_order import SortOrder
+from ..types.processing_status import ProcessingStatus
+from ..types.document_list_response import DocumentListResponse
 from ..types.process_status_response import ProcessStatusResponse
 from ..core.jsonable_encoder import jsonable_encoder
 from ..types.document_lookup_response import DocumentLookupResponse
@@ -32,97 +31,20 @@ class DocumentsClient:
     def __init__(self, *, client_wrapper: SyncClientWrapper):
         self._client_wrapper = client_wrapper
 
-    def list(
+    def ingest_remote(
         self,
         *,
-        n: typing.Optional[int] = None,
-        filter: typing.Optional[str] = None,
-        sort: typing.Optional[Sort] = None,
-        sort_order: typing.Optional[SortOrder] = None,
-        status: typing.Optional[ProcessingStatus] = None,
-        next_token: typing.Optional[str] = None,
+        documents: typing.Sequence[IngestRemoteDocument],
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> DocumentListResponse:
-        """
-        lookup all documents across all resources which are currently on GroundX
-
-        Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
-
-        Parameters
-        ----------
-        n : typing.Optional[int]
-            The maximum number of returned documents. Accepts 1-100 with a default of 20.
-
-        filter : typing.Optional[str]
-            Only documents with names that contain the filter string will be returned in the results.
-
-        sort : typing.Optional[Sort]
-            The document attribute that will be used to sort the results.
-
-        sort_order : typing.Optional[SortOrder]
-            The order in which to sort the results. A value for sort must also be set.
-
-        status : typing.Optional[ProcessingStatus]
-            A status filter on the get documents query. If this value is set, then only documents with this status will be returned in the results.
-
-        next_token : typing.Optional[str]
-            A token for pagination. If the number of documents for a given query is larger than n, the response will include a "nextToken" value. That token can be included in this field to retrieve the next batch of n documents.
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        DocumentListResponse
-            Look up success
-
-        Examples
-        --------
-        from groundx import GroundX
-
-        client = GroundX(
-            api_key="YOUR_API_KEY",
-        )
-        client.documents.list()
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents",
-            method="GET",
-            params={
-                "n": n,
-                "filter": filter,
-                "sort": sort,
-                "sortOrder": sort_order,
-                "status": status,
-                "nextToken": next_token,
-            },
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    DocumentListResponse,
-                    parse_obj_as(
-                        type_=DocumentListResponse,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
-    def ingest(
-        self, *, documents: typing.Sequence[Document], request_options: typing.Optional[RequestOptions] = None
     ) -> IngestResponse:
         """
-        Ingest documents hosted on public URLs or a local file system for ingestion into a GroundX bucket.
+        Ingest documents hosted on public URLs into a GroundX bucket.
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        documents : typing.Sequence[Document]
+        documents : typing.Sequence[IngestRemoteDocument]
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -134,35 +56,28 @@ class DocumentsClient:
 
         Examples
         --------
-        from groundx import Document, GroundX
+        from groundx import GroundX, IngestRemoteDocument
 
         client = GroundX(
             api_key="YOUR_API_KEY",
         )
-        client.documents.ingest(
+        client.documents.ingest_remote(
             documents=[
-                Document(
+                IngestRemoteDocument(
                     bucket_id=1234,
                     file_name="my_file1.txt",
-                    file_path="https://my.source.url.com/file1.txt",
                     file_type="txt",
-                    search_data={"key": "value"},
-                ),
-                Document(
-                    bucket_id=1234,
-                    file_name="my_file2.pdf",
-                    file_path="/local/path/file2.pdf",
-                    file_type="pdf",
-                ),
+                    source_url="https://my.source.url.com/file1.txt",
+                )
             ],
         )
         """
         _response = self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents",
+            "v1/ingest/documents/remote",
             method="POST",
             json={
                 "documents": convert_and_respect_annotation_metadata(
-                    object_=documents, annotation=typing.Sequence[Document], direction="write"
+                    object_=documents, annotation=typing.Sequence[IngestRemoteDocument], direction="write"
                 ),
             },
             headers={
@@ -205,21 +120,17 @@ class DocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def delete(
-        self,
-        *,
-        document_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
-        request_options: typing.Optional[RequestOptions] = None,
+    def ingest_local(
+        self, *, request: DocumentLocalIngestRequest, request_options: typing.Optional[RequestOptions] = None
     ) -> IngestResponse:
         """
-        Delete multiple documents hosted on GroundX
+        Upload documents hosted on a local file system into a GroundX bucket.
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        document_ids : typing.Optional[typing.Union[str, typing.Sequence[str]]]
-            A list of documentIds which correspond to documents ingested by GroundX
+        request : DocumentLocalIngestRequest
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -227,24 +138,36 @@ class DocumentsClient:
         Returns
         -------
         IngestResponse
-            Documents are queued to be deleted
+            Documents successfully uploaded
 
         Examples
         --------
-        from groundx import GroundX
+        from groundx import GroundX, IngestLocalDocument, IngestLocalDocumentMetadata
 
         client = GroundX(
             api_key="YOUR_API_KEY",
         )
-        client.documents.delete()
+        client.documents.ingest_local(
+            request=[
+                IngestLocalDocument(
+                    blob="blob",
+                    metadata=IngestLocalDocumentMetadata(
+                        bucket_id=1234,
+                        file_name="my_file1.txt",
+                        file_type="txt",
+                    ),
+                )
+            ],
+        )
         """
         _response = self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents",
-            method="DELETE",
-            params={
-                "documentIds": document_ids,
-            },
+            "v1/ingest/documents/local",
+            method="POST",
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=DocumentLocalIngestRequest, direction="write"
+            ),
             request_options=request_options,
+            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
@@ -280,20 +203,17 @@ class DocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def ingest_remote(
-        self,
-        *,
-        documents: typing.Sequence[IngestRemoteDocument],
-        request_options: typing.Optional[RequestOptions] = None,
+    def crawl_website(
+        self, *, websites: typing.Sequence[WebsiteSource], request_options: typing.Optional[RequestOptions] = None
     ) -> IngestResponse:
         """
-        Ingest documents hosted on public URLs to a GroundX bucket.
+        Upload the content of a publicly accessible website for ingestion into a GroundX bucket. This is done by following links within a specified URL, recursively, up to a specified depth or number of pages.
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        documents : typing.Sequence[IngestRemoteDocument]
+        websites : typing.Sequence[WebsiteSource]
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -301,30 +221,33 @@ class DocumentsClient:
         Returns
         -------
         IngestResponse
-            Documents successfully uploaded
+            Website successfully queued
 
         Examples
         --------
-        from groundx import GroundX, IngestRemoteDocument
+        from groundx import GroundX, WebsiteSource
 
         client = GroundX(
             api_key="YOUR_API_KEY",
         )
-        client.documents.ingest_remote(
-            documents=[
-                IngestRemoteDocument(
+        client.documents.crawl_website(
+            websites=[
+                WebsiteSource(
                     bucket_id=1234,
-                    source_url="https://my.source.url.com/file.txt",
+                    cap=100,
+                    depth=3,
+                    search_data={"key": "value"},
+                    source_url="https://my.website.com",
                 )
             ],
         )
         """
         _response = self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents/remote",
+            "v1/ingest/documents/website",
             method="POST",
             json={
-                "documents": convert_and_respect_annotation_metadata(
-                    object_=documents, annotation=typing.Sequence[IngestRemoteDocument], direction="write"
+                "websites": convert_and_respect_annotation_metadata(
+                    object_=websites, annotation=typing.Sequence[WebsiteSource], direction="write"
                 ),
             },
             headers={
@@ -367,28 +290,49 @@ class DocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def ingest_local(
+    def list(
         self,
         *,
-        documents: typing.Optional[typing.List[IngestLocalDocument]] = OMIT,
+        n: typing.Optional[int] = None,
+        filter: typing.Optional[str] = None,
+        sort: typing.Optional[Sort] = None,
+        sort_order: typing.Optional[SortOrder] = None,
+        status: typing.Optional[ProcessingStatus] = None,
+        next_token: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> IngestResponse:
+    ) -> DocumentListResponse:
         """
-        Upload documents hosted on a local file system for ingestion into a GroundX bucket.
+        lookup all documents across all resources which are currently on GroundX
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        documents : typing.Optional[typing.List[IngestLocalDocument]]
+        n : typing.Optional[int]
+            The maximum number of returned documents. Accepts 1-100 with a default of 20.
+
+        filter : typing.Optional[str]
+            Only documents with names that contain the filter string will be returned in the results.
+
+        sort : typing.Optional[Sort]
+            The document attribute that will be used to sort the results.
+
+        sort_order : typing.Optional[SortOrder]
+            The order in which to sort the results. A value for sort must also be set.
+
+        status : typing.Optional[ProcessingStatus]
+            A status filter on the get documents query. If this value is set, then only documents with this status will be returned in the results.
+
+        next_token : typing.Optional[str]
+            A token for pagination. If the number of documents for a given query is larger than n, the response will include a "nextToken" value. That token can be included in this field to retrieve the next batch of n documents.
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        IngestResponse
-            Documents successfully uploaded
+        DocumentListResponse
+            Look up success
 
         Examples
         --------
@@ -397,63 +341,50 @@ class DocumentsClient:
         client = GroundX(
             api_key="YOUR_API_KEY",
         )
-        client.documents.ingest_local()
+        client.documents.list()
         """
         _response = self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents/local",
-            method="POST",
-            data={
-                "documents": documents,
+            "v1/ingest/documents",
+            method="GET",
+            params={
+                "n": n,
+                "filter": filter,
+                "sort": sort,
+                "sortOrder": sort_order,
+                "status": status,
+                "nextToken": next_token,
             },
-            files={},
             request_options=request_options,
-            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
                 return typing.cast(
-                    IngestResponse,
+                    DocumentListResponse,
                     parse_obj_as(
-                        type_=IngestResponse,  # type: ignore
+                        type_=DocumentListResponse,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
-            if _response.status_code == 400:
-                raise BadRequestError(
-                    typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    )
-                )
-            if _response.status_code == 401:
-                raise UnauthorizedError(
-                    typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    )
-                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def crawl_website(
-        self, *, websites: typing.Sequence[WebsiteSource], request_options: typing.Optional[RequestOptions] = None
+    def delete(
+        self,
+        *,
+        document_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> IngestResponse:
         """
-        Upload the content of a publicly accessible website for ingestion into a GroundX bucket. This is done by following links within a specified URL, recursively, up to a specified depth or number of pages.
+        Delete multiple documents hosted on GroundX
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        websites : typing.Sequence[WebsiteSource]
+        document_ids : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            A list of documentIds which correspond to documents ingested by GroundX
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -461,40 +392,24 @@ class DocumentsClient:
         Returns
         -------
         IngestResponse
-            Website successfully queued
+            Documents are queued to be deleted
 
         Examples
         --------
-        from groundx import GroundX, WebsiteSource
+        from groundx import GroundX
 
         client = GroundX(
             api_key="YOUR_API_KEY",
         )
-        client.documents.crawl_website(
-            websites=[
-                WebsiteSource(
-                    bucket_id=1234,
-                    cap=100,
-                    depth=3,
-                    search_data={"key": "value"},
-                    source_url="https://my.website.com",
-                )
-            ],
-        )
+        client.documents.delete()
         """
         _response = self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents/website",
-            method="POST",
-            json={
-                "websites": convert_and_respect_annotation_metadata(
-                    object_=websites, annotation=typing.Sequence[WebsiteSource], direction="write"
-                ),
-            },
-            headers={
-                "content-type": "application/json",
+            "v1/ingest/documents",
+            method="DELETE",
+            params={
+                "documentIds": document_ids,
             },
             request_options=request_options,
-            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
@@ -782,175 +697,90 @@ class DocumentsClient:
         """
         Delete a single document hosted on GroundX
 
-        Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
-
-        Parameters
-        ----------
-        document_id : str
-            A documentId which correspond to a document ingested by GroundX
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        IngestResponse
-            Document successfully deleted
-
-        Examples
-        --------
-        from groundx import GroundX
-
-        client = GroundX(
-            api_key="YOUR_API_KEY",
-        )
-        client.documents.delete_by_id(
-            document_id="documentId",
-        )
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            f"v1/ingest/document/{jsonable_encoder(document_id)}",
-            method="DELETE",
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    IngestResponse,
-                    parse_obj_as(
-                        type_=IngestResponse,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            if _response.status_code == 400:
-                raise BadRequestError(
-                    typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    )
-                )
-            if _response.status_code == 401:
-                raise UnauthorizedError(
-                    typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    )
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
-
-class AsyncDocumentsClient:
-    def __init__(self, *, client_wrapper: AsyncClientWrapper):
-        self._client_wrapper = client_wrapper
-
-    async def list(
-        self,
-        *,
-        n: typing.Optional[int] = None,
-        filter: typing.Optional[str] = None,
-        sort: typing.Optional[Sort] = None,
-        sort_order: typing.Optional[SortOrder] = None,
-        status: typing.Optional[ProcessingStatus] = None,
-        next_token: typing.Optional[str] = None,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> DocumentListResponse:
-        """
-        lookup all documents across all resources which are currently on GroundX
-
-        Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
-
-        Parameters
-        ----------
-        n : typing.Optional[int]
-            The maximum number of returned documents. Accepts 1-100 with a default of 20.
-
-        filter : typing.Optional[str]
-            Only documents with names that contain the filter string will be returned in the results.
-
-        sort : typing.Optional[Sort]
-            The document attribute that will be used to sort the results.
-
-        sort_order : typing.Optional[SortOrder]
-            The order in which to sort the results. A value for sort must also be set.
-
-        status : typing.Optional[ProcessingStatus]
-            A status filter on the get documents query. If this value is set, then only documents with this status will be returned in the results.
+        Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
-        next_token : typing.Optional[str]
-            A token for pagination. If the number of documents for a given query is larger than n, the response will include a "nextToken" value. That token can be included in this field to retrieve the next batch of n documents.
+        Parameters
+        ----------
+        document_id : str
+            A documentId which correspond to a document ingested by GroundX
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        DocumentListResponse
-            Look up success
+        IngestResponse
+            Document successfully deleted
 
         Examples
         --------
-        import asyncio
-
-        from groundx import AsyncGroundX
+        from groundx import GroundX
 
-        client = AsyncGroundX(
+        client = GroundX(
             api_key="YOUR_API_KEY",
         )
-
-
-        async def main() -> None:
-            await client.documents.list()
-
-
-        asyncio.run(main())
+        client.documents.delete_by_id(
+            document_id="documentId",
+        )
         """
-        _response = await self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents",
-            method="GET",
-            params={
-                "n": n,
-                "filter": filter,
-                "sort": sort,
-                "sortOrder": sort_order,
-                "status": status,
-                "nextToken": next_token,
-            },
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/ingest/document/{jsonable_encoder(document_id)}",
+            method="DELETE",
             request_options=request_options,
         )
         try:
             if 200 <= _response.status_code < 300:
                 return typing.cast(
-                    DocumentListResponse,
+                    IngestResponse,
                     parse_obj_as(
-                        type_=DocumentListResponse,  # type: ignore
+                        type_=IngestResponse,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def ingest(
-        self, *, documents: typing.Sequence[Document], request_options: typing.Optional[RequestOptions] = None
+
+class AsyncDocumentsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def ingest_remote(
+        self,
+        *,
+        documents: typing.Sequence[IngestRemoteDocument],
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> IngestResponse:
         """
-        Ingest documents hosted on public URLs or a local file system for ingestion into a GroundX bucket.
+        Ingest documents hosted on public URLs into a GroundX bucket.
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        documents : typing.Sequence[Document]
+        documents : typing.Sequence[IngestRemoteDocument]
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -964,7 +794,7 @@ class AsyncDocumentsClient:
         --------
         import asyncio
 
-        from groundx import AsyncGroundX, Document
+        from groundx import AsyncGroundX, IngestRemoteDocument
 
         client = AsyncGroundX(
             api_key="YOUR_API_KEY",
@@ -972,21 +802,14 @@ class AsyncDocumentsClient:
 
 
         async def main() -> None:
-            await client.documents.ingest(
+            await client.documents.ingest_remote(
                 documents=[
-                    Document(
+                    IngestRemoteDocument(
                         bucket_id=1234,
                         file_name="my_file1.txt",
-                        file_path="https://my.source.url.com/file1.txt",
                         file_type="txt",
-                        search_data={"key": "value"},
-                    ),
-                    Document(
-                        bucket_id=1234,
-                        file_name="my_file2.pdf",
-                        file_path="/local/path/file2.pdf",
-                        file_type="pdf",
-                    ),
+                        source_url="https://my.source.url.com/file1.txt",
+                    )
                 ],
             )
 
@@ -994,11 +817,11 @@ class AsyncDocumentsClient:
         asyncio.run(main())
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents",
+            "v1/ingest/documents/remote",
             method="POST",
             json={
                 "documents": convert_and_respect_annotation_metadata(
-                    object_=documents, annotation=typing.Sequence[Document], direction="write"
+                    object_=documents, annotation=typing.Sequence[IngestRemoteDocument], direction="write"
                 ),
             },
             headers={
@@ -1041,21 +864,17 @@ class AsyncDocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def delete(
-        self,
-        *,
-        document_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
-        request_options: typing.Optional[RequestOptions] = None,
+    async def ingest_local(
+        self, *, request: DocumentLocalIngestRequest, request_options: typing.Optional[RequestOptions] = None
     ) -> IngestResponse:
         """
-        Delete multiple documents hosted on GroundX
+        Upload documents hosted on a local file system into a GroundX bucket.
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        document_ids : typing.Optional[typing.Union[str, typing.Sequence[str]]]
-            A list of documentIds which correspond to documents ingested by GroundX
+        request : DocumentLocalIngestRequest
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -1063,13 +882,17 @@ class AsyncDocumentsClient:
         Returns
         -------
         IngestResponse
-            Documents are queued to be deleted
+            Documents successfully uploaded
 
         Examples
         --------
         import asyncio
 
-        from groundx import AsyncGroundX
+        from groundx import (
+            AsyncGroundX,
+            IngestLocalDocument,
+            IngestLocalDocumentMetadata,
+        )
 
         client = AsyncGroundX(
             api_key="YOUR_API_KEY",
@@ -1077,18 +900,30 @@ class AsyncDocumentsClient:
 
 
         async def main() -> None:
-            await client.documents.delete()
+            await client.documents.ingest_local(
+                request=[
+                    IngestLocalDocument(
+                        blob="blob",
+                        metadata=IngestLocalDocumentMetadata(
+                            bucket_id=1234,
+                            file_name="my_file1.txt",
+                            file_type="txt",
+                        ),
+                    )
+                ],
+            )
 
 
         asyncio.run(main())
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents",
-            method="DELETE",
-            params={
-                "documentIds": document_ids,
-            },
+            "v1/ingest/documents/local",
+            method="POST",
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=DocumentLocalIngestRequest, direction="write"
+            ),
             request_options=request_options,
+            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
@@ -1124,20 +959,17 @@ class AsyncDocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def ingest_remote(
-        self,
-        *,
-        documents: typing.Sequence[IngestRemoteDocument],
-        request_options: typing.Optional[RequestOptions] = None,
+    async def crawl_website(
+        self, *, websites: typing.Sequence[WebsiteSource], request_options: typing.Optional[RequestOptions] = None
     ) -> IngestResponse:
         """
-        Ingest documents hosted on public URLs to a GroundX bucket.
+        Upload the content of a publicly accessible website for ingestion into a GroundX bucket. This is done by following links within a specified URL, recursively, up to a specified depth or number of pages.
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        documents : typing.Sequence[IngestRemoteDocument]
+        websites : typing.Sequence[WebsiteSource]
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -1145,13 +977,13 @@ class AsyncDocumentsClient:
         Returns
         -------
         IngestResponse
-            Documents successfully uploaded
+            Website successfully queued
 
         Examples
         --------
         import asyncio
 
-        from groundx import AsyncGroundX, IngestRemoteDocument
+        from groundx import AsyncGroundX, WebsiteSource
 
         client = AsyncGroundX(
             api_key="YOUR_API_KEY",
@@ -1159,11 +991,14 @@ class AsyncDocumentsClient:
 
 
         async def main() -> None:
-            await client.documents.ingest_remote(
-                documents=[
-                    IngestRemoteDocument(
+            await client.documents.crawl_website(
+                websites=[
+                    WebsiteSource(
                         bucket_id=1234,
-                        source_url="https://my.source.url.com/file.txt",
+                        cap=100,
+                        depth=3,
+                        search_data={"key": "value"},
+                        source_url="https://my.website.com",
                     )
                 ],
             )
@@ -1172,11 +1007,11 @@ class AsyncDocumentsClient:
         asyncio.run(main())
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents/remote",
+            "v1/ingest/documents/website",
             method="POST",
             json={
-                "documents": convert_and_respect_annotation_metadata(
-                    object_=documents, annotation=typing.Sequence[IngestRemoteDocument], direction="write"
+                "websites": convert_and_respect_annotation_metadata(
+                    object_=websites, annotation=typing.Sequence[WebsiteSource], direction="write"
                 ),
             },
             headers={
@@ -1219,28 +1054,49 @@ class AsyncDocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def ingest_local(
+    async def list(
         self,
         *,
-        documents: typing.Optional[typing.List[IngestLocalDocument]] = OMIT,
+        n: typing.Optional[int] = None,
+        filter: typing.Optional[str] = None,
+        sort: typing.Optional[Sort] = None,
+        sort_order: typing.Optional[SortOrder] = None,
+        status: typing.Optional[ProcessingStatus] = None,
+        next_token: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> IngestResponse:
+    ) -> DocumentListResponse:
         """
-        Upload documents hosted on a local file system for ingestion into a GroundX bucket.
+        lookup all documents across all resources which are currently on GroundX
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        documents : typing.Optional[typing.List[IngestLocalDocument]]
+        n : typing.Optional[int]
+            The maximum number of returned documents. Accepts 1-100 with a default of 20.
+
+        filter : typing.Optional[str]
+            Only documents with names that contain the filter string will be returned in the results.
+
+        sort : typing.Optional[Sort]
+            The document attribute that will be used to sort the results.
+
+        sort_order : typing.Optional[SortOrder]
+            The order in which to sort the results. A value for sort must also be set.
+
+        status : typing.Optional[ProcessingStatus]
+            A status filter on the get documents query. If this value is set, then only documents with this status will be returned in the results.
+
+        next_token : typing.Optional[str]
+            A token for pagination. If the number of documents for a given query is larger than n, the response will include a "nextToken" value. That token can be included in this field to retrieve the next batch of n documents.
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        IngestResponse
-            Documents successfully uploaded
+        DocumentListResponse
+            Look up success
 
         Examples
         --------
@@ -1254,66 +1110,53 @@ class AsyncDocumentsClient:
 
 
         async def main() -> None:
-            await client.documents.ingest_local()
+            await client.documents.list()
 
 
         asyncio.run(main())
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents/local",
-            method="POST",
-            data={
-                "documents": documents,
+            "v1/ingest/documents",
+            method="GET",
+            params={
+                "n": n,
+                "filter": filter,
+                "sort": sort,
+                "sortOrder": sort_order,
+                "status": status,
+                "nextToken": next_token,
             },
-            files={},
             request_options=request_options,
-            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
                 return typing.cast(
-                    IngestResponse,
+                    DocumentListResponse,
                     parse_obj_as(
-                        type_=IngestResponse,  # type: ignore
+                        type_=DocumentListResponse,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
-            if _response.status_code == 400:
-                raise BadRequestError(
-                    typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    )
-                )
-            if _response.status_code == 401:
-                raise UnauthorizedError(
-                    typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    )
-                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def crawl_website(
-        self, *, websites: typing.Sequence[WebsiteSource], request_options: typing.Optional[RequestOptions] = None
+    async def delete(
+        self,
+        *,
+        document_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> IngestResponse:
         """
-        Upload the content of a publicly accessible website for ingestion into a GroundX bucket. This is done by following links within a specified URL, recursively, up to a specified depth or number of pages.
+        Delete multiple documents hosted on GroundX
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        websites : typing.Sequence[WebsiteSource]
+        document_ids : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            A list of documentIds which correspond to documents ingested by GroundX
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -1321,13 +1164,13 @@ class AsyncDocumentsClient:
         Returns
         -------
         IngestResponse
-            Website successfully queued
+            Documents are queued to be deleted
 
         Examples
         --------
         import asyncio
 
-        from groundx import AsyncGroundX, WebsiteSource
+        from groundx import AsyncGroundX
 
         client = AsyncGroundX(
             api_key="YOUR_API_KEY",
@@ -1335,34 +1178,18 @@ class AsyncDocumentsClient:
 
 
         async def main() -> None:
-            await client.documents.crawl_website(
-                websites=[
-                    WebsiteSource(
-                        bucket_id=1234,
-                        cap=100,
-                        depth=3,
-                        search_data={"key": "value"},
-                        source_url="https://my.website.com",
-                    )
-                ],
-            )
+            await client.documents.delete()
 
 
         asyncio.run(main())
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents/website",
-            method="POST",
-            json={
-                "websites": convert_and_respect_annotation_metadata(
-                    object_=websites, annotation=typing.Sequence[WebsiteSource], direction="write"
-                ),
-            },
-            headers={
-                "content-type": "application/json",
+            "v1/ingest/documents",
+            method="DELETE",
+            params={
+                "documentIds": document_ids,
             },
             request_options=request_options,
-            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300: