@graph8/sdk 0.251.0 → 0.262.0

package/docs/api/aiInbox.md

@@ -0,0 +1,3490 @@
+<!-- Generated by sdk/js/scripts/generate-agent-docs.ts from developer-contract/openapi.json. Regenerated on every build. -->
+
+# `g8.api.aiInbox`: AI Inbox
+
+79 operations (32 read, 26 write, 10 destructive, 1 billable, 10 external).
+
+No hand-written client covers this area. Call it through `g8.api.aiInbox.*` as shown below, or by operationId with `g8.api.call(operationId, input)`.
+
+Every example below assumes this setup (server-side, API key):
+
+```ts
+import { g8 } from "@graph8/sdk";
+
+g8.init({ apiKey: process.env.G8_API_KEY! });
+```
+
+Example values are placeholders that match each field's type. Only required fields are shown. Every example is type-checked against the SDK in CI.
+
+Exact TypeScript types for every operation on this page, and every schema they use: [aiInbox.d.ts](aiInbox.d.ts).
+
+## Operations
+
+| Call | HTTP | Tier | Scope | Summary |
+|---|---|---|---|---|
+| [`activateInboxMailboxes`](#op-activateinboxmailboxes) | `POST /api/v1/inbox/mailboxes/activate` | external | `inbox:run` | Activate Inbox Mailboxes |
+| [`addChannelComment`](#op-addchannelcomment) | `POST /api/v1/inbox/channels/{channel_id}/comments` | write | `inbox:write` | Add Channel Comment |
+| [`addChannelTag`](#op-addchanneltag) | `POST /api/v1/inbox/channels/{channel_id}/tags` | write | `inbox:write` | Add Channel Tag |
+| [`addMailboxToWorkspace`](#op-addmailboxtoworkspace) | `POST /api/v1/inbox/workspaces/{workspace_id}/mailboxes` | write | `inbox:write` | Add Mailbox To Workspace |
+| [`assignChannel`](#op-assignchannel) | `POST /api/v1/inbox/channels/{channel_id}/assign` | write | `inbox:write` | Assign Channel |
+| [`blockInboxSender`](#op-blockinboxsender) | `POST /api/v1/inbox/blocked-senders` | write | `inbox:write` | Block Inbox Sender |
+| [`clearMeetingTranscriptLink`](#op-clearmeetingtranscriptlink) | `DELETE /api/v1/inbox/meetings/{meeting_id}/transcript-link` | destructive | `meetings:delete` | Clear Meeting Transcript Link |
+| [`composeInboxEmail`](#op-composeinboxemail) | `POST /api/v1/inbox/emails/compose` | external | `inbox:run` | Compose Inbox Email |
+| [`composeInboxLinkedinMessage`](#op-composeinboxlinkedinmessage) | `POST /api/v1/inbox/linkedin/compose` | external | `inbox:run` | Compose Inbox Linkedin Message |
+| [`composeInboxSms`](#op-composeinboxsms) | `POST /api/v1/inbox/sms/compose` | external | `inbox:run` | Compose Inbox Sms |
+| [`createInboxAgent`](#op-createinboxagent) | `POST /api/v1/inbox/agents` | write | `inbox:write` | Create Inbox Agent |
+| [`createInboxTag`](#op-createinboxtag) | `POST /api/v1/inbox/tags` | write | `inbox:write` | Create Inbox Tag |
+| [`createMeetingTask`](#op-createmeetingtask) | `POST /api/v1/inbox/meetings/{meeting_id}/tasks` | write | `meetings:write` | Create Meeting Task |
+| [`deactivateInboxMailboxes`](#op-deactivateinboxmailboxes) | `POST /api/v1/inbox/mailboxes/deactivate` | write | `inbox:write` | Deactivate Inbox Mailboxes |
+| [`deleteInboxEmailDraft`](#op-deleteinboxemaildraft) | `DELETE /api/v1/inbox/drafts/emails/{draft_id}` | destructive | `inbox:delete` | Delete Inbox Email Draft |
+| [`deleteInboxLinkedinDraft`](#op-deleteinboxlinkedindraft) | `DELETE /api/v1/inbox/linkedin/accounts/{account_id}/conversations/{conversation_id}/draft` | destructive | `inbox:delete` | Delete Inbox Linkedin Draft |
+| [`deleteInboxTag`](#op-deleteinboxtag) | `DELETE /api/v1/inbox/tags/{tag_id}` | destructive | `inbox:delete` | Delete Inbox Tag |
+| [`deleteMeetingTask`](#op-deletemeetingtask) | `DELETE /api/v1/inbox/meetings/tasks/{task_id}` | destructive | `meetings:delete` | Delete Meeting Task |
+| [`disableInboxLinkedinAccount`](#op-disableinboxlinkedinaccount) | `POST /api/v1/inbox/linkedin/accounts/{account_id}/disable` | write | `inbox:write` | Disable Inbox Linkedin Account |
+| [`downloadInboxAttachment`](#op-downloadinboxattachment) | `GET /api/v1/inbox/attachments/{token}` | read | `inbox:read` | Download Inbox Attachment |
+| [`enableInboxLinkedinAccount`](#op-enableinboxlinkedinaccount) | `POST /api/v1/inbox/linkedin/accounts/{account_id}/enable` | external | `inbox:run` | Enable Inbox Linkedin Account |
+| [`generateInboxDraft`](#op-generateinboxdraft) | `POST /api/v1/inbox/drafts/generate` | billable | `inbox:run` | Generate Inbox Draft |
+| [`getAssigneeEligibility`](#op-getassigneeeligibility) | `GET /api/v1/inbox/channels/{channel_id}/assignee-eligibility` | read | `inbox:read` | Get Assignee Eligibility |
+| [`getInboxCallResult`](#op-getinboxcallresult) | `GET /api/v1/inbox/call-results/{call_id}` | read | `inbox:read` | Get Inbox Call Result |
+| [`getInboxChannel`](#op-getinboxchannel) | `GET /api/v1/inbox/channels/{channel_id}` | read | `inbox:read` | Get Inbox Channel |
+| [`getInboxEmailSettings`](#op-getinboxemailsettings) | `GET /api/v1/inbox/email-settings` | read | `inbox:read` | Get Inbox Email Settings |
+| [`getInboxLinkedinAccount`](#op-getinboxlinkedinaccount) | `GET /api/v1/inbox/linkedin/accounts/{account_id}` | read | `inbox:read` | Get Inbox Linkedin Account |
+| [`getInboxLinkedinConversation`](#op-getinboxlinkedinconversation) | `GET /api/v1/inbox/linkedin/accounts/{account_id}/conversations/{conversation_id}` | read | `inbox:read` | Get Inbox Linkedin Conversation |
+| [`getInboxLinkedinConversationDetail`](#op-getinboxlinkedinconversationdetail) | `GET /api/v1/inbox/linkedin/accounts/{account_id}/conversations/{conversation_id}/detail` | read | `inbox:read` | Get Inbox Linkedin Conversation Detail |
+| [`getInboxMailboxSync`](#op-getinboxmailboxsync) | `GET /api/v1/inbox/mailboxes/{mailbox}/sync` | read | `inbox:read` | Get Inbox Mailbox Sync |
+| [`getInboxTagAgent`](#op-getinboxtagagent) | `GET /api/v1/inbox/tags/{tag_id}/agent` | read | `inbox:read` | Get Inbox Tag Agent |
+| [`getInboxWorkspace`](#op-getinboxworkspace) | `GET /api/v1/inbox/workspaces/{workspace_id}` | read | `inbox:read` | Get Inbox Workspace |
+| [`getSequenceChannels`](#op-getsequencechannels) | `GET /api/v1/inbox/workspaces/sequence-channels/{sequence_id}` | read | `inbox:read` | Get Sequence Channels |
+| [`getWorkspaceUnreadCounts`](#op-getworkspaceunreadcounts) | `GET /api/v1/inbox/workspaces/unread-counts` | read | `inbox:read` | Get Workspace Unread Counts |
+| [`linkInboxEmailToSequence`](#op-linkinboxemailtosequence) | `POST /api/v1/inbox/emails/{email_id}/link-sequence` | write | `inbox:write` | Link Inbox Email To Sequence |
+| [`linkMeetingTranscript`](#op-linkmeetingtranscript) | `POST /api/v1/inbox/meetings/{meeting_id}/transcript-link` | write | `meetings:write` | Link Meeting Transcript |
+| [`listAllInboxMailboxes`](#op-listallinboxmailboxes) | `GET /api/v1/inbox/mailboxes/all` | read | `inbox:read` | List All Inbox Mailboxes |
+| [`listAssignableMeetingUsers`](#op-listassignablemeetingusers) | `GET /api/v1/inbox/meetings/{meeting_id}/assignable-users` | read | `meetings:read` | List Assignable Meeting Users |
+| [`listChannelComments`](#op-listchannelcomments) | `GET /api/v1/inbox/channels/{channel_id}/comments` | read | `inbox:read` | List Channel Comments |
+| [`listInboxBlockedSenders`](#op-listinboxblockedsenders) | `GET /api/v1/inbox/blocked-senders` | read | `inbox:read` | List Inbox Blocked Senders |
+| [`listInboxEmailSequenceCandidates`](#op-listinboxemailsequencecandidates) | `GET /api/v1/inbox/emails/{email_id}/sequence-candidates` | read | `inbox:read` | List Inbox Email Sequence Candidates |
+| [`listInboxEmailSettingsTimezones`](#op-listinboxemailsettingstimezones) | `GET /api/v1/inbox/email-settings/timezones` | read | `inbox:read` | List Inbox Email Settings Timezones |
+| [`listInboxEmailsBySequence`](#op-listinboxemailsbysequence) | `GET /api/v1/inbox/emails/by-sequence/{sequence_id}` | read | `inbox:read` | List Inbox Emails By Sequence |
+| [`listInboxLinkedinAccounts`](#op-listinboxlinkedinaccounts) | `GET /api/v1/inbox/linkedin/accounts` | read | `inbox:read` | List Inbox Linkedin Accounts |
+| [`listInboxMailboxes`](#op-listinboxmailboxes) | `GET /api/v1/inbox/mailboxes` | read | `inbox:read` | List Inbox Mailboxes |
+| [`listInboxMailboxesPaginated`](#op-listinboxmailboxespaginated) | `GET /api/v1/inbox/mailboxes/paginated` | read | `inbox:read` | List Inbox Mailboxes Paginated |
+| [`listInboxUsers`](#op-listinboxusers) | `GET /api/v1/inbox/users` | read | `inbox:read` | List Inbox Users |
+| [`listInboxWorkspaces`](#op-listinboxworkspaces) | `GET /api/v1/inbox/workspaces` | read | `inbox:read` | List Inbox Workspaces |
+| [`listMailboxAssociatedSequences`](#op-listmailboxassociatedsequences) | `POST /api/v1/inbox/mailboxes/associated-sequences` | read | `inbox:read` | List Mailbox Associated Sequences |
+| [`listMeetingTasks`](#op-listmeetingtasks) | `GET /api/v1/inbox/meetings/{meeting_id}/tasks` | read | `meetings:read` | List Meeting Tasks |
+| [`listMyMeetingTasks`](#op-listmymeetingtasks) | `GET /api/v1/inbox/meetings/my-tasks` | read | `meetings:read` | List My Meeting Tasks |
+| [`markInboxEmailRead`](#op-markinboxemailread) | `POST /api/v1/inbox/emails/{email_id}/mark-read` | write | `inbox:write` | Mark Inbox Email Read |
+| [`markInboxLinkedinConversationRead`](#op-markinboxlinkedinconversationread) | `POST /api/v1/inbox/linkedin/accounts/{account_id}/conversations/{conversation_id}/read` | write | `inbox:write` | Mark Inbox Linkedin Conversation Read |
+| [`markInboxLinkedinConversationUnread`](#op-markinboxlinkedinconversationunread) | `POST /api/v1/inbox/linkedin/accounts/{account_id}/conversations/{conversation_id}/unread` | write | `inbox:write` | Mark Inbox Linkedin Conversation Unread |
+| [`markInboxSmsRead`](#op-markinboxsmsread) | `POST /api/v1/inbox/sms/{thread_id}/mark-read` | write | `inbox:write` | Mark Inbox Sms Read |
+| [`markMeetingNoTranscriptExpected`](#op-markmeetingnotranscriptexpected) | `POST /api/v1/inbox/meetings/{meeting_id}/no-transcript` | write | `meetings:write` | Mark Meeting No Transcript Expected |
+| [`removeChannelTag`](#op-removechanneltag) | `DELETE /api/v1/inbox/channels/{channel_id}/tags` | destructive | `inbox:delete` | Remove Channel Tag |
+| [`revalidateInboxMailbox`](#op-revalidateinboxmailbox) | `POST /api/v1/inbox/mailboxes/{mailbox}/revalidate` | write | `inbox:write` | Revalidate Inbox Mailbox |
+| [`searchInboxCallResults`](#op-searchinboxcallresults) | `POST /api/v1/inbox/call-results/search` | read | `inbox:read` | Search Inbox Call Results |
+| [`searchInboxLinkedinConversations`](#op-searchinboxlinkedinconversations) | `POST /api/v1/inbox/linkedin/conversations/search` | read | `inbox:read` | Search Inbox Linkedin Conversations |
+| [`setChannelAiPause`](#op-setchannelaipause) | `POST /api/v1/inbox/channels/{channel_id}/ai-pause` | write | `inbox:write` | Set Channel Ai Pause |
+| [`setInboxEmailSequence`](#op-setinboxemailsequence) | `POST /api/v1/inbox/emails/{email_id}/sequence` | write | `inbox:write` | Set Inbox Email Sequence |
+| [`setInboxEmailSettings`](#op-setinboxemailsettings) | `PUT /api/v1/inbox/email-settings` | write | `inbox:write` | Set Inbox Email Settings |
+| [`setInboxMailboxVisibility`](#op-setinboxmailboxvisibility) | `PATCH /api/v1/inbox/mailboxes/{mailbox}/visibility` | write | `inbox:write` | Set Inbox Mailbox Visibility |
+| [`setMeetingSensitivity`](#op-setmeetingsensitivity) | `PATCH /api/v1/inbox/meetings/{meeting_id}/sensitivity` | destructive | `meetings:delete` | Set Meeting Sensitivity |
+| [`startInboxMailboxSync`](#op-startinboxmailboxsync) | `POST /api/v1/inbox/mailboxes/{mailbox}/sync` | external | `inbox:run` | Start Inbox Mailbox Sync |
+| [`stopInboxMailboxSync`](#op-stopinboxmailboxsync) | `DELETE /api/v1/inbox/mailboxes/{mailbox}/sync` | destructive | `inbox:delete` | Stop Inbox Mailbox Sync |
+| [`syncInboxLinkedinAccounts`](#op-syncinboxlinkedinaccounts) | `POST /api/v1/inbox/linkedin/accounts/sync` | external | `inbox:run` | Sync Inbox Linkedin Accounts |
+| [`toggleInboxMailboxes`](#op-toggleinboxmailboxes) | `PATCH /api/v1/inbox/mailboxes/bulk` | external | `inbox:run` | Toggle Inbox Mailboxes |
+| [`unassignChannel`](#op-unassignchannel) | `DELETE /api/v1/inbox/channels/{channel_id}/assign` | destructive | `inbox:delete` | Unassign Channel |
+| [`unblockInboxSender`](#op-unblockinboxsender) | `DELETE /api/v1/inbox/blocked-senders/{blocked_sender_id}` | destructive | `inbox:delete` | Unblock Inbox Sender |
+| [`updateInboxLinkedinAccount`](#op-updateinboxlinkedinaccount) | `PUT /api/v1/inbox/linkedin/accounts/{account_id}` | external | `inbox:run` | Update Inbox Linkedin Account |
+| [`updateInboxMailboxSettings`](#op-updateinboxmailboxsettings) | `PATCH /api/v1/inbox/mailboxes/{mailbox}/settings` | external | `inbox:run` | Update Inbox Mailbox Settings |
+| [`updateInboxTag`](#op-updateinboxtag) | `PUT /api/v1/inbox/tags/{tag_id}` | write | `inbox:write` | Update Inbox Tag |
+| [`updateMeetingTask`](#op-updatemeetingtask) | `PATCH /api/v1/inbox/meetings/tasks/{task_id}` | write | `meetings:write` | Update Meeting Task |
+| [`uploadInboxDraftAttachment`](#op-uploadinboxdraftattachment) | `POST /api/v1/inbox/drafts/attachments` | write | `inbox:write` | Upload Inbox Draft Attachment |
+| [`uploadInboxNoteAttachment`](#op-uploadinboxnoteattachment) | `POST /api/v1/inbox/notes/attachments` | write | `inbox:write` | Upload Inbox Note Attachment |
+| [`validateInboxLinkedinAccount`](#op-validateinboxlinkedinaccount) | `POST /api/v1/inbox/linkedin/validate-account` | read | `inbox:read` | Validate Inbox Linkedin Account |
+| [`validateInboxSendMailbox`](#op-validateinboxsendmailbox) | `POST /api/v1/inbox/emails/validate-mailbox` | read | `inbox:read` | Validate Inbox Send Mailbox |
+
+---
+
+<a id="op-activateinboxmailboxes"></a>
+
+### `g8.api.aiInbox.activateInboxMailboxes(input)`
+
+**Activate Inbox Mailboxes**
+
+- HTTP: `POST /api/v1/inbox/mailboxes/activate`
+- operationId: `activate_inbox_mailboxes_inbox_mailboxes_activate_post` (also callable as `g8.api.call("activate_inbox_mailboxes_inbox_mailboxes_activate_post", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `inbox:run`
+
+Start polling SEVERAL mailboxes, each with its own provider.
+
+NOT ATOMIC, and the failure shape is the thing to know: the app returns
+400 if ANY mailbox fails, but the ones that succeeded REMAIN ACTIVATED.
+The 400 body carries `successful` and `failed`, so read them rather than
+assuming the call did nothing.
+
+Reaches outside graph8 for the same reason the single-mailbox start does.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `MailboxActivateRequest` | yes | Request body; fields below. |
+
+Body fields (`MailboxActivateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.mailboxes` | `Array<MailboxJobItem>` | yes | min items 1 |
+| `body.auto_respond` | `boolean \| null` | no | Let the AI answer on these mailboxes. Omit to leave each mailbox as it is. |
+| `body.campaign_id` | `string \| null` | no | Sequence id to attribute synced threads to. Applies to every mailbox listed. |
+| `body.campaign_name` | `string \| null` | no |  |
+| `body.last_unread_limit` | `integer \| null` | no | How many unread threads the first sync reaches back for. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.aiInbox.activateInboxMailboxes({
+  body: { mailboxes: [{ mailbox: "example", provider: "google_mailbox" }] },
+});
+```
+
+---
+
+<a id="op-addchannelcomment"></a>
+
+### `g8.api.aiInbox.addChannelComment(input)`
+
+**Add Channel Comment**
+
+- HTTP: `POST /api/v1/inbox/channels/{channel_id}/comments`
+- operationId: `add_channel_comment_inbox_channels__channel_id__comments_post` (also callable as `g8.api.call("add_channel_comment_inbox_channels__channel_id__comments_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Leave an INTERNAL note. Not a reply - the customer never sees it.
+
+MENTIONING SOMEONE CREATES THEM A TASK in the Work app. The two mention
+lists are additive rather than alternatives: an id with no matching email
+still gets the task, it just gets no notification, so send both to get the
+bell as well.
+
+Attachments must already be uploaded; only their token and key are
+load-bearing, because the server re-validates and never trusts a
+client-sent name, size or type.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.channel_id` | `string` | yes | Conversation id. |
+| `query.channel_type` | `"email" \| "chat" \| "phone" \| "sms" \| "heyreach" \| "meetings" \| "support" \| "all"` | yes | Which channel the conversation lives in. REQUIRED: the same id means different rows in different channels, so this is what identifies the conversation, not a filter. |
+| `body` | `CommentCreateRequest` | yes | Request body; fields below. |
+
+Body fields (`CommentCreateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.content` | `string` | yes | min length 1, max length 5000 |
+| `body.attachments` | `Array<CommentAttachmentRef>` | no |  |
+| `body.mentioned_user_emails` | `Array<string>` | no | The same users by email. Additive - this is what drives the notification. |
+| `body.mentioned_user_ids` | `Array<string>` | no | Mentioned users by id. Each gets a Work task. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.addChannelComment({
+  path: { channel_id: "id" },
+  query: { channel_type: "email" },
+  body: { content: "example" },
+});
+```
+
+---
+
+<a id="op-addchanneltag"></a>
+
+### `g8.api.aiInbox.addChannelTag(input)`
+
+**Add Channel Tag**
+
+- HTTP: `POST /api/v1/inbox/channels/{channel_id}/tags`
+- operationId: `add_channel_tag_inbox_channels__channel_id__tags_post` (also callable as `g8.api.call("add_channel_tag_inbox_channels__channel_id__tags_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Attach an existing tag to a conversation.
+
+The tag must already exist - this links, it does not create.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.channel_id` | `string` | yes | Conversation id. |
+| `query.channel_type` | `"email" \| "chat" \| "phone" \| "sms" \| "heyreach" \| "meetings" \| "support" \| "all"` | yes | Which channel the conversation lives in. REQUIRED: the same id means different rows in different channels, so this is what identifies the conversation, not a filter. |
+| `body` | `developer_api__interfaces__dtos__inbox_collab__TagRequest` | yes | Request body; fields below. |
+| `query.linkedin_account_id` | `integer \| null` | no | LinkedIn account id. Required only for `heyreach`, where the id is account-scoped and ambiguous without it. |
+
+Body fields (`developer_api__interfaces__dtos__inbox_collab__TagRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.tag_id` | `string` | yes | The tag to attach. It must already exist. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.addChannelTag({
+  path: { channel_id: "id" },
+  query: { channel_type: "email" },
+  body: { tag_id: "id" },
+});
+```
+
+---
+
+<a id="op-addmailboxtoworkspace"></a>
+
+### `g8.api.aiInbox.addMailboxToWorkspace(input)`
+
+**Add Mailbox To Workspace**
+
+- HTTP: `POST /api/v1/inbox/workspaces/{workspace_id}/mailboxes`
+- operationId: `add_mailbox_to_workspace_inbox_workspaces__workspace_id__mailboxes_post` (also callable as `g8.api.call("add_mailbox_to_workspace_inbox_workspaces__workspace_id__mailboxes_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Put a mailbox into a workspace.
+
+IDEMPOTENT: adding a mailbox that is already a member is a no-op, and the
+response says which happened rather than failing.
+
+This one handler wants a `PropelAuthUser` rather than the shared principal,
+so it gets one from `build_api_principal` - resolved from the validated
+key, never client-supplied.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.workspace_id` | `string` | yes | Workspace id (UUID). |
+| `body` | `Body_add_mailbox_to_workspace_inbox_workspaces__workspace_id__mailboxes_post` | yes | Request body; fields below. |
+
+Body fields (`Body_add_mailbox_to_workspace_inbox_workspaces__workspace_id__mailboxes_post`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.mailbox_id` | `integer` | yes | Integer `mailboxes.id` - the database primary key, NOT the cron-job string id. The app is explicit about the difference and so is this. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.addMailboxToWorkspace({ path: { workspace_id: "id" }, body: { mailbox_id: 123 } });
+```
+
+---
+
+<a id="op-assignchannel"></a>
+
+### `g8.api.aiInbox.assignChannel(input)`
+
+**Assign Channel**
+
+- HTTP: `POST /api/v1/inbox/channels/{channel_id}/assign`
+- operationId: `assign_channel_inbox_channels__channel_id__assign_post` (also callable as `g8.api.call("assign_channel_inbox_channels__channel_id__assign_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Give a conversation to one or more people.
+
+Ownership is SHARED, not singular: assigning ADDS people rather than
+replacing whoever is already there. Take someone off with
+`DELETE /inbox/channels/{id}/assign`.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.channel_id` | `string` | yes | Conversation id. |
+| `query.channel_type` | `"email" \| "chat" \| "phone" \| "sms" \| "heyreach" \| "meetings" \| "support" \| "all"` | yes | Which channel the conversation lives in. REQUIRED: the same id means different rows in different channels, so this is what identifies the conversation, not a filter. |
+| `body` | `AssignmentCreateRequest` | yes | Request body; fields below. |
+| `query.linkedin_account_id` | `integer \| null` | no | LinkedIn account id. Required only for `heyreach`, where the id is account-scoped and ambiguous without it. |
+
+Body fields (`AssignmentCreateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.assignee_emails` | `Array<string>` | yes | Who owns this conversation. Check eligibility first. min items 1, max items 20 |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.assignChannel({
+  path: { channel_id: "id" },
+  query: { channel_type: "email" },
+  body: { assignee_emails: ["jane@acme.com"] },
+});
+```
+
+---
+
+<a id="op-blockinboxsender"></a>
+
+### `g8.api.aiInbox.blockInboxSender(input)`
+
+**Block Inbox Sender**
+
+- HTTP: `POST /api/v1/inbox/blocked-senders`
+- operationId: `block_inbox_sender_inbox_blocked_senders_post` (also callable as `g8.api.call("block_inbox_sender_inbox_blocked_senders_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Stop a sender reaching ONE mailbox.
+
+Scoped to the mailbox named in the body, not to the organisation: the same
+sender still reaches every other mailbox until blocked there too. This is
+an INGESTION filter - it is not a suppression, and it does not stop
+graph8 emailing them (see `/contacts/suppressions` for that).
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `BlockedSenderCreateRequest` | yes | Request body; fields below. |
+
+Body fields (`BlockedSenderCreateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.mailbox` | `string` | yes | The mailbox to block them on. |
+| `body.sender_email` | `string` | yes | The address to block. |
+| `body.reason` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.blockInboxSender({ body: { mailbox: "example", sender_email: "jane@acme.com" } });
+```
+
+---
+
+<a id="op-clearmeetingtranscriptlink"></a>
+
+### `g8.api.aiInbox.clearMeetingTranscriptLink(input)`
+
+**Clear Meeting Transcript Link**
+
+- HTTP: `DELETE /api/v1/inbox/meetings/{meeting_id}/transcript-link`
+- operationId: `clear_meeting_transcript_link_inbox_meetings__meeting_id__transcript_link_delete` (also callable as `g8.api.call("clear_meeting_transcript_link_inbox_meetings__meeting_id__transcript_link_delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `meetings:delete`
+
+Detach the transcript from a meeting.
+
+Breaks the LINK, not the transcript: the recording and its text survive
+and can be attached to the right meeting instead.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.meeting_id` | `string` | yes | Meeting id, as returned by `GET /inbox/meetings`. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.aiInbox.clearMeetingTranscriptLink({ path: { meeting_id: "id" } });
+```
+
+---
+
+<a id="op-composeinboxemail"></a>
+
+### `g8.api.aiInbox.composeInboxEmail(input)`
+
+**Compose Inbox Email**
+
+- HTTP: `POST /api/v1/inbox/emails/compose`
+- operationId: `compose_inbox_email_inbox_emails_compose_post` (also callable as `g8.api.call("compose_inbox_email_inbox_emails_compose_post", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `inbox:run`
+
+COMPOSE AN EMAIL. WITH `save_as_draft` FALSE THIS REACHES A REAL PERSON.
+
+The one call that does everything the compose window does:
+
+  * new thread, sent now          - `to`, `from_mailbox`, `subject`, `content`
+  * new thread, saved as a draft  - the same plus `save_as_draft: true`
+  * reply into a thread           - add `reply_to_email_id`
+  * edit an existing draft        - add `draft_id`
+  * send a draft you saved        - `draft_id` plus `save_as_draft: false`
+
+`save_as_draft` DEFAULTS TO FALSE, which means SEND. That is the app's own
+default and it is kept rather than made safer here, because two ends
+disagreeing about what an omitted field does is worse than a default you
+can read.
+
+Classified `external` (`inbox:run`) because it can deliver. Sending as a
+mailbox the caller is not authorised for is a 403 from the sender
+authorisation gate, not a silent success - check first with
+`POST /inbox/emails/validate-mailbox`.
+
+Distinct from `POST /inbox/emails/{email_id}/send`, which can only reply
+into a thread that already exists.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `EmailComposeRequest` | yes | Request body; fields below. |
+
+Body fields (`EmailComposeRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.content` | `string` | yes | Body, HTML. |
+| `body.from_mailbox` | `string` | yes | The mailbox to send AS. Must already be syncing - check with `POST /inbox/emails/validate-mailbox` first. |
+| `body.to` | `Array<string>` | yes | Recipients. These are real addresses. min items 1 |
+| `body.assigned_users` | `Array<string>` | no | Emails to assign the resulting thread to. |
+| `body.attachments` | `Array<Record<string, unknown>>` | no | Already-uploaded attachment references. The server re-validates each one. |
+| `body.bcc` | `Array<string>` | no |  |
+| `body.cc` | `Array<string>` | no |  |
+| `body.draft_id` | `string \| null` | no | Edit or send an existing draft. |
+| `body.include_signature` | `boolean` | no | default `true` |
+| `body.reply_to_email_id` | `string \| null` | no | Thread to reply into. Omit to start a new conversation. |
+| `body.save_as_draft` | `boolean` | no | FALSE SENDS THE MESSAGE. True stores a draft and contacts nobody. default `false` |
+| `body.subject` | `string \| null` | no | Auto-filled as `Re: {original}` on a reply if omitted. |
+| `body.tag_ids` | `Array<string>` | no | Tags to attach to the thread. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.aiInbox.composeInboxEmail({
+  body: { content: "example", from_mailbox: "example", to: ["+15555550100"] },
+});
+```
+
+---
+
+<a id="op-composeinboxlinkedinmessage"></a>
+
+### `g8.api.aiInbox.composeInboxLinkedinMessage(input)`
+
+**Compose Inbox Linkedin Message**
+
+- HTTP: `POST /api/v1/inbox/linkedin/compose`
+- operationId: `compose_inbox_linkedin_message_inbox_linkedin_compose_post` (also callable as `g8.api.call("compose_inbox_linkedin_message_inbox_linkedin_compose_post", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `inbox:run`
+
+COMPOSE A LINKEDIN MESSAGE. WITH `save_as_draft` FALSE IT REACHES A PERSON.
+
+ONE DRAFT PER CONVERSATION: saving over an existing draft replaces it, and
+sending deletes whatever draft was there. `save_as_draft` defaults to
+FALSE, which means send.
+
+Classified `external` (`inbox:run`). The account must be synced and
+enabled for the inbox - check with `POST /inbox/linkedin/validate-account`.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `LinkedInComposeRequest` | yes | Request body; fields below. |
+
+Body fields (`LinkedInComposeRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.conversation_id` | `string` | yes | An existing conversation on that account. |
+| `body.linkedin_account_id` | `integer` | yes | The sending account. Integer id. |
+| `body.message` | `string` | yes |  |
+| `body.assigned_users` | `Array<string>` | no |  |
+| `body.save_as_draft` | `boolean` | no | FALSE SENDS THE MESSAGE. True stores a draft. default `false` |
+| `body.tag_ids` | `Array<string>` | no |  |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.aiInbox.composeInboxLinkedinMessage({
+  body: {
+    conversation_id: "id",
+    linkedin_account_id: 123,
+    message: "example",
+  },
+});
+```
+
+---
+
+<a id="op-composeinboxsms"></a>
+
+### `g8.api.aiInbox.composeInboxSms(input)`
+
+**Compose Inbox Sms**
+
+- HTTP: `POST /api/v1/inbox/sms/compose`
+- operationId: `compose_inbox_sms_inbox_sms_compose_post` (also callable as `g8.api.call("compose_inbox_sms_inbox_sms_compose_post", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `inbox:run`
+
+COMPOSE AN SMS. WITH `save_as_draft` FALSE THIS REACHES A REAL PHONE.
+
+Sends through the organisation's own number and files the message into the
+SMS thread, so the conversation stays in one place. `save_as_draft`
+defaults to FALSE, which means send.
+
+Classified `external` (`inbox:run`). `from_number` must be a number this
+organisation owns - checked before anything is saved or sent, a 400
+otherwise (see the module docstring for why the check lives here).
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `SmsComposeRequest` | yes | Request body; fields below. |
+
+Body fields (`SmsComposeRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.body` | `string` | yes | Message text. |
+| `body.from_number` | `string` | yes | A number this organisation owns, E.164. |
+| `body.to_number` | `string` | yes | The recipient's number, E.164. A real phone. |
+| `body.draft_id` | `string \| null` | no |  |
+| `body.save_as_draft` | `boolean` | no | FALSE SENDS THE MESSAGE. True stores a draft. default `false` |
+| `body.thread_id` | `string \| null` | no | Existing SMS thread to continue. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.aiInbox.composeInboxSms({
+  body: { body: "example", from_number: "example", to_number: "example" },
+});
+```
+
+---
+
+<a id="op-createinboxagent"></a>
+
+### `g8.api.aiInbox.createInboxAgent(input)`
+
+**Create Inbox Agent**
+
+- HTTP: `POST /api/v1/inbox/agents`
+- operationId: `create_inbox_agent_inbox_agents_post` (also callable as `g8.api.call("create_inbox_agent_inbox_agents_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Create an AI Inbox agent - the named responder tags and email settings
+point at.
+
+NOT the Copilot Agent Runtime at `/agent/*`, which runs and approves
+autonomous work. Different object, similar name; the context notes record
+that this pair has already misled an audit.
+
+Names are unique per organisation: a repeat is a 400, not a second agent.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `InboxAgentCreateRequest` | yes | Request body; fields below. |
+
+Body fields (`InboxAgentCreateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.name` | `string` | yes | Unique within the organisation. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.createInboxAgent({ body: { name: "Example" } });
+```
+
+---
+
+<a id="op-createinboxtag"></a>
+
+### `g8.api.aiInbox.createInboxTag(input)`
+
+**Create Inbox Tag**
+
+- HTTP: `POST /api/v1/inbox/tags`
+- operationId: `create_inbox_tag_inbox_tags_post` (also callable as `g8.api.call("create_inbox_tag_inbox_tags_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Create an inbox tag - a conversation label, not a CRM contact tag.
+
+The read of these objects ships as `GET /workflows/inbox-tags`. With
+`ai_can_apply` true and `rules` set, the auto-tagger may apply this tag to
+threads on its own; with `agent_id` set, the agent answers threads carrying
+it.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `TagCreateRequest` | yes | Request body; fields below. |
+
+Body fields (`TagCreateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.name` | `string` | yes | Tag name, unique per organisation. min length 1 |
+| `body.agent_id` | `string \| null` | no | AI Inbox agent that answers threads carrying this tag. |
+| `body.ai_can_apply` | `boolean` | no | Whether the auto-tagger may apply this tag on its own. default `false` |
+| `body.color` | `string \| null` | no |  |
+| `body.description` | `string \| null` | no |  |
+| `body.priority` | `integer \| null` | no | 1-100. min 1, max 100 |
+| `body.rules` | `Array<string> \| null` | no | Plain-language rules the auto-tagger applies this tag by. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.createInboxTag({ body: { name: "Example" } });
+```
+
+---
+
+<a id="op-createmeetingtask"></a>
+
+### `g8.api.aiInbox.createMeetingTask(input)`
+
+**Create Meeting Task**
+
+- HTTP: `POST /api/v1/inbox/meetings/{meeting_id}/tasks`
+- operationId: `create_meeting_task_inbox_meetings__meeting_id__tasks_post` (also callable as `g8.api.call("create_meeting_task_inbox_meetings__meeting_id__tasks_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `meetings:write`
+
+Create a follow-up on this meeting.
+
+The meeting and its transcript are filled in from the meeting itself, so
+the task stays traceable to what was said. The assignee must be a
+PARTICIPANT - checked server-side, because a client-side filter is not a
+permission.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.meeting_id` | `string` | yes | Meeting id, as returned by `GET /inbox/meetings`. |
+| `body` | `MeetingTaskCreateRequest` | yes | Request body; fields below. |
+
+Body fields (`MeetingTaskCreateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.title` | `string` | yes | What needs doing. |
+| `body.assignee_user_id` | `string \| null` | no | The assignee's user id, from `GET /inbox/meetings/{meeting_id}/assignable-users`. Must be a meeting participant. |
+| `body.description` | `string \| null` | no |  |
+| `body.due_date` | `string (date-time) \| null` | no |  |
+| `body.priority` | `integer` | no | Lower is more urgent. The app's default is 2. default `2` |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.createMeetingTask({ path: { meeting_id: "id" }, body: { title: "Example" } });
+```
+
+---
+
+<a id="op-deactivateinboxmailboxes"></a>
+
+### `g8.api.aiInbox.deactivateInboxMailboxes(input)`
+
+**Deactivate Inbox Mailboxes**
+
+- HTTP: `POST /api/v1/inbox/mailboxes/deactivate`
+- operationId: `deactivate_inbox_mailboxes_inbox_mailboxes_deactivate_post` (also callable as `g8.api.call("deactivate_inbox_mailboxes_inbox_mailboxes_deactivate_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Stop polling several mailboxes at once.
+
+Takes the same body as activate - the campaign and auto-respond fields are
+simply ignored on this path, which is the app's own shape and is left
+alone rather than split into a narrower model that would drift from it.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `MailboxActivateRequest` | yes | Request body; fields below. |
+
+Body fields (`MailboxActivateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.mailboxes` | `Array<MailboxJobItem>` | yes | min items 1 |
+| `body.auto_respond` | `boolean \| null` | no | Let the AI answer on these mailboxes. Omit to leave each mailbox as it is. |
+| `body.campaign_id` | `string \| null` | no | Sequence id to attribute synced threads to. Applies to every mailbox listed. |
+| `body.campaign_name` | `string \| null` | no |  |
+| `body.last_unread_limit` | `integer \| null` | no | How many unread threads the first sync reaches back for. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.deactivateInboxMailboxes({
+  body: { mailboxes: [{ mailbox: "example", provider: "google_mailbox" }] },
+});
+```
+
+---
+
+<a id="op-deleteinboxemaildraft"></a>
+
+### `g8.api.aiInbox.deleteInboxEmailDraft(input)`
+
+**Delete Inbox Email Draft**
+
+- HTTP: `DELETE /api/v1/inbox/drafts/emails/{draft_id}`
+- operationId: `delete_inbox_email_draft_inbox_drafts_emails__draft_id__delete` (also callable as `g8.api.call("delete_inbox_email_draft_inbox_drafts_emails__draft_id__delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `inbox:delete`
+
+Delete a saved email draft by its id, wherever it sits.
+
+Not `DELETE /inbox/emails/{email_id}/draft`, which discards the AI's
+latest suggestion on a thread: this removes ONE draft by id, and if it was
+the only message in its thread the thread goes too. Refused with 403 unless
+the caller may send from the draft's mailbox - deleting a draft carries the
+same authority as sending it. Files attached to the draft are deleted.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.draft_id` | `string` | yes | The draft's message id, from `POST /inbox/emails/compose`. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.aiInbox.deleteInboxEmailDraft({ path: { draft_id: "id" } });
+```
+
+---
+
+<a id="op-deleteinboxlinkedindraft"></a>
+
+### `g8.api.aiInbox.deleteInboxLinkedinDraft(input)`
+
+**Delete Inbox Linkedin Draft**
+
+- HTTP: `DELETE /api/v1/inbox/linkedin/accounts/{account_id}/conversations/{conversation_id}/draft`
+- operationId: `delete_inbox_linkedin_draft_inbox_linkedin_accounts__account_id__conversations__conversation_id__draft_delete` (also callable as `g8.api.call("delete_inbox_linkedin_draft_inbox_linkedin_accounts__account_id__conversations__conversation_id__draft_delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `inbox:delete`
+
+Delete the saved draft on a LinkedIn conversation (there is at most one).
+404 when there is none. Nothing is sent.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.account_id` | `integer` | yes | LinkedIn account id (integer). |
+| `path.conversation_id` | `string` | yes | LinkedIn conversation id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.aiInbox.deleteInboxLinkedinDraft({ path: { account_id: 123, conversation_id: "id" } });
+```
+
+---
+
+<a id="op-deleteinboxtag"></a>
+
+### `g8.api.aiInbox.deleteInboxTag(input)`
+
+**Delete Inbox Tag**
+
+- HTTP: `DELETE /api/v1/inbox/tags/{tag_id}`
+- operationId: `delete_inbox_tag_inbox_tags__tag_id__delete` (also callable as `g8.api.call("delete_inbox_tag_inbox_tags__tag_id__delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `inbox:delete`
+
+Delete an inbox tag. Threads lose the label; nothing else is removed.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.tag_id` | `string` | yes | Tag id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.aiInbox.deleteInboxTag({ path: { tag_id: "id" } });
+```
+
+---
+
+<a id="op-deletemeetingtask"></a>
+
+### `g8.api.aiInbox.deleteMeetingTask(input)`
+
+**Delete Meeting Task**
+
+- HTTP: `DELETE /api/v1/inbox/meetings/tasks/{task_id}`
+- operationId: `delete_meeting_task_inbox_meetings_tasks__task_id__delete` (also callable as `g8.api.call("delete_meeting_task_inbox_meetings_tasks__task_id__delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `meetings:delete`
+
+Delete a meeting follow-up. The meeting and its transcript survive.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.task_id` | `string` | yes | Meeting task id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.aiInbox.deleteMeetingTask({ path: { task_id: "id" } });
+```
+
+---
+
+<a id="op-disableinboxlinkedinaccount"></a>
+
+### `g8.api.aiInbox.disableInboxLinkedinAccount(input)`
+
+**Disable Inbox Linkedin Account**
+
+- HTTP: `POST /api/v1/inbox/linkedin/accounts/{account_id}/disable`
+- operationId: `disable_inbox_linkedin_account_inbox_linkedin_accounts__account_id__disable_post` (also callable as `g8.api.call("disable_inbox_linkedin_account_inbox_linkedin_accounts__account_id__disable_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Take a LinkedIn account out of the inbox. Stops the AI answering on it;
+its configuration is kept for when it is enabled again.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.account_id` | `integer` | yes | LinkedIn account id (integer). |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.disableInboxLinkedinAccount({ path: { account_id: 123 } });
+```
+
+---
+
+<a id="op-downloadinboxattachment"></a>
+
+### `g8.api.aiInbox.downloadInboxAttachment(input)`
+
+**Download Inbox Attachment**
+
+- HTTP: `GET /api/v1/inbox/attachments/{token}`
+- operationId: `download_inbox_attachment_inbox_attachments__token__get` (also callable as `g8.api.call("download_inbox_attachment_inbox_attachments__token__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Download a draft or internal-note attachment. Not enveloped: bytes are bytes.
+
+The token only opens a file of THIS organisation: it is bound to the org
+that uploaded it, and a token from anywhere else is a flat 404. Served
+with `Content-Disposition: attachment` and `nosniff`, never inline.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.token` | `string` | yes | The `token` returned by `POST /inbox/drafts/attachments` or `POST /inbox/notes/attachments`. |
+
+**Returns**: no JSON body is declared for the success response.
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.downloadInboxAttachment({ path: { token: "example" } });
+```
+
+---
+
+<a id="op-enableinboxlinkedinaccount"></a>
+
+### `g8.api.aiInbox.enableInboxLinkedinAccount(input)`
+
+**Enable Inbox Linkedin Account**
+
+- HTTP: `POST /api/v1/inbox/linkedin/accounts/{account_id}/enable`
+- operationId: `enable_inbox_linkedin_account_inbox_linkedin_accounts__account_id__enable_post` (also callable as `g8.api.call("enable_inbox_linkedin_account_inbox_linkedin_accounts__account_id__enable_post", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `inbox:run`
+
+Bring a LinkedIn account's conversations into the inbox.
+
+If the account's configuration already has `auto_respond` on, enabling it
+is what lets the AI start messaging people from it - so this is classified
+`external`, the same tier as the configuration update.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.account_id` | `integer` | yes | LinkedIn account id (integer). |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.aiInbox.enableInboxLinkedinAccount({ path: { account_id: 123 } });
+```
+
+---
+
+<a id="op-generateinboxdraft"></a>
+
+### `g8.api.aiInbox.generateInboxDraft(input)`
+
+**Generate Inbox Draft**
+
+- HTTP: `POST /api/v1/inbox/drafts/generate`
+- operationId: `generate_inbox_draft_inbox_drafts_generate_post` (also callable as `g8.api.call("generate_inbox_draft_inbox_drafts_generate_post", input)`)
+- Tier: `billable`: spends credits; the SDK never blindly retries it; confirm cost before bulk use
+- API-key scope: `inbox:run`
+
+Write or rewrite a message with the model. THIS SPENDS CREDITS.
+
+DELIVERS NOTHING. It returns text; sending it is a separate, `external`
+call. Classified `billable` (`inbox:run`) because it charges - 402 when
+the organisation has no credits left.
+
+ONE CHARGE PER CALL, including a multi-operation call: pass a LIST in
+`operation` to apply several transforms in a single generation rather than
+paying per transform.
+
+`generate_from_scratch` is the only operation that does not need
+`message_html`; give it either a `conversation_id` + `channel_type` to
+ground the reply in the thread, or free-text `instructions` to write
+something with no thread at all.
+
+Wider than the already-published `GET /inbox/{reply_id}/draft`, which only
+ever generates from scratch on an existing thread.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `AiDraftGenerateRequest` | yes | Request body; fields below. |
+
+Body fields (`AiDraftGenerateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.operation` | `"change_tone" \| "fix_grammar_spelling" \| "change_objective" \| "expand" \| "shorten" \| "change_persona" \| "generate_from_scratch" \| Array<"change_tone" \| "fix_grammar_spelling" \| "change_objective" \| "expand" \| "shorten" \| "change_persona" \| "generate_from_scratch">` | yes | One operation, or several applied together in a single charged call. |
+| `body.channel_type` | `"email" \| "heyreach" \| "sms" \| null` | no | Required alongside `conversation_id`. `heyreach` is the LinkedIn channel and additionally needs `linkedin_account_id`. |
+| `body.conversation_id` | `string \| null` | no | Ground the draft in this thread's history. |
+| `body.instructions` | `string \| null` | no | Free-text prompt. With `generate_from_scratch` this writes a message with no thread at all. |
+| `body.linkedin_account_id` | `integer \| null` | no |  |
+| `body.message_html` | `string` | no | The text to transform. Required by every operation except `generate_from_scratch`. default `""` |
+| `body.objective` | `"book_meeting" \| "follow_up" \| "re_engage" \| "provide_value" \| "handle_objection" \| "close_deal" \| null` | no |  |
+| `body.persona` | `"sdr" \| "growth_manager" \| "account_executive" \| "customer_success" \| "founder" \| null` | no |  |
+| `body.tone` | `"professional" \| "friendly" \| "casual" \| "assertive" \| "empathetic" \| "urgent" \| null` | no |  |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// billable: spends credits; the SDK never blindly retries it; confirm cost before bulk use.
+const result = await g8.api.aiInbox.generateInboxDraft({ body: { operation: "change_tone" } });
+```
+
+---
+
+<a id="op-getassigneeeligibility"></a>
+
+### `g8.api.aiInbox.getAssigneeEligibility(input)`
+
+**Get Assignee Eligibility**
+
+- HTTP: `GET /api/v1/inbox/channels/{channel_id}/assignee-eligibility`
+- operationId: `get_assignee_eligibility_inbox_channels__channel_id__assignee_eligibility_get` (also callable as `g8.api.call("get_assignee_eligibility_inbox_channels__channel_id__assignee_eligibility_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Who can be given this conversation, and who cannot.
+
+Read this before assigning: eligibility depends on the channel and on
+mailbox access, so a user who appears in `/inbox/users` is not necessarily
+assignable to THIS thread.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.channel_id` | `string` | yes | Conversation id. |
+| `query.channel_type` | `"email" \| "chat" \| "phone" \| "sms" \| "heyreach" \| "meetings" \| "support" \| "all"` | yes | Which channel the conversation lives in. REQUIRED: the same id means different rows in different channels, so this is what identifies the conversation, not a filter. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getAssigneeEligibility({ path: { channel_id: "id" }, query: { channel_type: "email" } });
+```
+
+---
+
+<a id="op-getinboxcallresult"></a>
+
+### `g8.api.aiInbox.getInboxCallResult(input)`
+
+**Get Inbox Call Result**
+
+- HTTP: `GET /api/v1/inbox/call-results/{call_id}`
+- operationId: `get_inbox_call_result_inbox_call_results__call_id__get` (also callable as `g8.api.call("get_inbox_call_result_inbox_call_results__call_id__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+One call outcome, with its transcript, disposition and tags.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.call_id` | `integer` | yes | Integer call-result id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getInboxCallResult({ path: { call_id: 123 } });
+```
+
+---
+
+<a id="op-getinboxchannel"></a>
+
+### `g8.api.aiInbox.getInboxChannel(input)`
+
+**Get Inbox Channel**
+
+- HTTP: `GET /api/v1/inbox/channels/{channel_id}`
+- operationId: `get_inbox_channel_inbox_channels__channel_id__get` (also callable as `g8.api.call("get_inbox_channel_inbox_channels__channel_id__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+One conversation in the unified inbox shape - messages, tags and
+assignees - for any channel.
+
+The same row `GET /inbox` lists, fetched by id. Visibility is the app's:
+a thread in a personal mailbox is owner-only, so another person's key gets
+a 403/404 rather than the thread.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.channel_id` | `string` | yes | Conversation id. |
+| `query.channel_type` | `"email" \| "chat" \| "phone" \| "sms" \| "heyreach" \| "meetings" \| "support" \| "all"` | yes | Which channel the conversation lives in. REQUIRED: the same id means different rows in different channels. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getInboxChannel({ path: { channel_id: "id" }, query: { channel_type: "email" } });
+```
+
+---
+
+<a id="op-getinboxemailsettings"></a>
+
+### `g8.api.aiInbox.getInboxEmailSettings(input?)`
+
+**Get Inbox Email Settings**
+
+- HTTP: `GET /api/v1/inbox/email-settings`
+- operationId: `get_inbox_email_settings_inbox_email_settings_get` (also callable as `g8.api.call("get_inbox_email_settings_inbox_email_settings_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+The organisation's AI Inbox email settings.
+
+ORGANISATION-WIDE - there is no per-user copy, so a change here moves the
+behaviour for everyone. Answers `{"message": "Email settings not found"}`
+rather than 404 when nothing has been configured yet.
+
+**Input**: none.
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getInboxEmailSettings();
+```
+
+---
+
+<a id="op-getinboxlinkedinaccount"></a>
+
+### `g8.api.aiInbox.getInboxLinkedinAccount(input)`
+
+**Get Inbox Linkedin Account**
+
+- HTTP: `GET /api/v1/inbox/linkedin/accounts/{account_id}`
+- operationId: `get_inbox_linkedin_account_inbox_linkedin_accounts__account_id__get` (also callable as `g8.api.call("get_inbox_linkedin_account_inbox_linkedin_accounts__account_id__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+One LinkedIn account's inbox configuration - enabled, auto-respond and
+its rules, the sequence it is attributed to - plus the cached profile.
+The read side of `PUT /inbox/linkedin/accounts/{account_id}`; 404 until the
+account has been synced.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.account_id` | `integer` | yes | LinkedIn account id (integer). |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getInboxLinkedinAccount({ path: { account_id: 123 } });
+```
+
+---
+
+<a id="op-getinboxlinkedinconversation"></a>
+
+### `g8.api.aiInbox.getInboxLinkedinConversation(input)`
+
+**Get Inbox Linkedin Conversation**
+
+- HTTP: `GET /api/v1/inbox/linkedin/accounts/{account_id}/conversations/{conversation_id}`
+- operationId: `get_inbox_linkedin_conversation_inbox_linkedin_accounts__account_id__conversations__conversation_id__get` (also callable as `g8.api.call("get_inbox_linkedin_conversation_inbox_linkedin_accounts__account_id__conversations__conversation_id__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+One LinkedIn conversation, with its whole message history.
+
+BOTH ids are required and neither is redundant: the same conversation id
+can appear under two LinkedIn accounts, so the account is what identifies
+the thread rather than filtering it.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.account_id` | `integer` | yes | LinkedIn account id (integer). |
+| `path.conversation_id` | `string` | yes | LinkedIn conversation id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getInboxLinkedinConversation({ path: { account_id: 123, conversation_id: "id" } });
+```
+
+---
+
+<a id="op-getinboxlinkedinconversationdetail"></a>
+
+### `g8.api.aiInbox.getInboxLinkedinConversationDetail(input)`
+
+**Get Inbox Linkedin Conversation Detail**
+
+- HTTP: `GET /api/v1/inbox/linkedin/accounts/{account_id}/conversations/{conversation_id}/detail`
+- operationId: `get_inbox_linkedin_conversation_detail_inbox_linkedin_accounts__account_id__conversations__conversation_id__detail_get` (also callable as `g8.api.call("get_inbox_linkedin_conversation_detail_inbox_linkedin_accounts__account_id__conversations__conversation_id__detail_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+One LinkedIn conversation MERGED with what graph8 holds about it: the
+AI analysis, the linked contact, tags, the saved draft and assignees.
+
+`GET .../conversations/{conversation_id}` is the provider's view alone;
+this is the view the inbox renders.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.account_id` | `integer` | yes | LinkedIn account id (integer). |
+| `path.conversation_id` | `string` | yes | LinkedIn conversation id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getInboxLinkedinConversationDetail({ path: { account_id: 123, conversation_id: "id" } });
+```
+
+---
+
+<a id="op-getinboxmailboxsync"></a>
+
+### `g8.api.aiInbox.getInboxMailboxSync(input)`
+
+**Get Inbox Mailbox Sync**
+
+- HTTP: `GET /api/v1/inbox/mailboxes/{mailbox}/sync`
+- operationId: `get_inbox_mailbox_sync_inbox_mailboxes__mailbox__sync_get` (also callable as `g8.api.call("get_inbox_mailbox_sync_inbox_mailboxes__mailbox__sync_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Is this mailbox being polled, and how did the last round go.
+
+A mailbox that was never connected is not an error - it answers
+`{"status": "STOPPED"}`.
+
+NOTE the asymmetry this proxy has to respect: the internal handler takes
+NO `current_user`, while its siblings do. Supplying one would be a
+TypeError on every call.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.mailbox` | `string` | yes | The mailbox ADDRESS, e.g. `sales@acme.com`. Not a numeric id. |
+| `query.provider` | `"google_mailbox" \| "smtp"` | yes | How the mailbox is connected. REQUIRED and not inferred: the same address can be connected either way, and guessing would act on the wrong transport. Closed to a Literal so an unknown value is a 422 naming both, rather than a `ValueError` raised inside the handler. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getInboxMailboxSync({
+  path: { mailbox: "example" },
+  query: { provider: "google_mailbox" },
+});
+```
+
+---
+
+<a id="op-getinboxtagagent"></a>
+
+### `g8.api.aiInbox.getInboxTagAgent(input)`
+
+**Get Inbox Tag Agent**
+
+- HTTP: `GET /api/v1/inbox/tags/{tag_id}/agent`
+- operationId: `get_inbox_tag_agent_inbox_tags__tag_id__agent_get` (also callable as `g8.api.call("get_inbox_tag_agent_inbox_tags__tag_id__agent_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Which AI agent answers threads carrying this tag.
+
+The bridge between a label and a behaviour: tagging a thread with a tag
+that has an agent is how that agent gets the conversation.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.tag_id` | `string` | yes | Tag id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getInboxTagAgent({ path: { tag_id: "id" } });
+```
+
+---
+
+<a id="op-getinboxworkspace"></a>
+
+### `g8.api.aiInbox.getInboxWorkspace(input)`
+
+**Get Inbox Workspace**
+
+- HTTP: `GET /api/v1/inbox/workspaces/{workspace_id}`
+- operationId: `get_inbox_workspace_inbox_workspaces__workspace_id__get` (also callable as `g8.api.call("get_inbox_workspace_inbox_workspaces__workspace_id__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+One workspace, with its mailboxes.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.workspace_id` | `string` | yes | Workspace id (UUID). |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getInboxWorkspace({ path: { workspace_id: "id" } });
+```
+
+---
+
+<a id="op-getsequencechannels"></a>
+
+### `g8.api.aiInbox.getSequenceChannels(input)`
+
+**Get Sequence Channels**
+
+- HTTP: `GET /api/v1/inbox/workspaces/sequence-channels/{sequence_id}`
+- operationId: `get_sequence_channels_inbox_workspaces_sequence_channels__sequence_id__get` (also callable as `g8.api.call("get_sequence_channels_inbox_workspaces_sequence_channels__sequence_id__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+The conversations a sequence produced.
+
+The bridge between a sequence and its replies: what went out, and what
+came back.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.sequence_id` | `string` | yes | Sequence id. |
+
+**Returns** `ApiResponse_InboxListPayload_`: the envelope `{ data: InboxListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getSequenceChannels({ path: { sequence_id: "id" } });
+```
+
+---
+
+<a id="op-getworkspaceunreadcounts"></a>
+
+### `g8.api.aiInbox.getWorkspaceUnreadCounts(input?)`
+
+**Get Workspace Unread Counts**
+
+- HTTP: `GET /api/v1/inbox/workspaces/unread-counts`
+- operationId: `get_workspace_unread_counts_inbox_workspaces_unread_counts_get` (also callable as `g8.api.call("get_workspace_unread_counts_inbox_workspaces_unread_counts_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Unread per workspace, in one call.
+
+Declared BEFORE `/workspaces/{workspace_id}` so the literal wins - the id
+route would otherwise match `unread-counts` and fail parsing it as a UUID.
+
+**Input**: none.
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.getWorkspaceUnreadCounts();
+```
+
+---
+
+<a id="op-linkinboxemailtosequence"></a>
+
+### `g8.api.aiInbox.linkInboxEmailToSequence(input)`
+
+**Link Inbox Email To Sequence**
+
+- HTTP: `POST /api/v1/inbox/emails/{email_id}/link-sequence`
+- operationId: `link_inbox_email_to_sequence_inbox_emails__email_id__link_sequence_post` (also callable as `g8.api.call("link_inbox_email_to_sequence_inbox_emails__email_id__link_sequence_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Attach a thread to the sequence that produced it AND STOP THE SEQUENCE.
+
+The second half is the point, not a side effect: linking tells the
+sequencer this contact replied, which halts their remaining steps. It is
+how someone who answered stops being chased.
+
+Only a sequence from `sequence-candidates` is accepted. If the sequencer
+call fails the link is KEPT - the association is committed first - so a
+successful response with `already_replied: false` after a provider hiccup
+can mean the halt did not register. Re-linking is safe.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.email_id` | `string` | yes | Email thread id. |
+| `body` | `LinkSequenceRequest` | yes | Request body; fields below. |
+
+Body fields (`LinkSequenceRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.contact_id` | `integer` | yes | Integer contact id - the CDP primary key, not an email address. |
+| `body.sequence_id` | `string` | yes | From `GET /inbox/emails/{email_id}/sequence-candidates`. Only sequences that actually emailed this contact are accepted. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.linkInboxEmailToSequence({
+  path: { email_id: "jane@acme.com" },
+  body: { contact_id: 123, sequence_id: "id" },
+});
+```
+
+---
+
+<a id="op-linkmeetingtranscript"></a>
+
+### `g8.api.aiInbox.linkMeetingTranscript(input)`
+
+**Link Meeting Transcript**
+
+- HTTP: `POST /api/v1/inbox/meetings/{meeting_id}/transcript-link`
+- operationId: `link_meeting_transcript_inbox_meetings__meeting_id__transcript_link_post` (also callable as `g8.api.call("link_meeting_transcript_inbox_meetings__meeting_id__transcript_link_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `meetings:write`
+
+Attach an existing transcript to a meeting.
+
+Contacts nobody. It corrects the RECORD - which recording belongs to which
+calendar event - when the automatic match got it wrong or never ran.
+
+Who may then read that transcript is a separate question, answered by
+`PATCH /inbox/meetings/{id}/sensitivity`.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.meeting_id` | `string` | yes | Meeting id, as returned by `GET /inbox/meetings`. |
+| `body` | `MeetingTranscriptLinkRequest` | yes | Request body; fields below. |
+
+Body fields (`MeetingTranscriptLinkRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.transcript_id` | `string` | yes | Id of a transcript that already exists in this organisation. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.linkMeetingTranscript({ path: { meeting_id: "id" }, body: { transcript_id: "id" } });
+```
+
+---
+
+<a id="op-listallinboxmailboxes"></a>
+
+### `g8.api.aiInbox.listAllInboxMailboxes(input?)`
+
+**List All Inbox Mailboxes**
+
+- HTTP: `GET /api/v1/inbox/mailboxes/all`
+- operationId: `list_all_inbox_mailboxes_inbox_mailboxes_all_get` (also callable as `g8.api.call("list_all_inbox_mailboxes_inbox_mailboxes_all_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Team AND personal mailboxes in one list, unfiltered.
+
+A three-segment LITERAL, declared before nothing that would swallow it -
+there is no `/inbox/mailboxes/{mailbox}` route, only deeper ones - but
+kept distinct from `GET /inbox/mailboxes` because that route defaults to
+a narrower set and callers reading only the obvious one would miss
+mailboxes.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.user_email` | `string \| null` | no | Whose personal mailboxes to include. Defaults to this key's human. |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listAllInboxMailboxes();
+```
+
+---
+
+<a id="op-listassignablemeetingusers"></a>
+
+### `g8.api.aiInbox.listAssignableMeetingUsers(input)`
+
+**List Assignable Meeting Users**
+
+- HTTP: `GET /api/v1/inbox/meetings/{meeting_id}/assignable-users`
+- operationId: `list_assignable_meeting_users_inbox_meetings__meeting_id__assignable_users_get` (also callable as `g8.api.call("list_assignable_meeting_users_inbox_meetings__meeting_id__assignable_users_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `meetings:read`
+
+Who a task on this meeting may be given to.
+
+PARTICIPANTS ONLY, mapped to their team-member records. Read this before
+creating a task: the server re-validates the assignee against the same
+list, so an arbitrary colleague is refused rather than silently accepted.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.meeting_id` | `string` | yes | Meeting id, as returned by `GET /inbox/meetings`. |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listAssignableMeetingUsers({ path: { meeting_id: "id" } });
+```
+
+---
+
+<a id="op-listchannelcomments"></a>
+
+### `g8.api.aiInbox.listChannelComments(input)`
+
+**List Channel Comments**
+
+- HTTP: `GET /api/v1/inbox/channels/{channel_id}/comments`
+- operationId: `list_channel_comments_inbox_channels__channel_id__comments_get` (also callable as `g8.api.call("list_channel_comments_inbox_channels__channel_id__comments_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Internal notes on a conversation. The customer never sees these.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.channel_id` | `string` | yes | Conversation id. |
+| `query.channel_type` | `"email" \| "chat" \| "phone" \| "sms" \| "heyreach" \| "meetings" \| "support" \| "all"` | yes | Which channel the conversation lives in. REQUIRED: the same id means different rows in different channels, so this is what identifies the conversation, not a filter. |
+
+**Returns** `ApiResponse_InboxListPayload_`: the envelope `{ data: InboxListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listChannelComments({ path: { channel_id: "id" }, query: { channel_type: "email" } });
+```
+
+---
+
+<a id="op-listinboxblockedsenders"></a>
+
+### `g8.api.aiInbox.listInboxBlockedSenders(input?)`
+
+**List Inbox Blocked Senders**
+
+- HTTP: `GET /api/v1/inbox/blocked-senders`
+- operationId: `list_inbox_blocked_senders_inbox_blocked_senders_get` (also callable as `g8.api.call("list_inbox_blocked_senders_inbox_blocked_senders_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Senders the inbox refuses to ingest, per mailbox.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.page` | `integer` | no | default `1` |
+| `query.page_size` | `integer` | no | default `10` |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listInboxBlockedSenders();
+```
+
+---
+
+<a id="op-listinboxemailsequencecandidates"></a>
+
+### `g8.api.aiInbox.listInboxEmailSequenceCandidates(input)`
+
+**List Inbox Email Sequence Candidates**
+
+- HTTP: `GET /api/v1/inbox/emails/{email_id}/sequence-candidates`
+- operationId: `list_inbox_email_sequence_candidates_inbox_emails__email_id__sequence_candidates_get` (also callable as `g8.api.call("list_inbox_email_sequence_candidates_inbox_emails__email_id__sequence_candidates_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Sequences this contact was ACTUALLY emailed from.
+
+The only sequences `link-sequence` will accept, so read this first - it is
+the safety guard, not a convenience. Scoping is by organisation and
+contact; the thread id is in the path for symmetry with the link call.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.email_id` | `string` | yes | Email thread id. |
+| `query.contact_id` | `integer` | yes | Integer contact id - the CDP primary key, not an email address. |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listInboxEmailSequenceCandidates({ path: { email_id: "jane@acme.com" }, query: { contact_id: 123 } });
+```
+
+---
+
+<a id="op-listinboxemailsettingstimezones"></a>
+
+### `g8.api.aiInbox.listInboxEmailSettingsTimezones(input?)`
+
+**List Inbox Email Settings Timezones**
+
+- HTTP: `GET /api/v1/inbox/email-settings/timezones`
+- operationId: `list_inbox_email_settings_timezones_inbox_email_settings_timezones_get` (also callable as `g8.api.call("list_inbox_email_settings_timezones_inbox_email_settings_timezones_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Every timezone name `timezone` in the email settings accepts (IANA
+names, as `items`). Static - it does not depend on the organisation.
+
+**Input**: none.
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listInboxEmailSettingsTimezones();
+```
+
+---
+
+<a id="op-listinboxemailsbysequence"></a>
+
+### `g8.api.aiInbox.listInboxEmailsBySequence(input)`
+
+**List Inbox Emails By Sequence**
+
+- HTTP: `GET /api/v1/inbox/emails/by-sequence/{sequence_id}`
+- operationId: `list_inbox_emails_by_sequence_inbox_emails_by_sequence__sequence_id__get` (also callable as `g8.api.call("list_inbox_emails_by_sequence_inbox_emails_by_sequence__sequence_id__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Email threads attributed to one sequence, newest first.
+
+A narrow projection - messages, mailbox and `updated_at` only - which is
+what makes it cheap enough to page through a whole campaign.
+`GET /inbox?channel=email&sequence_id=...` answers the same question with
+the full unified thread shape; use that when you need tags and assignees.
+
+Declared BEFORE nothing, but note the shape: `by-sequence` is a LITERAL in
+the position `/inbox/emails/{email_id}` fills at one segment shorter, so
+the two cannot collide.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.sequence_id` | `string` | yes | Sequence (campaign) id. |
+| `query.page` | `integer` | no | default `1` |
+| `query.page_size` | `integer` | no | default `10` |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listInboxEmailsBySequence({ path: { sequence_id: "id" } });
+```
+
+---
+
+<a id="op-listinboxlinkedinaccounts"></a>
+
+### `g8.api.aiInbox.listInboxLinkedinAccounts(input?)`
+
+**List Inbox Linkedin Accounts**
+
+- HTTP: `GET /api/v1/inbox/linkedin/accounts`
+- operationId: `list_inbox_linkedin_accounts_inbox_linkedin_accounts_get` (also callable as `g8.api.call("list_inbox_linkedin_accounts_inbox_linkedin_accounts_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+LinkedIn accounts as the PROVIDER reports them.
+
+Live from the provider, so it reflects a disconnected or suspended account
+immediately - but it carries none of the local inbox configuration. Read
+the configuration back from the update call, or set it with
+`PUT /inbox/linkedin/accounts/{account_id}`.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.keyword` | `string \| null` | no | Filter by name. |
+| `query.offset` | `integer` | no | default `0` |
+| `query.limit` | `integer` | no | default `50` |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listInboxLinkedinAccounts();
+```
+
+---
+
+<a id="op-listinboxmailboxes"></a>
+
+### `g8.api.aiInbox.listInboxMailboxes(input?)`
+
+**List Inbox Mailboxes**
+
+- HTTP: `GET /api/v1/inbox/mailboxes`
+- operationId: `list_inbox_mailboxes_inbox_mailboxes_get` (also callable as `g8.api.call("list_inbox_mailboxes_inbox_mailboxes_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Mailboxes with their AI Inbox sync state.
+
+Each row carries the mailbox record PLUS `cron_status`, `auto_respond`,
+`is_supported`, `has_credential_error` and `last_unread_limit` - the
+inbox-only columns `/mailboxes` does not have.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.user_email` | `string \| null` | no | Whose PERSONAL mailboxes to include. Defaults to the human who minted this key. An org-scoped key has no human, so it sees the team mailboxes only. |
+| `query.provider` | `"google_mailbox" \| "smtp" \| null` | no | Filter by connection type. |
+| `query.category` | `"team" \| "personal" \| null` | no | `team` (shared) or `personal` (owner-only). |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listInboxMailboxes();
+```
+
+---
+
+<a id="op-listinboxmailboxespaginated"></a>
+
+### `g8.api.aiInbox.listInboxMailboxesPaginated(input?)`
+
+**List Inbox Mailboxes Paginated**
+
+- HTTP: `GET /api/v1/inbox/mailboxes/paginated`
+- operationId: `list_inbox_mailboxes_paginated_inbox_mailboxes_paginated_get` (also callable as `g8.api.call("list_inbox_mailboxes_paginated_inbox_mailboxes_paginated_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Mailboxes with their sync state, paged and filterable - the settings
+screen's list.
+
+Every VISIBLE mailbox is returned, disconnected ones included, and each is
+annotated with `can_send` / `send_blocked_reason` for THIS caller, so a
+mailbox the key may see but not send from is distinguishable before a send
+is attempted. `total_count` carries the unpaged total. Credentials are
+scrubbed from every row.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.page` | `integer` | no | default `1` |
+| `query.page_size` | `integer` | no | default `20` |
+| `query.status` | `"RUNNING" \| "STOPPED" \| null` | no | `RUNNING` (being polled) or `STOPPED`. |
+| `query.provider` | `"google_mailbox" \| "smtp" \| null` | no | Filter by connection type. |
+| `query.search` | `string \| null` | no | Substring of the mailbox address. |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listInboxMailboxesPaginated();
+```
+
+---
+
+<a id="op-listinboxusers"></a>
+
+### `g8.api.aiInbox.listInboxUsers(input?)`
+
+**List Inbox Users**
+
+- HTTP: `GET /api/v1/inbox/users`
+- operationId: `list_inbox_users_inbox_users_get` (also callable as `g8.api.call("list_inbox_users_inbox_users_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Everyone in the organisation, as the inbox sees them.
+
+The directory an assignment draws from - but eligibility for a SPECIFIC
+conversation is a separate question, answered by
+`/inbox/channels/{id}/assignee-eligibility`.
+
+**Input**: none.
+
+**Returns** `ApiResponse_InboxListPayload_`: the envelope `{ data: InboxListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listInboxUsers();
+```
+
+---
+
+<a id="op-listinboxworkspaces"></a>
+
+### `g8.api.aiInbox.listInboxWorkspaces(input?)`
+
+**List Inbox Workspaces**
+
+- HTTP: `GET /api/v1/inbox/workspaces`
+- operationId: `list_inbox_workspaces_inbox_workspaces_get` (also callable as `g8.api.call("list_inbox_workspaces_inbox_workspaces_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Inbox workspaces - the mailbox groupings a team works out of.
+
+PLURAL here, though the app splits reads onto `/workspace` and the one
+write onto `/workspaces`. Two paths one letter apart do not belong in a
+public contract.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.page` | `integer` | no | default `1` |
+| `query.page_size` | `integer` | no | default `20` |
+
+**Returns** `ApiResponse_InboxListPayload_`: the envelope `{ data: InboxListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listInboxWorkspaces();
+```
+
+---
+
+<a id="op-listmailboxassociatedsequences"></a>
+
+### `g8.api.aiInbox.listMailboxAssociatedSequences(input)`
+
+**List Mailbox Associated Sequences**
+
+- HTTP: `POST /api/v1/inbox/mailboxes/associated-sequences`
+- operationId: `list_mailbox_associated_sequences_inbox_mailboxes_associated_sequences_post` (also callable as `g8.api.call("list_mailbox_associated_sequences_inbox_mailboxes_associated_sequences_post", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Which sequences have threads in these mailboxes.
+
+A POST because the mailbox list is a body; it reads and writes nothing,
+so it gates on `inbox:read`.
+
+Keyed by mailbox ADDRESS. `/mailboxes/{mailbox_id}/associated-sequences`
+is the same question asked of one mailbox by its numeric id - a different
+key, which is why this is not folded into it.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `MailboxAddressesRequest` | yes | Request body; fields below. |
+
+Body fields (`MailboxAddressesRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.mailboxes` | `Array<string>` | yes | Mailbox addresses. An empty list returns an empty result. |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listMailboxAssociatedSequences({ body: { mailboxes: ["example"] } });
+```
+
+---
+
+<a id="op-listmeetingtasks"></a>
+
+### `g8.api.aiInbox.listMeetingTasks(input)`
+
+**List Meeting Tasks**
+
+- HTTP: `GET /api/v1/inbox/meetings/{meeting_id}/tasks`
+- operationId: `list_meeting_tasks_inbox_meetings__meeting_id__tasks_get` (also callable as `g8.api.call("list_meeting_tasks_inbox_meetings__meeting_id__tasks_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `meetings:read`
+
+Follow-ups hung off this meeting, filtered by the caller's task
+visibility - team-only tasks do not cross team boundaries just because the
+caller can open the meeting.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.meeting_id` | `string` | yes | Meeting id, as returned by `GET /inbox/meetings`. |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listMeetingTasks({ path: { meeting_id: "id" } });
+```
+
+---
+
+<a id="op-listmymeetingtasks"></a>
+
+### `g8.api.aiInbox.listMyMeetingTasks(input?)`
+
+**List My Meeting Tasks**
+
+- HTTP: `GET /api/v1/inbox/meetings/my-tasks`
+- operationId: `list_my_meeting_tasks_inbox_meetings_my_tasks_get` (also callable as `g8.api.call("list_my_meeting_tasks_inbox_meetings_my_tasks_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `meetings:read`
+
+Every meeting follow-up assigned to the caller, across all meetings.
+
+Declared BEFORE nothing in this router, but registered BEFORE
+`meetings_router`: `GET /inbox/meetings/{meeting_id}` already ships, and
+the parameter route would otherwise match `my-tasks` and look it up as a
+meeting id.
+
+Strictly meeting-derived tasks, not a general task list - see
+`GET /tasks` for that. Returns an empty list, not an error, when the
+caller has no team-member row in this organisation, which is what an
+org-scoped key will see.
+
+**Input**: none.
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.listMyMeetingTasks();
+```
+
+---
+
+<a id="op-markinboxemailread"></a>
+
+### `g8.api.aiInbox.markInboxEmailRead(input)`
+
+**Mark Inbox Email Read**
+
+- HTTP: `POST /api/v1/inbox/emails/{email_id}/mark-read`
+- operationId: `mark_inbox_email_read_inbox_emails__email_id__mark_read_post` (also callable as `g8.api.call("mark_inbox_email_read_inbox_emails__email_id__mark_read_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Mark an email thread read. Contacts nobody.
+
+Best-effort syncs the read state up to the mail provider as well, so the customer's
+own mailbox agrees. Idempotent.
+
+Gated on VISIBILITY of the owning mailbox: a personal mailbox is
+owner-only, so marking someone else's thread read is a 403 rather than a
+quiet mutation of their inbox.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.email_id` | `string` | yes | Email thread id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.markInboxEmailRead({ path: { email_id: "jane@acme.com" } });
+```
+
+---
+
+<a id="op-markinboxlinkedinconversationread"></a>
+
+### `g8.api.aiInbox.markInboxLinkedinConversationRead(input)`
+
+**Mark Inbox Linkedin Conversation Read**
+
+- HTTP: `POST /api/v1/inbox/linkedin/accounts/{account_id}/conversations/{conversation_id}/read`
+- operationId: `mark_inbox_linkedin_conversation_read_inbox_linkedin_accounts__account_id__conversations__conversation_id__read_post` (also callable as `g8.api.call("mark_inbox_linkedin_conversation_read_inbox_linkedin_accounts__account_id__conversations__conversation_id__read_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Mark a LinkedIn conversation read. Contacts nobody.
+
+Syncs seen-state to whichever provider serves this organisation. The
+handler resolves that STRICTLY on this path, so a credential-store failure
+surfaces as an error rather than quietly toggling read state on the wrong
+provider.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.account_id` | `integer` | yes | LinkedIn account id (integer). |
+| `path.conversation_id` | `string` | yes | LinkedIn conversation id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.markInboxLinkedinConversationRead({ path: { account_id: 123, conversation_id: "id" } });
+```
+
+---
+
+<a id="op-markinboxlinkedinconversationunread"></a>
+
+### `g8.api.aiInbox.markInboxLinkedinConversationUnread(input)`
+
+**Mark Inbox Linkedin Conversation Unread**
+
+- HTTP: `POST /api/v1/inbox/linkedin/accounts/{account_id}/conversations/{conversation_id}/unread`
+- operationId: `mark_inbox_linkedin_conversation_unread_inbox_linkedin_accounts__account_id__conversations__conversation_id__unread_post` (also callable as `g8.api.call("mark_inbox_linkedin_conversation_unread_inbox_linkedin_accounts__account_id__conversations__conversation_id__unread_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Put a LinkedIn conversation back in the unread queue.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.account_id` | `integer` | yes | LinkedIn account id (integer). |
+| `path.conversation_id` | `string` | yes | LinkedIn conversation id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.markInboxLinkedinConversationUnread({ path: { account_id: 123, conversation_id: "id" } });
+```
+
+---
+
+<a id="op-markinboxsmsread"></a>
+
+### `g8.api.aiInbox.markInboxSmsRead(input)`
+
+**Mark Inbox Sms Read**
+
+- HTTP: `POST /api/v1/inbox/sms/{thread_id}/mark-read`
+- operationId: `mark_inbox_sms_read_inbox_sms__thread_id__mark_read_post` (also callable as `g8.api.call("mark_inbox_sms_read_inbox_sms__thread_id__mark_read_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Mark an SMS thread read. Contacts nobody.
+
+Answers 200 whether or not the thread exists - the underlying update
+matches zero rows silently - so do not read success as proof the id was
+real.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.thread_id` | `string` | yes | SMS thread id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.markInboxSmsRead({ path: { thread_id: "id" } });
+```
+
+---
+
+<a id="op-markmeetingnotranscriptexpected"></a>
+
+### `g8.api.aiInbox.markMeetingNoTranscriptExpected(input)`
+
+**Mark Meeting No Transcript Expected**
+
+- HTTP: `POST /api/v1/inbox/meetings/{meeting_id}/no-transcript`
+- operationId: `mark_meeting_no_transcript_expected_inbox_meetings__meeting_id__no_transcript_post` (also callable as `g8.api.call("mark_meeting_no_transcript_expected_inbox_meetings__meeting_id__no_transcript_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `meetings:write`
+
+Say that this meeting was never recorded, so stop waiting for one.
+
+Distinguishes "nothing was captured" from "the recording has not arrived
+yet", which is what stops the meeting sitting in a pending state forever.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.meeting_id` | `string` | yes | Meeting id, as returned by `GET /inbox/meetings`. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.markMeetingNoTranscriptExpected({ path: { meeting_id: "id" } });
+```
+
+---
+
+<a id="op-removechanneltag"></a>
+
+### `g8.api.aiInbox.removeChannelTag(input)`
+
+**Remove Channel Tag**
+
+- HTTP: `DELETE /api/v1/inbox/channels/{channel_id}/tags`
+- operationId: `remove_channel_tag_inbox_channels__channel_id__tags_delete` (also callable as `g8.api.call("remove_channel_tag_inbox_channels__channel_id__tags_delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `inbox:delete`
+
+Take a tag off a conversation. The tag itself survives.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.channel_id` | `string` | yes | Conversation id. |
+| `query.tag_id` | `string` | yes | The tag to remove. |
+| `query.channel_type` | `"email" \| "chat" \| "phone" \| "sms" \| "heyreach" \| "meetings" \| "support" \| "all"` | yes | Which channel the conversation lives in. REQUIRED: the same id means different rows in different channels, so this is what identifies the conversation, not a filter. |
+| `query.linkedin_account_id` | `integer \| null` | no | LinkedIn account id. Required only for `heyreach`, where the id is account-scoped and ambiguous without it. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.aiInbox.removeChannelTag({
+  path: { channel_id: "id" },
+  query: { tag_id: "id", channel_type: "email" },
+});
+```
+
+---
+
+<a id="op-revalidateinboxmailbox"></a>
+
+### `g8.api.aiInbox.revalidateInboxMailbox(input)`
+
+**Revalidate Inbox Mailbox**
+
+- HTTP: `POST /api/v1/inbox/mailboxes/{mailbox}/revalidate`
+- operationId: `revalidate_inbox_mailbox_inbox_mailboxes__mailbox__revalidate_post` (also callable as `g8.api.call("revalidate_inbox_mailbox_inbox_mailboxes__mailbox__revalidate_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Re-check this mailbox's credentials and folders, and store the answer.
+
+Contacts no recipient. It connects to the provider to find out whether the
+stored credentials still work, then writes `is_supported`, the error
+message and the credential-error flag back onto the sync record - which is
+what makes a mailbox that silently stopped working visible.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.mailbox` | `string` | yes | The mailbox ADDRESS, e.g. `sales@acme.com`. Not a numeric id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.revalidateInboxMailbox({ path: { mailbox: "example" } });
+```
+
+---
+
+<a id="op-searchinboxcallresults"></a>
+
+### `g8.api.aiInbox.searchInboxCallResults(input?)`
+
+**Search Inbox Call Results**
+
+- HTTP: `POST /api/v1/inbox/call-results/search`
+- operationId: `search_inbox_call_results_inbox_call_results_search_post` (also callable as `g8.api.call("search_inbox_call_results_inbox_call_results_search_post", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Inbound call outcomes, filtered and paged. Reads only.
+
+A POST because the filter set is a body; it gates on `inbox:read`.
+FAILED calls are excluded by the handler - this is the answered-call
+record, not a call log.
+
+NOT `/voice/dialer/calls`, which reads the outbound dialer's own tables.
+Same-sounding feature, different rows.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `CallResultSearchRequest` | no | Request body; fields below. |
+
+Body fields (`CallResultSearchRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.assigned_to_user_email` | `string \| null` | no |  |
+| `body.campaign_ids` | `Array<string> \| null` | no |  |
+| `body.disposition` | `"booked" \| "positive" \| "neutral" \| "negative" \| "voicemail" \| null` | no |  |
+| `body.page` | `integer` | no | default `1`, min 1 |
+| `body.page_size` | `integer` | no | default `20`, min 1, max 100 |
+| `body.sort_by` | `"updated_at" \| "created_at" \| "last_message_at"` | no | default `"updated_at"` |
+| `body.sort_order` | `"asc" \| "desc"` | no | default `"desc"` |
+| `body.tag_ids` | `Array<string> \| null` | no |  |
+| `body.updated_after` | `string (date-time) \| null` | no |  |
+| `body.updated_before` | `string (date-time) \| null` | no |  |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.searchInboxCallResults();
+```
+
+---
+
+<a id="op-searchinboxlinkedinconversations"></a>
+
+### `g8.api.aiInbox.searchInboxLinkedinConversations(input?)`
+
+**Search Inbox Linkedin Conversations**
+
+- HTTP: `POST /api/v1/inbox/linkedin/conversations/search`
+- operationId: `search_inbox_linkedin_conversations_inbox_linkedin_conversations_search_post` (also callable as `g8.api.call("search_inbox_linkedin_conversations_inbox_linkedin_conversations_search_post", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Search LinkedIn conversations across accounts.
+
+A POST because the filter is a body, not because it writes anything - it
+gates on `inbox:read`, matching `POST /inbox/chats/search` beside it.
+
+`seen: false` is the unread view. `sequence_ids` are graph8 sequence ids;
+the handler maps them onto the provider's own campaign ids for you.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `LinkedInConversationSearchRequest` | no | Request body; fields below. |
+
+Body fields (`LinkedInConversationSearchRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.limit` | `integer` | no | default `25`, min 1, max 100 |
+| `body.linkedin_account_ids` | `Array<integer> \| null` | no |  |
+| `body.offset` | `integer` | no | default `0`, min 0 |
+| `body.search` | `string \| null` | no |  |
+| `body.seen` | `boolean \| null` | no | False returns only unread conversations. |
+| `body.sequence_ids` | `Array<string> \| null` | no |  |
+| `body.sort_order` | `"asc" \| "desc"` | no | default `"desc"` |
+| `body.tags` | `Array<string> \| null` | no |  |
+| `body.updated_after` | `string (date-time) \| null` | no |  |
+| `body.updated_before` | `string (date-time) \| null` | no |  |
+
+**Returns** `ApiResponse_InboxOpsListPayload_`: the envelope `{ data: InboxOpsListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`InboxOpsListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.searchInboxLinkedinConversations();
+```
+
+---
+
+<a id="op-setchannelaipause"></a>
+
+### `g8.api.aiInbox.setChannelAiPause(input)`
+
+**Set Channel Ai Pause**
+
+- HTTP: `POST /api/v1/inbox/channels/{channel_id}/ai-pause`
+- operationId: `set_channel_ai_pause_inbox_channels__channel_id__ai_pause_post` (also callable as `g8.api.call("set_channel_ai_pause_inbox_channels__channel_id__ai_pause_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Stop the AI answering THIS conversation, or let it resume.
+
+Scoped to the one thread: pausing here does not disable the responder
+anywhere else. This is the handover switch - pause it when a human takes
+over, so the customer does not get two replies.
+
+`paused` is explicit rather than a toggle, so a retried request is
+idempotent instead of flipping the state back.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.channel_id` | `string` | yes | Conversation id. |
+| `query.channel_type` | `"email" \| "chat" \| "phone" \| "sms" \| "heyreach" \| "meetings" \| "support" \| "all"` | yes | Which channel the conversation lives in. REQUIRED: the same id means different rows in different channels, so this is what identifies the conversation, not a filter. |
+| `body` | `AiPauseRequest` | yes | Request body; fields below. |
+
+Body fields (`AiPauseRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.paused` | `boolean` | yes | True stops the AI answering this thread; false lets it resume. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.setChannelAiPause({
+  path: { channel_id: "id" },
+  query: { channel_type: "email" },
+  body: { paused: true },
+});
+```
+
+---
+
+<a id="op-setinboxemailsequence"></a>
+
+### `g8.api.aiInbox.setInboxEmailSequence(input)`
+
+**Set Inbox Email Sequence**
+
+- HTTP: `POST /api/v1/inbox/emails/{email_id}/sequence`
+- operationId: `set_inbox_email_sequence_inbox_emails__email_id__sequence_post` (also callable as `g8.api.call("set_inbox_email_sequence_inbox_emails__email_id__sequence_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Attribute a thread to a sequence, WITHOUT touching the sequencer.
+
+The quiet twin of `link-sequence`: it re-labels the thread for reporting
+and does not tell the sequencer anything, so the contact keeps receiving
+the remaining steps. Use `link-sequence` when someone replied.
+
+Accepts any id - unlike `link-sequence` there is no candidate check - so
+a wrong value mislabels the thread silently. Gated on visibility of the
+owning mailbox.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.email_id` | `string` | yes | Email thread id. |
+| `query.sequence_id` | `string` | yes | Sequence (campaign) id to attribute the thread to. |
+| `query.sequence_name` | `string` | yes | Display name stored alongside the id. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.setInboxEmailSequence({
+  path: { email_id: "jane@acme.com" },
+  query: { sequence_id: "id", sequence_name: "Example" },
+});
+```
+
+---
+
+<a id="op-setinboxemailsettings"></a>
+
+### `g8.api.aiInbox.setInboxEmailSettings(input)`
+
+**Set Inbox Email Settings**
+
+- HTTP: `PUT /api/v1/inbox/email-settings`
+- operationId: `set_inbox_email_settings_inbox_email_settings_put` (also callable as `g8.api.call("set_inbox_email_settings_inbox_email_settings_put", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Create or replace the organisation's AI Inbox email settings.
+
+A PUT because it REPLACES: the app writes every field, so anything you
+omit is written as its default rather than left alone. Read the current
+settings, change the one field, send the whole thing back.
+
+`business_hours_only` plus the start/end hours are what stop the AI
+replying to a customer at 3am. `event_id` is the booking event it offers
+when it schedules a meeting.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `EmailSettingsRequest` | yes | Request body; fields below. |
+
+Body fields (`EmailSettingsRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.timezone` | `string` | yes | IANA timezone name, e.g. `America/New_York`. Required. |
+| `body.agent_id` | `string \| integer \| null \| null` | no | AI Inbox agent that answers. See `POST /inbox/agents`. |
+| `body.auto_tagging` | `boolean` | no | default `false` |
+| `body.business_hours_end` | `integer` | no | default `17` |
+| `body.business_hours_only` | `boolean` | no | Restrict AI replies to the hours below. default `false` |
+| `body.business_hours_start` | `integer` | no | default `9` |
+| `body.event_id` | `integer \| null` | no | Booking event the AI offers when it schedules a meeting. |
+| `body.refresh_rate` | `integer` | no | Minutes between sync rounds. default `1` |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.setInboxEmailSettings({ body: { timezone: "example" } });
+```
+
+---
+
+<a id="op-setinboxmailboxvisibility"></a>
+
+### `g8.api.aiInbox.setInboxMailboxVisibility(input)`
+
+**Set Inbox Mailbox Visibility**
+
+- HTTP: `PATCH /api/v1/inbox/mailboxes/{mailbox}/visibility`
+- operationId: `set_inbox_mailbox_visibility_inbox_mailboxes__mailbox__visibility_patch` (also callable as `g8.api.call("set_inbox_mailbox_visibility_inbox_mailboxes__mailbox__visibility_patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Share a mailbox with the team, or make it personal again.
+
+THIS CHANGES WHO CAN READ THE THREADS IN IT. Sharing exposes the
+conversation history of that mailbox to every team member; un-sharing
+hides it again, but not retroactively.
+
+ONLY THE OWNER may change it - the person the mailbox was created by.
+An API key acts as its minting human, so a key held by anyone else gets a
+403, and an org-scoped key (which owns nothing) always does.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.mailbox` | `string` | yes | The mailbox ADDRESS, e.g. `sales@acme.com`. Not a numeric id. |
+| `query.shared_with_team` | `boolean` | yes | True makes the mailbox and its threads visible to the whole team. False makes it personal to its owner. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.setInboxMailboxVisibility({ path: { mailbox: "example" }, query: { shared_with_team: true } });
+```
+
+---
+
+<a id="op-setmeetingsensitivity"></a>
+
+### `g8.api.aiInbox.setMeetingSensitivity(input)`
+
+**Set Meeting Sensitivity**
+
+- HTTP: `PATCH /api/v1/inbox/meetings/{meeting_id}/sensitivity`
+- operationId: `set_meeting_sensitivity_inbox_meetings__meeting_id__sensitivity_patch` (also callable as `g8.api.call("set_meeting_sensitivity_inbox_meetings__meeting_id__sensitivity_patch", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `meetings:delete`
+
+CHANGE WHO MAY READ THE RECORDING OF THIS MEETING.
+
+`private` HIDES the transcript from everyone except the meeting's
+participants. `normal` EXPOSES it to the organisation again - and a
+transcript that has been read cannot be un-read, so going back to `normal`
+is not a reversible edit in any sense that matters.
+
+Only a PARTICIPANT may change it; anyone else gets a 403. Classified
+`destructive`, so it needs `inbox:delete` rather than riding along with
+`inbox:write` - a key that triages the inbox should not also be able to
+publish a private recording.
+
+`sensitivity` is REQUIRED here. The app defaults a missing key to
+`normal`, which is the exposing direction, so this contract refuses to
+guess.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.meeting_id` | `string` | yes | Meeting id, as returned by `GET /inbox/meetings`. |
+| `body` | `MeetingSensitivityRequest` | yes | Request body; fields below. |
+
+Body fields (`MeetingSensitivityRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.sensitivity` | `"normal" \| "private"` | yes | `private` = participants only. `normal` = visible to the organisation. Required - there is no safe default. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.aiInbox.setMeetingSensitivity({ path: { meeting_id: "id" }, body: { sensitivity: "normal" } });
+```
+
+---
+
+<a id="op-startinboxmailboxsync"></a>
+
+### `g8.api.aiInbox.startInboxMailboxSync(input)`
+
+**Start Inbox Mailbox Sync**
+
+- HTTP: `POST /api/v1/inbox/mailboxes/{mailbox}/sync`
+- operationId: `start_inbox_mailbox_sync_inbox_mailboxes__mailbox__sync_post` (also callable as `g8.api.call("start_inbox_mailbox_sync_inbox_mailboxes__mailbox__sync_post", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `inbox:run`
+
+START POLLING this mailbox.
+
+REACHES OUTSIDE GRAPH8: from here on the platform connects to the
+customer's Google or IMAP server with their stored credentials, on a
+schedule, until it is stopped. Classified `external`, so it needs
+`inbox:run` rather than plain write.
+
+It contacts no recipient - nothing is SENT by turning sync on. What it
+can lead to is the AI answering on this mailbox, which is governed
+separately by `auto_respond`.
+
+Refuses with 400 if the mailbox is already running, so a retry is safe
+rather than doubling the polling.
+
+202 because the first sync round happens on the org-level worker's next
+pass, not inside this request.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.mailbox` | `string` | yes | The mailbox ADDRESS, e.g. `sales@acme.com`. Not a numeric id. |
+| `query.provider` | `"google_mailbox" \| "smtp"` | yes | How the mailbox is connected. REQUIRED and not inferred: the same address can be connected either way, and guessing would act on the wrong transport. Closed to a Literal so an unknown value is a 422 naming both, rather than a `ValueError` raised inside the handler. |
+| `query.display_name` | `string \| null` | no | Label shown beside the address. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.aiInbox.startInboxMailboxSync({
+  path: { mailbox: "example" },
+  query: { provider: "google_mailbox" },
+});
+```
+
+---
+
+<a id="op-stopinboxmailboxsync"></a>
+
+### `g8.api.aiInbox.stopInboxMailboxSync(input)`
+
+**Stop Inbox Mailbox Sync**
+
+- HTTP: `DELETE /api/v1/inbox/mailboxes/{mailbox}/sync`
+- operationId: `stop_inbox_mailbox_sync_inbox_mailboxes__mailbox__sync_delete` (also callable as `g8.api.call("stop_inbox_mailbox_sync_inbox_mailboxes__mailbox__sync_delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `inbox:delete`
+
+STOP polling this mailbox.
+
+Stops the sync, not the mailbox: the threads already pulled in stay, and
+the mailbox record itself is untouched. 404 if this mailbox was never
+connected to the inbox.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.mailbox` | `string` | yes | The mailbox ADDRESS, e.g. `sales@acme.com`. Not a numeric id. |
+| `query.provider` | `"google_mailbox" \| "smtp"` | yes | How the mailbox is connected. REQUIRED and not inferred: the same address can be connected either way, and guessing would act on the wrong transport. Closed to a Literal so an unknown value is a 422 naming both, rather than a `ValueError` raised inside the handler. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.aiInbox.stopInboxMailboxSync({
+  path: { mailbox: "example" },
+  query: { provider: "google_mailbox" },
+});
+```
+
+---
+
+<a id="op-syncinboxlinkedinaccounts"></a>
+
+### `g8.api.aiInbox.syncInboxLinkedinAccounts(input?)`
+
+**Sync Inbox Linkedin Accounts**
+
+- HTTP: `POST /api/v1/inbox/linkedin/accounts/sync`
+- operationId: `sync_inbox_linkedin_accounts_inbox_linkedin_accounts_sync_post` (also callable as `g8.api.call("sync_inbox_linkedin_accounts_inbox_linkedin_accounts_sync_post", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `inbox:run`
+
+Refresh the organisation's LinkedIn accounts from the provider.
+
+Creates a local configuration record for every account the provider
+reports that graph8 has not seen, and refreshes the cached profile of the
+rest. Existing configuration (enabled, auto-respond) is not changed.
+Returns the counts. Sends nothing.
+
+**Input**: none.
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.aiInbox.syncInboxLinkedinAccounts();
+```
+
+---
+
+<a id="op-toggleinboxmailboxes"></a>
+
+### `g8.api.aiInbox.toggleInboxMailboxes(input)`
+
+**Toggle Inbox Mailboxes**
+
+- HTTP: `PATCH /api/v1/inbox/mailboxes/bulk`
+- operationId: `toggle_inbox_mailboxes_inbox_mailboxes_bulk_patch` (also callable as `g8.api.call("toggle_inbox_mailboxes_inbox_mailboxes_bulk_patch", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `inbox:run`
+
+Flip several mailboxes on or off by address, and optionally set
+auto-respond on all of them in the same call.
+
+PARTIALLY TOLERANT where activate is not: this one reports failures in the
+body and still returns 200. Check `total_failed`.
+
+`activate` is explicit rather than a toggle, so a retried request is
+idempotent instead of putting the mailboxes back the way they were.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `MailboxToggleRequest` | yes | Request body; fields below. |
+
+Body fields (`MailboxToggleRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.activate` | `boolean` | yes | True starts syncing, false stops it. |
+| `body.mailboxes` | `Array<string>` | yes | Mailbox addresses. min items 1 |
+| `body.auto_respond` | `boolean \| null` | no |  |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.aiInbox.toggleInboxMailboxes({ body: { activate: true, mailboxes: ["example"] } });
+```
+
+---
+
+<a id="op-unassignchannel"></a>
+
+### `g8.api.aiInbox.unassignChannel(input)`
+
+**Unassign Channel**
+
+- HTTP: `DELETE /api/v1/inbox/channels/{channel_id}/assign`
+- operationId: `unassign_channel_inbox_channels__channel_id__assign_delete` (also callable as `g8.api.call("unassign_channel_inbox_channels__channel_id__assign_delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `inbox:delete`
+
+Take ONE person off a conversation. The others keep it.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.channel_id` | `string` | yes | Conversation id. |
+| `query.assignee_email` | `string` | yes | The person to take off. |
+| `query.channel_type` | `"email" \| "chat" \| "phone" \| "sms" \| "heyreach" \| "meetings" \| "support" \| "all"` | yes | Which channel the conversation lives in. REQUIRED: the same id means different rows in different channels, so this is what identifies the conversation, not a filter. |
+| `query.linkedin_account_id` | `integer \| null` | no | LinkedIn account id. Required only for `heyreach`, where the id is account-scoped and ambiguous without it. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.aiInbox.unassignChannel({
+  path: { channel_id: "id" },
+  query: { assignee_email: "jane@acme.com", channel_type: "email" },
+});
+```
+
+---
+
+<a id="op-unblockinboxsender"></a>
+
+### `g8.api.aiInbox.unblockInboxSender(input)`
+
+**Unblock Inbox Sender**
+
+- HTTP: `DELETE /api/v1/inbox/blocked-senders/{blocked_sender_id}`
+- operationId: `unblock_inbox_sender_inbox_blocked_senders__blocked_sender_id__delete` (also callable as `g8.api.call("unblock_inbox_sender_inbox_blocked_senders__blocked_sender_id__delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `inbox:delete`
+
+Let a sender through again. Mail already refused is not recovered.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.blocked_sender_id` | `string` | yes | Id of the block record, from `GET /inbox/blocked-senders`. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.aiInbox.unblockInboxSender({ path: { blocked_sender_id: "id" } });
+```
+
+---
+
+<a id="op-updateinboxlinkedinaccount"></a>
+
+### `g8.api.aiInbox.updateInboxLinkedinAccount(input)`
+
+**Update Inbox Linkedin Account**
+
+- HTTP: `PUT /api/v1/inbox/linkedin/accounts/{account_id}`
+- operationId: `update_inbox_linkedin_account_inbox_linkedin_accounts__account_id__put` (also callable as `g8.api.call("update_inbox_linkedin_account_inbox_linkedin_accounts__account_id__put", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `inbox:run`
+
+Configure one LinkedIn account's place in the inbox.
+
+PARTIAL: only the fields you send are written, so omitting
+`auto_respond_config` leaves the existing one alone.
+
+READ THIS BEFORE TURNING ANYTHING ON. `auto_respond: true` with
+`auto_respond_config.require_human_review: false` is the combination that
+lets the AI message real people on this account unattended - no draft, no
+approval. `require_human_review` defaults to TRUE and this route does not
+change that; it only stops applying if you send a config that says
+otherwise.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.account_id` | `integer` | yes | LinkedIn account id (integer). |
+| `body` | `LinkedInAccountConfigRequest` | yes | Request body; fields below. |
+
+Body fields (`LinkedInAccountConfigRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.ai_inbox_enabled` | `boolean \| null` | no | Whether the account's conversations appear in the inbox at all. |
+| `body.auto_respond` | `boolean \| null` | no |  |
+| `body.auto_respond_config` | `LinkedInAutoRespondConfig \| null` | no |  |
+| `body.linkedin_campaign_id` | `integer \| null` | no | Provider-side campaign id to attribute conversations to. |
+| `body.sequence_id` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.aiInbox.updateInboxLinkedinAccount({ path: { account_id: 123 }, body: {} });
+```
+
+---
+
+<a id="op-updateinboxmailboxsettings"></a>
+
+### `g8.api.aiInbox.updateInboxMailboxSettings(input)`
+
+**Update Inbox Mailbox Settings**
+
+- HTTP: `PATCH /api/v1/inbox/mailboxes/{mailbox}/settings`
+- operationId: `update_inbox_mailbox_settings_inbox_mailboxes__mailbox__settings_patch` (also callable as `g8.api.call("update_inbox_mailbox_settings_inbox_mailboxes__mailbox__settings_patch", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `inbox:run`
+
+Change one mailbox's inbox settings. PARTIAL: omitted fields are left alone.
+
+`auto_respond: true` LETS THE AI ANSWER REAL PEOPLE from this mailbox,
+unattended, so the operation is classified `external` (`inbox:run`) - the
+same call already made for the LinkedIn account configuration. 404 if the
+mailbox was never connected to the inbox.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.mailbox` | `string` | yes | The mailbox ADDRESS, e.g. `sales@acme.com`. Not a numeric id. |
+| `query.provider` | `"google_mailbox" \| "smtp"` | yes | How the mailbox is connected. REQUIRED and not inferred: the same address can be connected either way, and guessing would act on the wrong transport. Closed to a Literal so an unknown value is a 422 naming both, rather than a `ValueError` raised inside the handler. |
+| `body` | `MailboxSettingsRequest` | yes | Request body; fields below. |
+
+Body fields (`MailboxSettingsRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.auto_respond` | `boolean \| null` | no | True lets the AI answer inbound mail on this mailbox. It will message real people. |
+| `body.last_unread_limit` | `integer \| null` | no | How many unread emails a sync round fetches. min 1, max 100 |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.aiInbox.updateInboxMailboxSettings({
+  path: { mailbox: "example" },
+  query: { provider: "google_mailbox" },
+  body: {},
+});
+```
+
+---
+
+<a id="op-updateinboxtag"></a>
+
+### `g8.api.aiInbox.updateInboxTag(input)`
+
+**Update Inbox Tag**
+
+- HTTP: `PUT /api/v1/inbox/tags/{tag_id}`
+- operationId: `update_inbox_tag_inbox_tags__tag_id__put` (also callable as `g8.api.call("update_inbox_tag_inbox_tags__tag_id__put", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Edit an inbox tag.
+
+`/inbox/tags/...`, not `/tags/...`: `/contacts/tags` is a DIFFERENT
+vocabulary (contact tags on a CRM record) and these are conversation
+labels. The published READ of these same objects ships as
+`GET /workflows/inbox-tags`, because the workflow builder needed it first.
+
+`ai_can_apply` and `rules` are what let the auto-tagger reach for this tag
+on its own, so changing them changes what the AI does to threads nobody
+looked at.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.tag_id` | `string` | yes | Tag id, from `GET /workflows/inbox-tags`. |
+| `body` | `TagUpdateRequest` | yes | Request body; fields below. |
+
+Body fields (`TagUpdateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.agent_id` | `string \| null` | no |  |
+| `body.ai_can_apply` | `boolean \| null` | no | Whether the AI may apply this tag on its own. |
+| `body.color` | `string \| null` | no |  |
+| `body.description` | `string \| null` | no |  |
+| `body.name` | `string \| null` | no |  |
+| `body.priority` | `integer \| null` | no | 1-100. min 1, max 100 |
+| `body.rules` | `Array<string> \| null` | no | Natural-language rules the AI uses to decide the tag applies. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.updateInboxTag({ path: { tag_id: "id" }, body: {} });
+```
+
+---
+
+<a id="op-updatemeetingtask"></a>
+
+### `g8.api.aiInbox.updateMeetingTask(input)`
+
+**Update Meeting Task**
+
+- HTTP: `PATCH /api/v1/inbox/meetings/tasks/{task_id}`
+- operationId: `update_meeting_task_inbox_meetings_tasks__task_id__patch` (also callable as `g8.api.call("update_meeting_task_inbox_meetings_tasks__task_id__patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `meetings:write`
+
+Patch a meeting task. Reassignment re-checks participant scope.
+
+THREE-STATE nullable fields: omit `assignee_user_id` or
+`due_date` to leave it alone, send it as `null` to CLEAR it. The proxy
+forwards with `exclude_unset=True` precisely so the app can still tell
+those apart - dumping every field would turn each PATCH into a full
+overwrite that cleared whatever the caller did not mention.
+
+Pass `expected_updated_at` to refuse the write if someone else moved the
+task since you read it.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.task_id` | `string` | yes | Meeting task id. |
+| `body` | `MeetingTaskUpdateRequest` | yes | Request body; fields below. |
+
+Body fields (`MeetingTaskUpdateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.assignee_user_id` | `string \| null` | no |  |
+| `body.description` | `string \| null` | no |  |
+| `body.due_date` | `string (date-time) \| null` | no |  |
+| `body.expected_updated_at` | `string (date-time) \| null` | no | Optimistic concurrency: the `updated_at` you read. If the task moved since, the update is refused instead of silently overwriting someone else's edit. |
+| `body.priority` | `integer \| null` | no |  |
+| `body.status` | `"open" \| "in_progress" \| "completed" \| "done" \| "cancelled" \| null` | no |  |
+| `body.title` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.updateMeetingTask({ path: { task_id: "id" }, body: {} });
+```
+
+---
+
+<a id="op-uploadinboxdraftattachment"></a>
+
+### `g8.api.aiInbox.uploadInboxDraftAttachment(input?)`
+
+**Upload Inbox Draft Attachment**
+
+- HTTP: `POST /api/v1/inbox/drafts/attachments`
+- operationId: `upload_inbox_draft_attachment_inbox_drafts_attachments_post` (also callable as `g8.api.call("upload_inbox_draft_attachment_inbox_drafts_attachments_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Attach a file to an existing email draft (multipart: `file`, `draft_id`).
+
+Returns `token`, `key`, `name`, `size`, `contentType`. The draft must
+already exist and the caller must be allowed to send from its mailbox - a
+403 otherwise; 413 over 25 MB. Nothing is sent: the file rides along when
+the draft is.
+
+Calls the app handler's own body (`__wrapped__`): the app wraps it in a
+per-process rate limiter bound to the APP's state, and this API's own
+rate limit applies instead.
+
+**Input**: none.
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.uploadInboxDraftAttachment();
+```
+
+---
+
+<a id="op-uploadinboxnoteattachment"></a>
+
+### `g8.api.aiInbox.uploadInboxNoteAttachment(input?)`
+
+**Upload Inbox Note Attachment**
+
+- HTTP: `POST /api/v1/inbox/notes/attachments`
+- operationId: `upload_inbox_note_attachment_inbox_notes_attachments_post` (also callable as `g8.api.call("upload_inbox_note_attachment_inbox_notes_attachments_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `inbox:write`
+
+Upload a file for an INTERNAL note (multipart: `file`).
+
+Returns the attachment ref (`token`, `key`, `name`, `size`,
+`contentType`) that `POST /inbox/channels/{channel_id}/comments` accepts
+in `attachments`. Notes are internal, so nothing reaches a customer.
+
+**Input**: none.
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.uploadInboxNoteAttachment();
+```
+
+---
+
+<a id="op-validateinboxlinkedinaccount"></a>
+
+### `g8.api.aiInbox.validateInboxLinkedinAccount(input)`
+
+**Validate Inbox Linkedin Account**
+
+- HTTP: `POST /api/v1/inbox/linkedin/validate-account`
+- operationId: `validate_inbox_linkedin_account_inbox_linkedin_validate_account_post` (also callable as `g8.api.call("validate_inbox_linkedin_account_inbox_linkedin_validate_account_post", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Can this LinkedIn account send right now? Reads only.
+
+Checks the account is synced locally, enabled for the inbox, active at the
+provider, and that the provider credentials still authenticate. Gates on
+`inbox:read`.
+
+NOTE the app's shape, preserved here: a failure to reach the provider is
+reported as `valid: false` with an `error` string and HTTP 200, not as a
+5xx. Read `valid`, not the status code.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.linkedin_account_id` | `integer` | yes | The account you intend to send from. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.validateInboxLinkedinAccount({ query: { linkedin_account_id: 123 } });
+```
+
+---
+
+<a id="op-validateinboxsendmailbox"></a>
+
+### `g8.api.aiInbox.validateInboxSendMailbox(input)`
+
+**Validate Inbox Send Mailbox**
+
+- HTTP: `POST /api/v1/inbox/emails/validate-mailbox`
+- operationId: `validate_inbox_send_mailbox_inbox_emails_validate_mailbox_post` (also callable as `g8.api.call("validate_inbox_send_mailbox_inbox_emails_validate_mailbox_post", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `inbox:read`
+
+Can this mailbox send right now? Reads only - nothing is delivered.
+
+Checks that the mailbox is connected, syncing, of a supported provider,
+that its credentials still work, and that this caller is allowed to send
+as it. Gates on `inbox:read`: a key that can only read the inbox must
+still be able to find out whether a send WOULD work before anyone tries.
+
+An unauthorised mailbox is a 403 here, the same refusal the send itself
+gives, so the pre-flight and the real thing cannot disagree.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.mailbox` | `string` | yes | The mailbox address you intend to send AS. |
+
+**Returns** `ApiResponse_InboxPayload_`: the envelope `{ data: InboxPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.aiInbox.validateInboxSendMailbox({ query: { mailbox: "example" } });
+```
+
+---
+
+## Referenced types
+
+Named types that appear in the tables above. Full TypeScript definitions: `G8Contract.<Name>` (`import type { G8Contract } from "@graph8/sdk"`).
+
+<a id="type-commentattachmentref"></a>
+
+### `CommentAttachmentRef`
+
+A file already uploaded to the private note namespace. Only `token` and `key` are load-bearing: the server re-validates the capability token and never trusts the name, size or type a client sends. They are accepted because the app's model accepts them.
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `key` | `string` | yes | max length 1024 |
+| `token` | `string` | yes | max length 8192 |
+| `name` | `string \| null` | no |  |
+| `size` | `integer \| null` | no |  |
+| `type` | `string \| null` | no |  |
+
+<a id="type-linkedinautorespondconfig"></a>
+
+### `LinkedInAutoRespondConfig`
+
+When the AI is allowed to answer on a LinkedIn account by itself.
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `business_hours_end` | `integer` | no | default `17` |
+| `business_hours_only` | `boolean` | no | default `true` |
+| `business_hours_start` | `integer` | no | default `9` |
+| `enabled` | `boolean` | no | default `false` |
+| `exclude_intents` | `Array<string>` | no |  |
+| `max_replies_per_conversation` | `integer` | no | default `2` |
+| `min_delay_minutes` | `integer` | no | default `5` |
+| `require_human_review` | `boolean` | no | True holds the reply as a draft instead of sending it. default `true` |
+| `timezone` | `string` | no | default `"America/New_York"` |
+| `trigger_on_intents` | `Array<string>` | no |  |
+
+<a id="type-mailboxjobitem"></a>
+
+### `MailboxJobItem`
+
+One mailbox in a bulk activate/deactivate request.
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `mailbox` | `string` | yes | The mailbox address. |
+| `provider` | `"google_mailbox" \| "smtp"` | yes |  |
+| `display_name` | `string \| null` | no |  |