cherami 0.1.0__py3-none-any.whl

cherami/__init__.py

@@ -0,0 +1,16 @@
+"""Official synchronous and asynchronous Cherami HTTP clients."""
+from . import models as models
+from ._operations import AsyncCherami as AsyncCherami, Cherami as Cherami
+from ._transport import (
+    ApiResponse as ApiResponse,
+    CheramiApiError as CheramiApiError,
+    CheramiTransportError as CheramiTransportError,
+)
+from .attachments import attachment as attachment, attachment_bytes as attachment_bytes
+from .recovery import (
+    PreparedSend as PreparedSend,
+    SendOperation as SendOperation,
+    SendRecoveryExpiredError as SendRecoveryExpiredError,
+    prepare_send as prepare_send,
+    restore_send as restore_send,
+)

cherami/_client.py

@@ -0,0 +1,187 @@
+"""Connection lifetime and lazy pagination over shared wire/recovery policies."""
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Iterator
+from copy import deepcopy
+from typing import Any, Self
+
+import httpx
+
+from . import models
+from ._routes import PAGE_FIELDS, ROUTES
+from ._transport import (
+    ApiResponse, DEFAULT_TIMEOUT, Route, Timeout, WirePolicy,
+    decode_response, envelope, is_download, transport_error,
+)
+from .recovery import PreparedSend, check_send_window, restore_send
+
+
+def _pagination(operation: str, params: Any, max_pages: int | None) -> tuple[dict[str, Any], str | None, set[str]]:
+    if operation not in PAGE_FIELDS:
+        raise ValueError("Operation is not paginated.")
+    if max_pages is not None and (type(max_pages) is not int or max_pages < 1):
+        raise ValueError("max_pages must be a positive integer or None.")
+    if not isinstance(params, dict):
+        raise TypeError("Supply a parameter dictionary.")
+    # This runs when the iterator is obtained, not on its first advancement.
+    # Caller mutations during a pause cannot change the query's meaning.
+    snapshot = deepcopy(params)
+    cursor = snapshot.get("cursor")
+    if cursor is not None and (not isinstance(cursor, str) or not cursor):
+        raise ValueError("Invalid pagination cursor.")
+    return snapshot, cursor, {cursor} if cursor else set()
+
+
+def _next_page(result: ApiResponse[Any], seen: set[str]) -> str | None:
+    if "next_cursor" not in result.data:
+        raise ValueError("Missing pagination cursor; inspect the response before restarting.")
+    cursor = result.data["next_cursor"]
+    if cursor is not None:
+        if not isinstance(cursor, str) or not cursor or cursor in seen:
+            raise ValueError("Invalid or repeated pagination cursor; inspect the response before restarting.")
+        seen.add(cursor)
+    return cursor
+
+
+def _items(result: ApiResponse[Any], operation: str) -> list[Any]:
+    items = result.data.get(PAGE_FIELDS[operation])
+    if not isinstance(items, list):
+        raise ValueError("Invalid paginated collection in Cherami response.")
+    return items
+
+
+def _intent(prepared: PreparedSend) -> PreparedSend:
+    # Even direct construction of PreparedSend cannot bypass record validation.
+    record = restore_send(prepared.to_json())
+    check_send_window(record)
+    return record
+
+
+class SyncClient:
+    def __init__(self, api_key: str, *, base_url: str = "https://cherami.to", timeout: float | None = 60.0, transport: httpx.BaseTransport | None = None):
+        """Use an existing approved key. Custom transports must not retry writes.
+
+        timeout is HTTPX's per-operation inactivity timeout, in seconds; None
+        disables it. Environment proxies and implicit redirects are disabled.
+        """
+        self._wire = WirePolicy(api_key, base_url, timeout)
+        self._http = httpx.Client(follow_redirects=False, trust_env=False, transport=transport)
+
+    def __enter__(self) -> Self:
+        self._http.__enter__()
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._http.close()
+
+    def _request(self, route: Route, params: Any, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[Any]:
+        request = self._http.build_request(**self._wire.request_parts(route, params, timeout))
+        response = None
+        download = False
+        try:
+            # One request only. Always stream initially so binary bodies belong to
+            # the caller; JSON/error bodies are consumed and closed here instead.
+            response = self._http.send(request, stream=True, follow_redirects=False)
+            download = is_download(route, response)
+            if download:
+                return envelope(response, response)
+            response.read()
+            return decode_response(route, response)
+        except httpx.HTTPError as cause:
+            raise transport_error(response) from cause
+        finally:
+            if response is not None and not download:
+                response.close()
+
+    def submit(self, prepared: PreparedSend, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.SendReceipt]:
+        """Submit/recover a persisted intent once, without extending its window."""
+        record = _intent(prepared)
+        return self._request(ROUTES[record.operation], record.params, timeout=timeout)
+
+    def _pages(self, operation: str, params: Any, *, max_pages: int | None, timeout: Timeout) -> Iterator[ApiResponse[Any]]:
+        snapshot, cursor, seen = _pagination(operation, params, max_pages)
+
+        def generate() -> Iterator[ApiResponse[Any]]:
+            nonlocal cursor
+            count = 0
+            while max_pages is None or count < max_pages:
+                query = {**snapshot, **({"cursor": cursor} if cursor is not None else {})}
+                result = self._request(ROUTES[operation], query, timeout=timeout)
+                cursor = _next_page(result, seen)
+                yield result
+                count += 1
+                if cursor is None:
+                    return
+        return generate()
+
+    def _iterate(self, operation: str, params: Any, *, max_pages: int | None, timeout: Timeout) -> Iterator[Any]:
+        pages = self._pages(operation, params, max_pages=max_pages, timeout=timeout)
+        return (item for result in pages for item in _items(result, operation))
+
+
+class AsyncClient:
+    def __init__(self, api_key: str, *, base_url: str = "https://cherami.to", timeout: float | None = 60.0, transport: httpx.AsyncBaseTransport | None = None):
+        """Async I/O using the same policies and models as Cherami. No retries."""
+        self._wire = WirePolicy(api_key, base_url, timeout)
+        self._http = httpx.AsyncClient(follow_redirects=False, trust_env=False, transport=transport)
+
+    async def __aenter__(self) -> Self:
+        await self._http.__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def _request(self, route: Route, params: Any, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[Any]:
+        request = self._http.build_request(**self._wire.request_parts(route, params, timeout))
+        response = None
+        download = False
+        try:
+            response = await self._http.send(request, stream=True, follow_redirects=False)
+            download = is_download(route, response)
+            if download:
+                return envelope(response, response)
+            await response.aread()
+            return decode_response(route, response)
+        except httpx.HTTPError as cause:
+            raise transport_error(response) from cause
+        finally:
+            if response is not None and not download:
+                await response.aclose()
+        # Cancellation (including asyncio.CancelledError) deliberately propagates
+        # rather than being swallowed or retried. It cannot undo a submitted write.
+
+    async def submit(self, prepared: PreparedSend, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.SendReceipt]:
+        record = _intent(prepared)
+        return await self._request(ROUTES[record.operation], record.params, timeout=timeout)
+
+    def _pages(self, operation: str, params: Any, *, max_pages: int | None, timeout: Timeout) -> AsyncIterator[ApiResponse[Any]]:
+        snapshot, cursor, seen = _pagination(operation, params, max_pages)
+
+        async def generate() -> AsyncIterator[ApiResponse[Any]]:
+            nonlocal cursor
+            count = 0
+            while max_pages is None or count < max_pages:
+                query = {**snapshot, **({"cursor": cursor} if cursor is not None else {})}
+                result = await self._request(ROUTES[operation], query, timeout=timeout)
+                cursor = _next_page(result, seen)
+                yield result
+                count += 1
+                if cursor is None:
+                    return
+        return generate()
+
+    def _iterate(self, operation: str, params: Any, *, max_pages: int | None, timeout: Timeout) -> AsyncIterator[Any]:
+        pages = self._pages(operation, params, max_pages=max_pages, timeout=timeout)
+
+        async def generate() -> AsyncIterator[Any]:
+            async for result in pages:
+                for item in _items(result, operation):
+                    yield item
+        return generate()

cherami/_operations.py

@@ -0,0 +1,383 @@
+# Generated from openapi.json by bun scripts/generate.mts. Do not edit.
+from collections.abc import AsyncIterator, Iterator
+from typing import Any, Literal, overload
+import httpx
+from . import models
+from ._transport import ApiResponse, DEFAULT_TIMEOUT, Timeout
+from ._client import SyncClient, AsyncClient
+from ._routes import ROUTES
+
+class Cherami(SyncClient):
+    def list_inboxes(self, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListInboxesResult]:
+        """List inboxes. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["list_inboxes"], {}, timeout=timeout)
+
+    def create_inbox(self, params: models.CreateInboxParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.CreateInboxResult]:
+        """Create an inbox. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["create_inbox"], params, timeout=timeout)
+
+    def get_inbox(self, params: models.GetInboxParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetInboxResult]:
+        """Read an inbox. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["get_inbox"], params, timeout=timeout)
+
+    def update_inbox(self, params: models.UpdateInboxParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.UpdateInboxResult]:
+        """Edit inbox names. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["update_inbox"], params, timeout=timeout)
+
+    def delete_inbox(self, params: models.DeleteInboxParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.DeleteInboxResult]:
+        """Delete an inbox. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["delete_inbox"], params, timeout=timeout)
+
+    def get_sending_policy(self, params: models.GetSendingPolicyParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetSendingPolicyResult]:
+        """Inspect sending rules. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["get_sending_policy"], params, timeout=timeout)
+
+    def get_receiving_policy(self, params: models.GetReceivingPolicyParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetReceivingPolicyResult]:
+        """Inspect receiving rules. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["get_receiving_policy"], params, timeout=timeout)
+
+    def list_messages(self, params: models.ListMessagesParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListMessagesResult]:
+        """List received messages. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["list_messages"], params, timeout=timeout)
+
+    def count_messages(self, params: models.CountMessagesParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.CountMessagesResult]:
+        """Count received messages. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["count_messages"], params, timeout=timeout)
+
+    def get_message(self, params: models.GetMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetMessageResult]:
+        """Read a received message. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["get_message"], params, timeout=timeout)
+
+    def delete_message(self, params: models.DeleteMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.DeleteMessageResult]:
+        """Delete a received message. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["delete_message"], params, timeout=timeout)
+
+    def update_message_labels(self, params: models.UpdateMessageLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.UpdateMessageLabelsResult]:
+        """Label a received message. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["update_message_labels"], params, timeout=timeout)
+
+    def download_raw_message(self, params: models.DownloadRawMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[httpx.Response]:
+        """Download raw MIME. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["download_raw_message"], params, timeout=timeout)
+
+    def download_attachment(self, params: models.DownloadAttachmentParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[httpx.Response]:
+        """Download a received attachment. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["download_attachment"], params, timeout=timeout)
+
+    def delete_sent_message(self, params: models.DeleteSentMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.DeleteSentMessageResult]:
+        """Delete a sent copy. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["delete_sent_message"], params, timeout=timeout)
+
+    def update_sent_message_labels(self, params: models.UpdateSentMessageLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.UpdateSentMessageLabelsResult]:
+        """Label a sent copy. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["update_sent_message_labels"], params, timeout=timeout)
+
+    def get_sent_message(self, params: models.GetSentMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetSentMessageResult]:
+        """Read a sent message. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["get_sent_message"], params, timeout=timeout)
+
+    def bulk_update_message_labels(self, params: models.BulkUpdateMessageLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.BulkUpdateMessageLabelsResult]:
+        """Label several received messages. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["bulk_update_message_labels"], params, timeout=timeout)
+
+    def bulk_update_sent_labels(self, params: models.BulkUpdateSentLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.BulkUpdateSentLabelsResult]:
+        """Label several sent copies. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["bulk_update_sent_labels"], params, timeout=timeout)
+
+    def list_labels(self, params: models.ListLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListLabelsResult]:
+        """Discover labels. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["list_labels"], params, timeout=timeout)
+
+    def send_message(self, params: models.SendMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.SendMessageResult]:
+        """Send a message. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["send_message"], params, timeout=timeout)
+
+    def list_sent_messages(self, params: models.ListSentMessagesParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListSentMessagesResult]:
+        """List sent messages. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["list_sent_messages"], params, timeout=timeout)
+
+    def reply_message(self, params: models.ReplyMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ReplyMessageResult]:
+        """Reply to a message. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["reply_message"], params, timeout=timeout)
+
+    def reply_all_message(self, params: models.ReplyAllMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ReplyAllMessageResult]:
+        """Reply to visible participants. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["reply_all_message"], params, timeout=timeout)
+
+    def forward_message(self, params: models.ForwardMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ForwardMessageResult]:
+        """Forward a message. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["forward_message"], params, timeout=timeout)
+
+    def get_outbound_quota(self, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetOutboundQuotaResult]:
+        """Read sending allowance. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["get_outbound_quota"], {}, timeout=timeout)
+
+    def create_draft(self, params: models.CreateDraftParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.CreateDraftResult]:
+        """Create a draft. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["create_draft"], params, timeout=timeout)
+
+    def list_drafts(self, params: models.ListDraftsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListDraftsResult]:
+        """List drafts. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["list_drafts"], params, timeout=timeout)
+
+    def get_draft(self, params: models.GetDraftParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetDraftResult]:
+        """Retrieve a draft. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["get_draft"], params, timeout=timeout)
+
+    def update_draft(self, params: models.UpdateDraftParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.UpdateDraftResult]:
+        """Edit a draft. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["update_draft"], params, timeout=timeout)
+
+    def delete_draft(self, params: models.DeleteDraftParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.DeleteDraftResult]:
+        """Delete a draft. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["delete_draft"], params, timeout=timeout)
+
+    def send_draft(self, params: models.SendDraftParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.SendDraftResult]:
+        """Send a draft. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["send_draft"], params, timeout=timeout)
+
+    def list_threads(self, params: models.ListThreadsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListThreadsResult]:
+        """List conversations. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["list_threads"], params, timeout=timeout)
+
+    def get_thread(self, params: models.GetThreadParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetThreadResult]:
+        """Read a conversation. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["get_thread"], params, timeout=timeout)
+
+    def update_thread_labels(self, params: models.UpdateThreadLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.UpdateThreadLabelsResult]:
+        """Label a conversation. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["update_thread_labels"], params, timeout=timeout)
+
+    def delete_thread(self, params: models.DeleteThreadParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.DeleteThreadResult]:
+        """Delete a conversation. See the HTTP reference for state/recovery semantics."""
+        return self._request(ROUTES["delete_thread"], params, timeout=timeout)
+
+    @overload
+    def pages(self, operation: Literal["list_messages"], params: models.ListMessagesParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[ApiResponse[models.ListMessagesResult]]: ...
+
+    @overload
+    def pages(self, operation: Literal["list_labels"], params: models.ListLabelsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[ApiResponse[models.ListLabelsResult]]: ...
+
+    @overload
+    def pages(self, operation: Literal["list_sent_messages"], params: models.ListSentMessagesParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[ApiResponse[models.ListSentMessagesResult]]: ...
+
+    @overload
+    def pages(self, operation: Literal["list_drafts"], params: models.ListDraftsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[ApiResponse[models.ListDraftsResult]]: ...
+
+    @overload
+    def pages(self, operation: Literal["list_threads"], params: models.ListThreadsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[ApiResponse[models.ListThreadsResult]]: ...
+
+    @overload
+    def pages(self, operation: Literal["get_thread"], params: models.GetThreadParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[ApiResponse[models.GetThreadResult]]: ...
+
+    def pages(self, operation: str, params: Any, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[ApiResponse[Any]]:
+        return self._pages(operation, params, max_pages=max_pages, timeout=timeout)
+
+    @overload
+    def iterate(self, operation: Literal["list_messages"], params: models.ListMessagesParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[models.ListMessagesItem]: ...
+
+    @overload
+    def iterate(self, operation: Literal["list_labels"], params: models.ListLabelsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[models.ListLabelsItem]: ...
+
+    @overload
+    def iterate(self, operation: Literal["list_sent_messages"], params: models.ListSentMessagesParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[models.ListSentMessagesItem]: ...
+
+    @overload
+    def iterate(self, operation: Literal["list_drafts"], params: models.ListDraftsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[models.ListDraftsItem]: ...
+
+    @overload
+    def iterate(self, operation: Literal["list_threads"], params: models.ListThreadsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[models.ListThreadsItem]: ...
+
+    @overload
+    def iterate(self, operation: Literal["get_thread"], params: models.GetThreadParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[models.GetThreadItem]: ...
+
+    def iterate(self, operation: str, params: Any, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> Iterator[Any]:
+        return self._iterate(operation, params, max_pages=max_pages, timeout=timeout)
+
+
+class AsyncCherami(AsyncClient):
+    async def list_inboxes(self, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListInboxesResult]:
+        """List inboxes. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["list_inboxes"], {}, timeout=timeout)
+
+    async def create_inbox(self, params: models.CreateInboxParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.CreateInboxResult]:
+        """Create an inbox. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["create_inbox"], params, timeout=timeout)
+
+    async def get_inbox(self, params: models.GetInboxParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetInboxResult]:
+        """Read an inbox. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["get_inbox"], params, timeout=timeout)
+
+    async def update_inbox(self, params: models.UpdateInboxParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.UpdateInboxResult]:
+        """Edit inbox names. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["update_inbox"], params, timeout=timeout)
+
+    async def delete_inbox(self, params: models.DeleteInboxParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.DeleteInboxResult]:
+        """Delete an inbox. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["delete_inbox"], params, timeout=timeout)
+
+    async def get_sending_policy(self, params: models.GetSendingPolicyParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetSendingPolicyResult]:
+        """Inspect sending rules. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["get_sending_policy"], params, timeout=timeout)
+
+    async def get_receiving_policy(self, params: models.GetReceivingPolicyParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetReceivingPolicyResult]:
+        """Inspect receiving rules. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["get_receiving_policy"], params, timeout=timeout)
+
+    async def list_messages(self, params: models.ListMessagesParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListMessagesResult]:
+        """List received messages. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["list_messages"], params, timeout=timeout)
+
+    async def count_messages(self, params: models.CountMessagesParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.CountMessagesResult]:
+        """Count received messages. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["count_messages"], params, timeout=timeout)
+
+    async def get_message(self, params: models.GetMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetMessageResult]:
+        """Read a received message. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["get_message"], params, timeout=timeout)
+
+    async def delete_message(self, params: models.DeleteMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.DeleteMessageResult]:
+        """Delete a received message. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["delete_message"], params, timeout=timeout)
+
+    async def update_message_labels(self, params: models.UpdateMessageLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.UpdateMessageLabelsResult]:
+        """Label a received message. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["update_message_labels"], params, timeout=timeout)
+
+    async def download_raw_message(self, params: models.DownloadRawMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[httpx.Response]:
+        """Download raw MIME. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["download_raw_message"], params, timeout=timeout)
+
+    async def download_attachment(self, params: models.DownloadAttachmentParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[httpx.Response]:
+        """Download a received attachment. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["download_attachment"], params, timeout=timeout)
+
+    async def delete_sent_message(self, params: models.DeleteSentMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.DeleteSentMessageResult]:
+        """Delete a sent copy. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["delete_sent_message"], params, timeout=timeout)
+
+    async def update_sent_message_labels(self, params: models.UpdateSentMessageLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.UpdateSentMessageLabelsResult]:
+        """Label a sent copy. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["update_sent_message_labels"], params, timeout=timeout)
+
+    async def get_sent_message(self, params: models.GetSentMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetSentMessageResult]:
+        """Read a sent message. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["get_sent_message"], params, timeout=timeout)
+
+    async def bulk_update_message_labels(self, params: models.BulkUpdateMessageLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.BulkUpdateMessageLabelsResult]:
+        """Label several received messages. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["bulk_update_message_labels"], params, timeout=timeout)
+
+    async def bulk_update_sent_labels(self, params: models.BulkUpdateSentLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.BulkUpdateSentLabelsResult]:
+        """Label several sent copies. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["bulk_update_sent_labels"], params, timeout=timeout)
+
+    async def list_labels(self, params: models.ListLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListLabelsResult]:
+        """Discover labels. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["list_labels"], params, timeout=timeout)
+
+    async def send_message(self, params: models.SendMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.SendMessageResult]:
+        """Send a message. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["send_message"], params, timeout=timeout)
+
+    async def list_sent_messages(self, params: models.ListSentMessagesParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListSentMessagesResult]:
+        """List sent messages. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["list_sent_messages"], params, timeout=timeout)
+
+    async def reply_message(self, params: models.ReplyMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ReplyMessageResult]:
+        """Reply to a message. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["reply_message"], params, timeout=timeout)
+
+    async def reply_all_message(self, params: models.ReplyAllMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ReplyAllMessageResult]:
+        """Reply to visible participants. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["reply_all_message"], params, timeout=timeout)
+
+    async def forward_message(self, params: models.ForwardMessageParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ForwardMessageResult]:
+        """Forward a message. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["forward_message"], params, timeout=timeout)
+
+    async def get_outbound_quota(self, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetOutboundQuotaResult]:
+        """Read sending allowance. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["get_outbound_quota"], {}, timeout=timeout)
+
+    async def create_draft(self, params: models.CreateDraftParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.CreateDraftResult]:
+        """Create a draft. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["create_draft"], params, timeout=timeout)
+
+    async def list_drafts(self, params: models.ListDraftsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListDraftsResult]:
+        """List drafts. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["list_drafts"], params, timeout=timeout)
+
+    async def get_draft(self, params: models.GetDraftParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetDraftResult]:
+        """Retrieve a draft. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["get_draft"], params, timeout=timeout)
+
+    async def update_draft(self, params: models.UpdateDraftParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.UpdateDraftResult]:
+        """Edit a draft. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["update_draft"], params, timeout=timeout)
+
+    async def delete_draft(self, params: models.DeleteDraftParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.DeleteDraftResult]:
+        """Delete a draft. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["delete_draft"], params, timeout=timeout)
+
+    async def send_draft(self, params: models.SendDraftParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.SendDraftResult]:
+        """Send a draft. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["send_draft"], params, timeout=timeout)
+
+    async def list_threads(self, params: models.ListThreadsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.ListThreadsResult]:
+        """List conversations. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["list_threads"], params, timeout=timeout)
+
+    async def get_thread(self, params: models.GetThreadParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.GetThreadResult]:
+        """Read a conversation. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["get_thread"], params, timeout=timeout)
+
+    async def update_thread_labels(self, params: models.UpdateThreadLabelsParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.UpdateThreadLabelsResult]:
+        """Label a conversation. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["update_thread_labels"], params, timeout=timeout)
+
+    async def delete_thread(self, params: models.DeleteThreadParams, *, timeout: Timeout = DEFAULT_TIMEOUT) -> ApiResponse[models.DeleteThreadResult]:
+        """Delete a conversation. See the HTTP reference for state/recovery semantics."""
+        return await self._request(ROUTES["delete_thread"], params, timeout=timeout)
+
+    @overload
+    def pages(self, operation: Literal["list_messages"], params: models.ListMessagesParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[ApiResponse[models.ListMessagesResult]]: ...
+
+    @overload
+    def pages(self, operation: Literal["list_labels"], params: models.ListLabelsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[ApiResponse[models.ListLabelsResult]]: ...
+
+    @overload
+    def pages(self, operation: Literal["list_sent_messages"], params: models.ListSentMessagesParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[ApiResponse[models.ListSentMessagesResult]]: ...
+
+    @overload
+    def pages(self, operation: Literal["list_drafts"], params: models.ListDraftsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[ApiResponse[models.ListDraftsResult]]: ...
+
+    @overload
+    def pages(self, operation: Literal["list_threads"], params: models.ListThreadsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[ApiResponse[models.ListThreadsResult]]: ...
+
+    @overload
+    def pages(self, operation: Literal["get_thread"], params: models.GetThreadParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[ApiResponse[models.GetThreadResult]]: ...
+
+    def pages(self, operation: str, params: Any, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[ApiResponse[Any]]:
+        return self._pages(operation, params, max_pages=max_pages, timeout=timeout)
+
+    @overload
+    def iterate(self, operation: Literal["list_messages"], params: models.ListMessagesParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[models.ListMessagesItem]: ...
+
+    @overload
+    def iterate(self, operation: Literal["list_labels"], params: models.ListLabelsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[models.ListLabelsItem]: ...
+
+    @overload
+    def iterate(self, operation: Literal["list_sent_messages"], params: models.ListSentMessagesParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[models.ListSentMessagesItem]: ...
+
+    @overload
+    def iterate(self, operation: Literal["list_drafts"], params: models.ListDraftsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[models.ListDraftsItem]: ...
+
+    @overload
+    def iterate(self, operation: Literal["list_threads"], params: models.ListThreadsParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[models.ListThreadsItem]: ...
+
+    @overload
+    def iterate(self, operation: Literal["get_thread"], params: models.GetThreadParams, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[models.GetThreadItem]: ...
+
+    def iterate(self, operation: str, params: Any, *, max_pages: int | None = None, timeout: Timeout = DEFAULT_TIMEOUT) -> AsyncIterator[Any]:
+        return self._iterate(operation, params, max_pages=max_pages, timeout=timeout)