replylayer 0.14.0__py3-none-any.whl

replylayer/resources/mailboxes.py

@@ -0,0 +1,768 @@
+from __future__ import annotations
+
+from typing import Any, overload
+from urllib.parse import quote
+
+from .._http import AsyncHttpClient, SyncHttpClient
+from ..types import (
+    AttachmentAccessResponse,
+    AttachmentAllowedFileFamilyRequest,
+    AttachmentExposureMode,
+    HitlMode,
+    PiiMode,
+    PiiRedactionConfig,
+    RecipientPolicyMode,
+    ScannerPolicy,
+    SenderPolicyMode,
+    SubaddressMode,
+)
+
+
+def _build_attachment_access_body(
+    *,
+    enable: bool | None = None,
+    mode: AttachmentExposureMode | None = None,
+    allowed_file_families: list[AttachmentAllowedFileFamilyRequest] | None = None,
+    accept_disclaimer_version: str | None = None,
+    accept_image_risk_version: str | None = None,
+    reauth_token: str | None = None,
+) -> dict[str, Any]:
+    body: dict[str, Any] = {}
+    if enable is not None:
+        body["enable"] = enable
+    if mode is not None:
+        body["mode"] = mode
+    if allowed_file_families is not None:
+        body["allowed_file_families"] = allowed_file_families
+    if accept_disclaimer_version is not None:
+        body["accept_disclaimer_version"] = accept_disclaimer_version
+    if accept_image_risk_version is not None:
+        body["accept_image_risk_version"] = accept_image_risk_version
+    if reauth_token is not None:
+        body["reauth_token"] = reauth_token
+    return body
+
+
+class SyncMailboxAllowlist:
+    """Migration 036 — mailbox-scoped recipient allowlist (sync).
+
+    Reached via `client.mailboxes.allowlist`. Mutations are admin-only; an
+    `agent`-role key that calls `add`/`add_bulk`/`delete` gets 403
+    `INSUFFICIENT_SCOPE`. See ``docs/allowlist.md`` for the rationale.
+    """
+
+    def __init__(self, http: SyncHttpClient) -> None:
+        self._http = http
+
+    def list(
+        self,
+        mailbox_id: str,
+        *,
+        limit: int | None = None,
+        cursor: str | None = None,
+        all: bool | None = None,
+    ) -> dict[str, Any]:
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = str(limit)
+        if cursor is not None:
+            query["cursor"] = cursor
+        if all:
+            query["all"] = "true"
+        return self._http.request(
+            "GET", f"/v1/mailboxes/{mailbox_id}/allowlist", query=query
+        )
+
+    def add(self, mailbox_id: str, *, email: str) -> dict[str, Any]:
+        return self._http.request(
+            "POST", f"/v1/mailboxes/{mailbox_id}/allowlist", body={"email": email}
+        )
+
+    def add_bulk(self, mailbox_id: str, *, emails: list[str]) -> dict[str, Any]:
+        return self._http.request(
+            "POST",
+            f"/v1/mailboxes/{mailbox_id}/allowlist/bulk",
+            body={"emails": emails},
+        )
+
+    def delete(
+        self,
+        mailbox_id: str,
+        email: str,
+        *,
+        force_empty: bool = False,
+    ) -> dict[str, Any]:
+        query: dict[str, Any] = {}
+        if force_empty:
+            query["force_empty"] = "true"
+        return self._http.request(
+            "DELETE",
+            f"/v1/mailboxes/{mailbox_id}/allowlist/{quote(email, safe='')}",
+            query=query,
+        )
+
+    def list_blocked_attempts(
+        self,
+        mailbox_id: str,
+        *,
+        limit: int | None = None,
+        cursor: str | None = None,
+        all: bool | None = None,
+        aggregate: bool | None = None,
+        within_days: int | None = None,
+    ) -> dict[str, Any]:
+        """Migration 038 — blocked attempts log.
+
+        Default ``aggregate=True`` returns a top-N grouped view without
+        pagination (``next_cursor`` is always ``None``). Pass
+        ``aggregate=False`` for raw per-attempt history with tuple-cursor
+        pagination. Pass ``within_days=7`` for a "blocked this week" filter
+        (1..365).
+        """
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = str(limit)
+        if cursor is not None:
+            query["cursor"] = cursor
+        if all:
+            query["all"] = "true"
+        if aggregate is False:
+            query["aggregate"] = "false"
+        if within_days is not None:
+            query["within_days"] = str(within_days)
+        return self._http.request(
+            "GET",
+            f"/v1/mailboxes/{mailbox_id}/allowlist/blocked-attempts",
+            query=query,
+        )
+
+
+class AsyncMailboxAllowlist:
+    """Migration 036 — mailbox-scoped recipient allowlist (async)."""
+
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def list(
+        self,
+        mailbox_id: str,
+        *,
+        limit: int | None = None,
+        cursor: str | None = None,
+        all: bool | None = None,
+    ) -> dict[str, Any]:
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = str(limit)
+        if cursor is not None:
+            query["cursor"] = cursor
+        if all:
+            query["all"] = "true"
+        return await self._http.request(
+            "GET", f"/v1/mailboxes/{mailbox_id}/allowlist", query=query
+        )
+
+    async def add(self, mailbox_id: str, *, email: str) -> dict[str, Any]:
+        return await self._http.request(
+            "POST", f"/v1/mailboxes/{mailbox_id}/allowlist", body={"email": email}
+        )
+
+    async def add_bulk(
+        self, mailbox_id: str, *, emails: list[str]
+    ) -> dict[str, Any]:
+        return await self._http.request(
+            "POST",
+            f"/v1/mailboxes/{mailbox_id}/allowlist/bulk",
+            body={"emails": emails},
+        )
+
+    async def delete(
+        self,
+        mailbox_id: str,
+        email: str,
+        *,
+        force_empty: bool = False,
+    ) -> dict[str, Any]:
+        query: dict[str, Any] = {}
+        if force_empty:
+            query["force_empty"] = "true"
+        return await self._http.request(
+            "DELETE",
+            f"/v1/mailboxes/{mailbox_id}/allowlist/{quote(email, safe='')}",
+            query=query,
+        )
+
+    async def list_blocked_attempts(
+        self,
+        mailbox_id: str,
+        *,
+        limit: int | None = None,
+        cursor: str | None = None,
+        all: bool | None = None,
+        aggregate: bool | None = None,
+        within_days: int | None = None,
+    ) -> dict[str, Any]:
+        """Migration 038 — blocked attempts log (async).
+
+        Default ``aggregate=True`` returns the grouped top-N view; pass
+        ``aggregate=False`` for raw rows. ``within_days=7`` applies a
+        recency filter (1..365).
+        """
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = str(limit)
+        if cursor is not None:
+            query["cursor"] = cursor
+        if all:
+            query["all"] = "true"
+        if aggregate is False:
+            query["aggregate"] = "false"
+        if within_days is not None:
+            query["within_days"] = str(within_days)
+        return await self._http.request(
+            "GET",
+            f"/v1/mailboxes/{mailbox_id}/allowlist/blocked-attempts",
+            query=query,
+        )
+
+
+class SyncMailboxInboundAllowlist:
+    """Migration 047 — mailbox-scoped INBOUND sender allowlist (sync).
+
+    Reached via ``client.mailboxes.inbound_allowlist``. Mirrors
+    ``SyncMailboxAllowlist`` structurally but auth differs: BOTH admin
+    and agent keys can mutate (the firewall protects the customer FROM
+    senders, not against their own agents).
+    """
+
+    def __init__(self, http: SyncHttpClient) -> None:
+        self._http = http
+
+    def list(
+        self,
+        mailbox_id: str,
+        *,
+        limit: int | None = None,
+        cursor: str | None = None,
+        all: bool | None = None,
+    ) -> dict[str, Any]:
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = str(limit)
+        if cursor is not None:
+            query["cursor"] = cursor
+        if all:
+            query["all"] = "true"
+        return self._http.request(
+            "GET", f"/v1/mailboxes/{mailbox_id}/inbound-allowlist", query=query
+        )
+
+    def add(self, mailbox_id: str, *, email: str) -> dict[str, Any]:
+        return self._http.request(
+            "POST",
+            f"/v1/mailboxes/{mailbox_id}/inbound-allowlist",
+            body={"email": email},
+        )
+
+    def add_bulk(self, mailbox_id: str, *, emails: list[str]) -> dict[str, Any]:
+        return self._http.request(
+            "POST",
+            f"/v1/mailboxes/{mailbox_id}/inbound-allowlist/bulk",
+            body={"emails": emails},
+        )
+
+    def delete(
+        self,
+        mailbox_id: str,
+        email: str,
+        *,
+        force_empty: bool = False,
+    ) -> dict[str, Any]:
+        query: dict[str, Any] = {}
+        if force_empty:
+            query["force_empty"] = "true"
+        return self._http.request(
+            "DELETE",
+            f"/v1/mailboxes/{mailbox_id}/inbound-allowlist/{quote(email, safe='')}",
+            query=query,
+        )
+
+    def list_blocked_attempts(
+        self,
+        mailbox_id: str,
+        *,
+        limit: int | None = None,
+        cursor: str | None = None,
+        all: bool | None = None,
+        aggregate: bool | None = None,
+        within_days: int | None = None,
+    ) -> dict[str, Any]:
+        """Migration 047 — inbound firewall blocked-attempts log.
+
+        Mirrors the outbound ``list_blocked_attempts`` shape; the audit
+        rows under inspection here are
+        ``action='mailbox.inbound_firewall.blocked'``.
+        """
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = str(limit)
+        if cursor is not None:
+            query["cursor"] = cursor
+        if all:
+            query["all"] = "true"
+        if aggregate is False:
+            query["aggregate"] = "false"
+        if within_days is not None:
+            query["within_days"] = str(within_days)
+        return self._http.request(
+            "GET",
+            f"/v1/mailboxes/{mailbox_id}/inbound-allowlist/blocked-attempts",
+            query=query,
+        )
+
+
+class AsyncMailboxInboundAllowlist:
+    """Migration 047 — mailbox-scoped INBOUND sender allowlist (async)."""
+
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def list(
+        self,
+        mailbox_id: str,
+        *,
+        limit: int | None = None,
+        cursor: str | None = None,
+        all: bool | None = None,
+    ) -> dict[str, Any]:
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = str(limit)
+        if cursor is not None:
+            query["cursor"] = cursor
+        if all:
+            query["all"] = "true"
+        return await self._http.request(
+            "GET", f"/v1/mailboxes/{mailbox_id}/inbound-allowlist", query=query
+        )
+
+    async def add(self, mailbox_id: str, *, email: str) -> dict[str, Any]:
+        return await self._http.request(
+            "POST",
+            f"/v1/mailboxes/{mailbox_id}/inbound-allowlist",
+            body={"email": email},
+        )
+
+    async def add_bulk(
+        self, mailbox_id: str, *, emails: list[str]
+    ) -> dict[str, Any]:
+        return await self._http.request(
+            "POST",
+            f"/v1/mailboxes/{mailbox_id}/inbound-allowlist/bulk",
+            body={"emails": emails},
+        )
+
+    async def delete(
+        self,
+        mailbox_id: str,
+        email: str,
+        *,
+        force_empty: bool = False,
+    ) -> dict[str, Any]:
+        query: dict[str, Any] = {}
+        if force_empty:
+            query["force_empty"] = "true"
+        return await self._http.request(
+            "DELETE",
+            f"/v1/mailboxes/{mailbox_id}/inbound-allowlist/{quote(email, safe='')}",
+            query=query,
+        )
+
+    async def list_blocked_attempts(
+        self,
+        mailbox_id: str,
+        *,
+        limit: int | None = None,
+        cursor: str | None = None,
+        all: bool | None = None,
+        aggregate: bool | None = None,
+        within_days: int | None = None,
+    ) -> dict[str, Any]:
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = str(limit)
+        if cursor is not None:
+            query["cursor"] = cursor
+        if all:
+            query["all"] = "true"
+        if aggregate is False:
+            query["aggregate"] = "false"
+        if within_days is not None:
+            query["within_days"] = str(within_days)
+        return await self._http.request(
+            "GET",
+            f"/v1/mailboxes/{mailbox_id}/inbound-allowlist/blocked-attempts",
+            query=query,
+        )
+
+
+class SyncMailboxes:
+    def __init__(self, http: SyncHttpClient) -> None:
+        self._http = http
+        self.allowlist = SyncMailboxAllowlist(http)
+        self.inbound_allowlist = SyncMailboxInboundAllowlist(http)
+
+    def create(
+        self,
+        *,
+        name: str,
+        self_hosted_imap_folder: str | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"name": name}
+        if self_hosted_imap_folder is not None:
+            body["self_hosted_imap_folder"] = self_hosted_imap_folder
+        return self._http.request("POST", "/v1/mailboxes", body=body)
+
+    def list(self) -> dict[str, Any]:
+        return self._http.request("GET", "/v1/mailboxes")
+
+    def get_mailbox(self, id: str) -> dict[str, Any]:
+        """Single-mailbox detail.
+
+        Returns the same shape as a list entry plus
+        ``legacy_wildcard_active`` (true when the row is on the legacy
+        attachment-access compat path; the dashboard banner reads this).
+
+        Auth: session, admin keys, and mailbox-bound agent keys may read.
+        Unbound agent keys see 404 NOT_FOUND.
+        """
+        return self._http.request("GET", f"/v1/mailboxes/{id}")
+
+    def delete(self, id: str) -> dict[str, Any]:
+        return self._http.request("DELETE", f"/v1/mailboxes/{id}")
+
+    def update(
+        self,
+        id: str,
+        *,
+        # Round-1 c3: scanner_policy is now optional on the PATCH wire.
+        # Pass None (default) to leave the existing policy untouched.
+        scanner_policy: ScannerPolicy | None = None,
+        pii_mode: PiiMode | None = None,
+        default_subaddress_mode: SubaddressMode | None = None,
+        recipient_policy_mode: RecipientPolicyMode | None = None,
+        force_empty: bool = False,
+        hitl_mode: HitlMode | None = None,
+        # Migration 085 — thread-scoped reply bypass toggle. None means "do not
+        # include the field in the PATCH".
+        allow_thread_replies: bool | None = None,
+        # PR 8.1 — per-detector redaction visibility. Pass {} to reset to
+        # platform default; pass a partial map (e.g.
+        # {"EMAIL_ADDRESS": {"redact": False}}) to disable redaction on
+        # selected detectors. Tier-gated Pro+ for any redact:false entry.
+        # NOTE: None means "do not include the field in the PATCH"; pass {}
+        # to explicitly reset to platform default.
+        pii_redaction_config: PiiRedactionConfig | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {}
+        if scanner_policy is not None:
+            body["scanner_policy"] = scanner_policy
+        if pii_mode is not None:
+            body["pii_mode"] = pii_mode
+        if default_subaddress_mode is not None:
+            body["default_subaddress_mode"] = default_subaddress_mode
+        if recipient_policy_mode is not None:
+            body["recipient_policy_mode"] = recipient_policy_mode
+        if force_empty:
+            body["force_empty"] = True
+        if hitl_mode is not None:
+            body["hitl_mode"] = hitl_mode
+        if allow_thread_replies is not None:
+            body["allow_thread_replies"] = allow_thread_replies
+        if pii_redaction_config is not None:
+            body["pii_redaction_config"] = pii_redaction_config
+        return self._http.request("PATCH", f"/v1/mailboxes/{id}", body=body)
+
+    def set_recipient_policy(
+        self,
+        id: str,
+        mode: RecipientPolicyMode,
+        *,
+        force_empty: bool = False,
+        scanner_policy: ScannerPolicy | None = None,
+    ) -> dict[str, Any]:
+        """Convenience wrapper for the recipient-policy flip.
+
+        Round-1 c3: scanner_policy is now optional on the PATCH wire.
+        Pass it here only if you want to update it alongside the flip;
+        otherwise leave None and the server preserves the existing
+        value via COALESCE.
+        """
+        return self.update(
+            id,
+            scanner_policy=scanner_policy,
+            recipient_policy_mode=mode,
+            force_empty=force_empty,
+        )
+
+    def set_thread_replies(self, id: str, allow: bool) -> dict[str, Any]:
+        """Migration 085 — toggle the thread-scoped reply bypass.
+
+        Inert in ``blocklist`` mode; in ``allowlist`` mode, ``True`` lets an
+        agent reply to / follow up with any visible inbound participant of a
+        thread without that address gaining standing send-authority. ``False``
+        restores strict allowlist-only sends.
+        """
+        return self.update(id, allow_thread_replies=allow)
+
+    def set_sender_policy(
+        self,
+        id: str,
+        mode: SenderPolicyMode,
+        *,
+        force_empty: bool = False,
+    ) -> dict[str, Any]:
+        """Migration 047 — flip the inbound firewall mode (per-mailbox).
+
+        Pass ``force_empty=True`` to flip to ``allowlist`` while the
+        inbound allowlist is empty; the server otherwise returns 409
+        ``SENDER_POLICY_FLIP_EMPTY_ALLOWLIST``. Auth: admin + agent.
+        """
+        body: dict[str, Any] = {"mode": mode}
+        if force_empty:
+            body["force_empty"] = True
+        return self._http.request(
+            "PATCH", f"/v1/mailboxes/{id}/sender-policy", body=body
+        )
+
+    @overload
+    def set_attachment_access(
+        self,
+        id: str,
+        *,
+        enable: bool,
+        accept_disclaimer_version: str | None = None,
+    ) -> AttachmentAccessResponse: ...
+
+    @overload
+    def set_attachment_access(
+        self,
+        id: str,
+        *,
+        mode: AttachmentExposureMode,
+        allowed_file_families: list[AttachmentAllowedFileFamilyRequest] | None = None,
+        accept_disclaimer_version: str | None = None,
+        accept_image_risk_version: str | None = None,
+        reauth_token: str | None = None,
+    ) -> AttachmentAccessResponse: ...
+
+    def set_attachment_access(
+        self,
+        id: str,
+        *,
+        enable: bool | None = None,
+        mode: AttachmentExposureMode | None = None,
+        allowed_file_families: list[AttachmentAllowedFileFamilyRequest] | None = None,
+        accept_disclaimer_version: str | None = None,
+        accept_image_risk_version: str | None = None,
+        reauth_token: str | None = None,
+    ) -> AttachmentAccessResponse:
+        """Set the per-mailbox agent attachment-access policy.
+
+        Approved downloads (``mode='raw_download_selected_types'``) **enablement** —
+        including any widening of ``allowed_file_families`` against an
+        explicit raw-download row —
+        is rejected for Bearer-key callers with
+        ``403 REAUTH_REQUIRES_SESSION``. The route requires session-cookie
+        auth + a fresh TOTP code (or password if MFA is not enabled)
+        supplied as ``reauth_token``. The SDK's HTTP client does not
+        carry session cookies, so approved-download enablement must go through the
+        dashboard. The SDK still works for:
+
+          - reading state (see ``get_mailbox``)
+          - flipping between ``metadata_only`` and ``derived_content``
+          - same-or-narrower writes within an already-explicit raw-download row
+          - disabling via the legacy ``enable=False`` shape
+
+        If ``allowed_file_families`` includes ``"image"``, the server also
+        requires ``accept_image_risk_version`` to match
+        ``current_image_risk_version`` unless the mailbox already has current
+        image-risk acceptance.
+
+        See docs/inbox-attachment-integration-briefing.md.
+        """
+        body = _build_attachment_access_body(
+            enable=enable,
+            mode=mode,
+            allowed_file_families=allowed_file_families,
+            accept_disclaimer_version=accept_disclaimer_version,
+            accept_image_risk_version=accept_image_risk_version,
+            reauth_token=reauth_token,
+        )
+        return self._http.request(
+            "POST",
+            f"/v1/mailboxes/{id}/attachment-access",
+            body=body,
+        )
+
+
+class AsyncMailboxes:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+        self.allowlist = AsyncMailboxAllowlist(http)
+        self.inbound_allowlist = AsyncMailboxInboundAllowlist(http)
+
+    async def create(
+        self,
+        *,
+        name: str,
+        self_hosted_imap_folder: str | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"name": name}
+        if self_hosted_imap_folder is not None:
+            body["self_hosted_imap_folder"] = self_hosted_imap_folder
+        return await self._http.request("POST", "/v1/mailboxes", body=body)
+
+    async def list(self) -> dict[str, Any]:
+        return await self._http.request("GET", "/v1/mailboxes")
+
+    async def get_mailbox(self, id: str) -> dict[str, Any]:
+        """Single-mailbox detail (async). See SyncMailboxes.get_mailbox."""
+        return await self._http.request("GET", f"/v1/mailboxes/{id}")
+
+    async def delete(self, id: str) -> dict[str, Any]:
+        return await self._http.request("DELETE", f"/v1/mailboxes/{id}")
+
+    async def update(
+        self,
+        id: str,
+        *,
+        # Round-1 c3: scanner_policy is now optional on the PATCH wire.
+        # Pass None (default) to leave the existing policy untouched.
+        scanner_policy: ScannerPolicy | None = None,
+        pii_mode: PiiMode | None = None,
+        default_subaddress_mode: SubaddressMode | None = None,
+        recipient_policy_mode: RecipientPolicyMode | None = None,
+        force_empty: bool = False,
+        hitl_mode: HitlMode | None = None,
+        # Migration 085 — thread-scoped reply bypass toggle. None = do not
+        # include in the PATCH.
+        allow_thread_replies: bool | None = None,
+        # PR 8.1 — per-detector redaction visibility. Pass {} to reset to
+        # platform default; pass a partial map to disable redaction on
+        # selected detectors. None = do not include in the PATCH.
+        pii_redaction_config: PiiRedactionConfig | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {}
+        if scanner_policy is not None:
+            body["scanner_policy"] = scanner_policy
+        if pii_mode is not None:
+            body["pii_mode"] = pii_mode
+        if default_subaddress_mode is not None:
+            body["default_subaddress_mode"] = default_subaddress_mode
+        if recipient_policy_mode is not None:
+            body["recipient_policy_mode"] = recipient_policy_mode
+        if force_empty:
+            body["force_empty"] = True
+        if hitl_mode is not None:
+            body["hitl_mode"] = hitl_mode
+        if allow_thread_replies is not None:
+            body["allow_thread_replies"] = allow_thread_replies
+        if pii_redaction_config is not None:
+            body["pii_redaction_config"] = pii_redaction_config
+        return await self._http.request("PATCH", f"/v1/mailboxes/{id}", body=body)
+
+    async def set_recipient_policy(
+        self,
+        id: str,
+        mode: RecipientPolicyMode,
+        *,
+        force_empty: bool = False,
+        scanner_policy: ScannerPolicy | None = None,
+    ) -> dict[str, Any]:
+        """Convenience wrapper for the recipient-policy flip (async).
+
+        Round-1 c3: scanner_policy is now optional on the PATCH wire.
+        Pass it here only if you want to update it alongside the flip;
+        otherwise leave None and the server preserves the existing
+        value via COALESCE. (Earlier draft of this wrapper sent {}
+        as a passthrough, which under the relaxed schema would have
+        been a real scanner-policy update overwriting the existing
+        value — round-2 audit caught the async-only regression.)
+        """
+        return await self.update(
+            id,
+            scanner_policy=scanner_policy,
+            recipient_policy_mode=mode,
+            force_empty=force_empty,
+        )
+
+    async def set_thread_replies(self, id: str, allow: bool) -> dict[str, Any]:
+        """Migration 085 — toggle the thread-scoped reply bypass (async).
+
+        Inert in ``blocklist`` mode; in ``allowlist`` mode, ``True`` lets an
+        agent reply to / follow up with any visible inbound participant of a
+        thread without that address gaining standing send-authority.
+        """
+        return await self.update(id, allow_thread_replies=allow)
+
+    async def set_sender_policy(
+        self,
+        id: str,
+        mode: SenderPolicyMode,
+        *,
+        force_empty: bool = False,
+    ) -> dict[str, Any]:
+        """Migration 047 — flip the inbound firewall mode (async)."""
+        body: dict[str, Any] = {"mode": mode}
+        if force_empty:
+            body["force_empty"] = True
+        return await self._http.request(
+            "PATCH", f"/v1/mailboxes/{id}/sender-policy", body=body
+        )
+
+    @overload
+    async def set_attachment_access(
+        self,
+        id: str,
+        *,
+        enable: bool,
+        accept_disclaimer_version: str | None = None,
+    ) -> AttachmentAccessResponse: ...
+
+    @overload
+    async def set_attachment_access(
+        self,
+        id: str,
+        *,
+        mode: AttachmentExposureMode,
+        allowed_file_families: list[AttachmentAllowedFileFamilyRequest] | None = None,
+        accept_disclaimer_version: str | None = None,
+        accept_image_risk_version: str | None = None,
+        reauth_token: str | None = None,
+    ) -> AttachmentAccessResponse: ...
+
+    async def set_attachment_access(
+        self,
+        id: str,
+        *,
+        enable: bool | None = None,
+        mode: AttachmentExposureMode | None = None,
+        allowed_file_families: list[AttachmentAllowedFileFamilyRequest] | None = None,
+        accept_disclaimer_version: str | None = None,
+        accept_image_risk_version: str | None = None,
+        reauth_token: str | None = None,
+    ) -> AttachmentAccessResponse:
+        body = _build_attachment_access_body(
+            enable=enable,
+            mode=mode,
+            allowed_file_families=allowed_file_families,
+            accept_disclaimer_version=accept_disclaimer_version,
+            accept_image_risk_version=accept_image_risk_version,
+            reauth_token=reauth_token,
+        )
+        return await self._http.request(
+            "POST",
+            f"/v1/mailboxes/{id}/attachment-access",
+            body=body,
+        )