@graph8/sdk 0.251.0 → 0.260.0

package/docs/api/dialer.md

@@ -0,0 +1,2166 @@
+<!-- Generated by sdk/js/scripts/generate-agent-docs.ts from developer-contract/openapi.json. Regenerated on every build. -->
+
+# `g8.api.dialer`: Dialer
+
+46 operations (12 read, 23 write, 2 destructive, 2 billable, 7 external).
+
+No hand-written client covers this area. Call it through `g8.api.dialer.*` 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: [dialer.d.ts](dialer.d.ts).
+
+## Operations
+
+| Call | HTTP | Tier | Scope | Summary |
+|---|---|---|---|---|
+| [`backfillGrading`](#op-backfillgrading) | `POST /api/v1/dialer/parallel-calls/grading/backfill` | billable | `voice:run` | Backfill Grading |
+| [`checkCampaignReadiness`](#op-checkcampaignreadiness) | `GET /api/v1/dialer/parallel-calls/grading/campaign-readiness` | read | `voice:read` | Check Campaign Readiness |
+| [`checkRecordingOwnership`](#op-checkrecordingownership) | `GET /api/v1/dialer/parallel-calls/recordings/ownership` | read | `voice:read` | Check Recording Ownership |
+| [`clearSdrTargets`](#op-clearsdrtargets) | `DELETE /api/v1/dialer/parallel-calls/targets/sdr` | destructive | `voice:write` | Clear Sdr Targets |
+| [`createPausedParallelSession`](#op-createpausedparallelsession) | `POST /api/v1/dialer/parallel-calls/sessions` | write | `voice:write` | Create Paused Parallel Session |
+| [`createSessionDraft`](#op-createsessiondraft) | `POST /api/v1/dialer/sessions/draft` | write | `voice:write` | Create Session Draft |
+| [`declineTransfer`](#op-declinetransfer) | `POST /api/v1/dialer/transfer/{call_id}/decline` | write | `voice:write` | Decline Transfer |
+| [`deleteCustomDisposition`](#op-deletecustomdisposition) | `DELETE /api/v1/dialer/dispositions/{disposition_id}` | destructive | `voice:write` | Delete Custom Disposition |
+| [`dialNextBatch`](#op-dialnextbatch) | `POST /api/v1/dialer/sessions/{session_id}/next-batch` | external | `voice:run` | Dial Next Batch |
+| [`dropParallelVoicemail`](#op-dropparallelvoicemail) | `POST /api/v1/dialer/parallel-calls/calls/{livekit_room_name}/drop-voicemail` | external | `voice:run` | Drop Parallel Voicemail |
+| [`dropSessionVoicemail`](#op-dropsessionvoicemail) | `POST /api/v1/dialer/sessions/calls/drop-voicemail` | external | `voice:run` | Drop Session Voicemail |
+| [`hangupParallelCall`](#op-hangupparallelcall) | `POST /api/v1/dialer/parallel-calls/calls/hangup` | write | `voice:write` | Hangup Parallel Call |
+| [`hangupSessionCall`](#op-hangupsessioncall) | `POST /api/v1/dialer/sessions/calls/hangup` | write | `voice:write` | Hangup Session Call |
+| [`listContactIdsByDisposition`](#op-listcontactidsbydisposition) | `GET /api/v1/dialer/parallel-calls/sessions/{session_id}/contact-ids-by-disposition` | read | `voice:read` | List Contact Ids By Disposition |
+| [`listTransferDepartments`](#op-listtransferdepartments) | `GET /api/v1/dialer/transfer/departments` | read | `voice:read` | List Transfer Departments |
+| [`manualDial`](#op-manualdial) | `POST /api/v1/dialer/parallel-calls/manual-dial` | external | `voice:run` | Manual Dial |
+| [`markAllMissedCallbacksSeen`](#op-markallmissedcallbacksseen) | `PATCH /api/v1/dialer/parallel-calls/missed-callbacks/seen-all` | write | `voice:write` | Mark All Missed Callbacks Seen |
+| [`markGradingReviewed`](#op-markgradingreviewed) | `POST /api/v1/dialer/parallel-calls/calls/{livekit_room_name}/grading/review` | write | `voice:write` | Mark Grading Reviewed |
+| [`markMissedCallbacksSeen`](#op-markmissedcallbacksseen) | `PATCH /api/v1/dialer/parallel-calls/missed-callbacks/seen` | write | `voice:write` | Mark Missed Callbacks Seen |
+| [`mintSessionWsTicket`](#op-mintsessionwsticket) | `POST /api/v1/dialer/sessions/{session_id}/ws-ticket` | write | `voice:write` | Mint Session Ws Ticket |
+| [`mintSoftphoneToken`](#op-mintsoftphonetoken) | `GET /api/v1/dialer/sessions/token` | external | `voice:run` | Mint Softphone Token |
+| [`mintTranscriptWsTicket`](#op-minttranscriptwsticket) | `POST /api/v1/dialer/sessions/calls/{call_id}/ws-ticket` | write | `voice:write` | Mint Transcript Ws Ticket |
+| [`muteCall`](#op-mutecall) | `POST /api/v1/dialer/sessions/calls/mute` | write | `voice:write` | Mute Call |
+| [`prewarmVoicemails`](#op-prewarmvoicemails) | `POST /api/v1/dialer/sessions/prewarm-voicemails` | billable | `voice:run` | Prewarm Voicemails |
+| [`readAllSdrTargets`](#op-readallsdrtargets) | `GET /api/v1/dialer/parallel-calls/targets/all-sdrs` | read | `voice:read` | Read All Sdr Targets |
+| [`readDialerPreferences`](#op-readdialerpreferences) | `GET /api/v1/dialer/settings/preferences/{user_email}` | read | `voice:read` | Read Dialer Preferences |
+| [`readDialerReport`](#op-readdialerreport) | `GET /api/v1/dialer/parallel-calls/analytics/dialer-report` | read | `voice:read` | Read Dialer Report |
+| [`readOrgTargets`](#op-readorgtargets) | `GET /api/v1/dialer/parallel-calls/targets` | read | `voice:read` | Read Org Targets |
+| [`readProviderReceipt`](#op-readproviderreceipt) | `GET /api/v1/dialer/sessions/assurance/provider-receipt` | read | `voice:read` | Read Provider Receipt |
+| [`readQueueStats`](#op-readqueuestats) | `GET /api/v1/dialer/sessions/{session_id}/queue-stats` | read | `voice:read` | Read Queue Stats |
+| [`readSessionGrid`](#op-readsessiongrid) | `POST /api/v1/dialer/sessions/{session_id}/grid` | read | `voice:read` | Read Session Grid |
+| [`readTransferStatus`](#op-readtransferstatus) | `GET /api/v1/dialer/transfer/{call_id}` | read | `voice:read` | Read Transfer Status |
+| [`redialContact`](#op-redialcontact) | `POST /api/v1/dialer/parallel-calls/redial-contact` | external | `voice:run` | Redial Contact |
+| [`resolveMissedCallbacks`](#op-resolvemissedcallbacks) | `PATCH /api/v1/dialer/parallel-calls/missed-callbacks/resolve` | write | `voice:write` | Resolve Missed Callbacks |
+| [`setCallDisposition`](#op-setcalldisposition) | `PATCH /api/v1/dialer/parallel-calls/calls/{livekit_room_name}/disposition` | write | `voice:write` | Set Call Disposition |
+| [`setDialerPreferences`](#op-setdialerpreferences) | `PUT /api/v1/dialer/settings/preferences` | write | `voice:write` | Set Dialer Preferences |
+| [`setOrgTargets`](#op-setorgtargets) | `PUT /api/v1/dialer/parallel-calls/targets` | write | `voice:write` | Set Org Targets |
+| [`setSdrTargets`](#op-setsdrtargets) | `PUT /api/v1/dialer/parallel-calls/targets/sdr` | write | `voice:write` | Set Sdr Targets |
+| [`skipContact`](#op-skipcontact) | `POST /api/v1/dialer/sessions/{session_id}/calls/skip-contact` | write | `voice:write` | Skip Contact |
+| [`startParallelSession`](#op-startparallelsession) | `POST /api/v1/dialer/parallel-calls/sessions/start` | external | `voice:run` | Start Parallel Session |
+| [`unresolveMissedCallbacks`](#op-unresolvemissedcallbacks) | `PATCH /api/v1/dialer/parallel-calls/missed-callbacks/unresolve` | write | `voice:write` | Unresolve Missed Callbacks |
+| [`unskipContact`](#op-unskipcontact) | `POST /api/v1/dialer/sessions/{session_id}/calls/unskip-contact` | write | `voice:write` | Unskip Contact |
+| [`updateRedialState`](#op-updateredialstate) | `PATCH /api/v1/dialer/parallel-calls/sessions/{session_id}/redial-state` | write | `voice:write` | Update Redial State |
+| [`updateSessionBookingEventType`](#op-updatesessionbookingeventtype) | `PATCH /api/v1/dialer/sessions/{session_id}/booking-event-type` | write | `voice:write` | Update Session Booking Event Type |
+| [`updateSessionFilter`](#op-updatesessionfilter) | `PATCH /api/v1/dialer/sessions/{session_id}/filter-spec` | write | `voice:write` | Update Session Filter |
+| [`updateSessionHiddenFields`](#op-updatesessionhiddenfields) | `PATCH /api/v1/dialer/sessions/{session_id}/hidden-custom-fields` | write | `voice:write` | Update Session Hidden Fields |
+
+---
+
+<a id="op-backfillgrading"></a>
+
+### `g8.api.dialer.backfillGrading(input?)`
+
+**Backfill Grading**
+
+- HTTP: `POST /api/v1/dialer/parallel-calls/grading/backfill`
+- operationId: `backfill_grading_dialer_parallel_calls_grading_backfill_post` (also callable as `g8.api.call("backfill_grading_dialer_parallel_calls_grading_backfill_post", input)`)
+- Tier: `billable`: spends credits; the SDK never blindly retries it; confirm cost before bulk use
+- API-key scope: `voice:run`
+
+CONTACTS NOBODY - but it SPENDS, and it can spend a lot.
+
+With `dry_run=false` this runs AI grading over EVERY ungraded call with a
+transcript in the window - a model invocation each, one call every two
+seconds, with no ceiling other than how many calls exist. On a busy
+organisation over 365 days that is an unbounded bill from one request.
+
+`dry_run` defaults to TRUE and genuinely short-circuits before any grading
+(`parallel_calls.py:4602`), returning the eligible count and a sample.
+Call it that way first and read the count.
+
+Tiered `billable`, not `write`: it reaches a paid model per record.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.days` | `integer` | no | How far back to look. default `30` |
+| `query.dry_run` | `boolean` | no | `true` counts and samples; `false` GRADES AND SPENDS. default `true` |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.backfillGrading();
+```
+
+---
+
+<a id="op-checkcampaignreadiness"></a>
+
+### `g8.api.dialer.checkCampaignReadiness(input?)`
+
+**Check Campaign Readiness**
+
+- HTTP: `GET /api/v1/dialer/parallel-calls/grading/campaign-readiness`
+- operationId: `check_campaign_readiness_dialer_parallel_calls_grading_campaign_readiness_get` (also callable as `g8.api.call("check_campaign_readiness_dialer_parallel_calls_grading_campaign_readiness_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. Whether this org has enough graded calls to report on.
+
+A precondition check for the grading dashboards. Reads only.
+
+**Input**: none.
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.checkCampaignReadiness();
+```
+
+---
+
+<a id="op-checkrecordingownership"></a>
+
+### `g8.api.dialer.checkRecordingOwnership(input)`
+
+**Check Recording Ownership**
+
+- HTTP: `GET /api/v1/dialer/parallel-calls/recordings/ownership`
+- operationId: `check_recording_ownership_dialer_parallel_calls_recordings_ownership_get` (also callable as `g8.api.call("check_recording_ownership_dialer_parallel_calls_recordings_ownership_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. Does THIS organisation own the recording at `url`?
+
+Answered from the call rows rather than the storage prefix, because
+recordings moved between organisations by the merge migration keep the
+SOURCE org's prefix while belonging to the target. Fail-closed: anything
+that goes wrong answers "not owned".
+
+The organisation asked about is always the key's own - it is not a
+parameter, so this cannot be used to probe another tenant's storage.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.url` | `string` | yes | Stored recording URL. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.checkRecordingOwnership({ query: { url: "https://example.com" } });
+```
+
+---
+
+<a id="op-clearsdrtargets"></a>
+
+### `g8.api.dialer.clearSdrTargets(input)`
+
+**Clear Sdr Targets**
+
+- HTTP: `DELETE /api/v1/dialer/parallel-calls/targets/sdr`
+- operationId: `clear_sdr_targets_dialer_parallel_calls_targets_sdr_delete` (also callable as `g8.api.call("clear_sdr_targets_dialer_parallel_calls_targets_sdr_delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Removes one rep's override; they fall back to the org goal.
+
+Self-gated on the EXISTING `voice:write` scope rather than minting a
+`voice:delete` for two routes - `action_for()` maps DELETE to a `delete`
+action unconditionally otherwise, and a new scope strands every key minted
+before it. Same choice `DELETE /voice/agents/{agent_id}` already made.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.sdr_email` | `string` | yes | The rep whose override is removed. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.clearSdrTargets({ query: { sdr_email: "jane@acme.com" } });
+```
+
+---
+
+<a id="op-createpausedparallelsession"></a>
+
+### `g8.api.dialer.createPausedParallelSession(input)`
+
+**Create Paused Parallel Session**
+
+- HTTP: `POST /api/v1/dialer/parallel-calls/sessions`
+- operationId: `create_paused_parallel_session_dialer_parallel_calls_sessions_post` (also callable as `g8.api.call("create_paused_parallel_session_dialer_parallel_calls_sessions_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Creates a PAUSED parallel session.
+
+The session exists and is configured, and not one telephone rings. This is
+the safe half of the pair - `POST /dialer/parallel-calls/sessions/start`
+is the half that dials.
+
+Published as a POST to the collection precisely because that is what a
+customer will reach for first, and the harmless operation should be the
+one they land on by guessing.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `CreatePausedSessionRequest` | yes | Request body; fields below. |
+
+Body fields (`CreatePausedSessionRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.from_phone` | `string` | yes |  |
+| `body.user_id` | `string` | yes |  |
+| `body.campaign_builder_campaign_id` | `string \| null` | no |  |
+| `body.campaign_id` | `string \| null` | no |  |
+| `body.dialing_mode` | `"power" \| "parallel" \| null` | no |  |
+| `body.name` | `string \| null` | no |  |
+| `body.parallel_count` | `integer \| null` | no |  |
+| `body.session_id` | `string \| null` | no |  |
+| `body.session_metadata` | `SessionMetadataIn \| null` | no |  |
+| `body.user_email` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.createPausedParallelSession({ body: { from_phone: "+15555550100", user_id: "id" } });
+```
+
+---
+
+<a id="op-createsessiondraft"></a>
+
+### `g8.api.dialer.createSessionDraft(input)`
+
+**Create Session Draft**
+
+- HTTP: `POST /api/v1/dialer/sessions/draft`
+- operationId: `create_session_draft_dialer_sessions_draft_post` (also callable as `g8.api.call("create_session_draft_dialer_sessions_draft_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Creates a DRAFT session and dials no one.
+
+The safe first step: it resolves the list or sequence, snapshots the
+filter, and stops. `POST /dialer/sessions/{id}/next-batch` is what turns a
+draft into ringing telephones.
+
+Not idempotent in the way it looks: voice REUSES a live session for the
+same list rather than creating a second one, so calling this twice does
+not double-dial - it returns the existing session. `from_phone` is
+optional here and enforced at dial time.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `SessionDraftRequest` | yes | Request body; fields below. |
+
+Body fields (`SessionDraftRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.user_id` | `string` | yes |  |
+| `body.agent_id` | `string \| null` | no |  |
+| `body.campaign_builder_campaign_id` | `string \| null` | no |  |
+| `body.campaign_id` | `string \| null` | no |  |
+| `body.dialing_mode` | `"power" \| "parallel" \| null` | no |  |
+| `body.entity_type` | `string \| null` | no |  |
+| `body.filter_spec` | `FilterSpec \| null` | no |  |
+| `body.from_phone` | `string \| null` | no |  |
+| `body.list_id` | `string \| null` | no |  |
+| `body.list_title` | `string \| null` | no |  |
+| `body.name` | `string \| null` | no |  |
+| `body.order_spec` | `OrderSpec \| null` | no |  |
+| `body.parallel_count` | `integer` | no | default `1` |
+| `body.selected_event_type_id` | `integer \| null` | no |  |
+| `body.sequence_id` | `string \| null` | no |  |
+| `body.sequence_step_order` | `integer \| null` | no |  |
+| `body.user_email` | `string \| null` | no |  |
+| `body.user_timezone` | `string \| null` | no | default `"America/New_York"` |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.createSessionDraft({ body: { user_id: "id" } });
+```
+
+---
+
+<a id="op-declinetransfer"></a>
+
+### `g8.api.dialer.declineTransfer(input)`
+
+**Decline Transfer**
+
+- HTTP: `POST /api/v1/dialer/transfer/{call_id}/decline`
+- operationId: `decline_transfer_dialer_transfer__call_id__decline_post` (also callable as `g8.api.call("decline_transfer_dialer_transfer__call_id__decline_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+AFFECTS A LIVE CALL WITH A PERSON ON IT, but places no new call.
+
+The colleague passes on the transfer. The CALLER - a real human - STAYS ON
+HOLD until the ring times out; declining does not hang up on them and does
+not tell them anything. Worth knowing before wiring this to an
+auto-decline rule.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.call_id` | `string` | yes | Call being transferred. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.declineTransfer({ path: { call_id: "id" } });
+```
+
+---
+
+<a id="op-deletecustomdisposition"></a>
+
+### `g8.api.dialer.deleteCustomDisposition(input)`
+
+**Delete Custom Disposition**
+
+- HTTP: `DELETE /api/v1/dialer/dispositions/{disposition_id}`
+- operationId: `delete_custom_disposition_dialer_dispositions__disposition_id__delete` (also callable as `g8.api.call("delete_custom_disposition_dialer_dispositions__disposition_id__delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Deletes one of the organisation's CUSTOM dispositions.
+
+The gap `voice_router` named as deliberately absent - "voice's own
+dispositions router never exposed a delete endpoint" - which is no longer
+true: it does, and this publishes it.
+
+REFUSED WITH 409 IF ANY CALL IS ALREADY DISPOSITIONED WITH IT. So this
+only ever removes an unused value - history cannot be rewritten by it, and
+a 409 means "this one is in use", not "try again".
+
+The organisation is carried in a HEADER, not the path, and voice resolves
+the row with it (`_load_disposition_for_org`). It is the key's own org, so
+one tenant cannot delete another's vocabulary by guessing an id.
+
+ADMIN ONLY, and that gate is declared HERE. Voice declares
+`require_org_admin()` on its own route, and for a server-to-server call
+that dependency finds no bearer token and - with
+`ENFORCE_VOICE_PERMISSIONS` off, which is everywhere today - ALLOWS the
+request. `require_org_admin` from `developer_api.dependencies.admin` is
+the one actually protecting this, and it refuses machine keys outright:
+deleting shared org vocabulary needs a personal key held by an Admin or
+Owner.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.disposition_id` | `integer` | yes | Custom disposition id. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.deleteCustomDisposition({ path: { disposition_id: 123 } });
+```
+
+---
+
+<a id="op-dialnextbatch"></a>
+
+### `g8.api.dialer.dialNextBatch(input)`
+
+**Dial Next Batch**
+
+- HTTP: `POST /api/v1/dialer/sessions/{session_id}/next-batch`
+- operationId: `dial_next_batch_dialer_sessions__session_id__next_batch_post` (also callable as `g8.api.call("dial_next_batch_dialer_sessions__session_id__next_batch_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: `voice:run`
+
+*** CALLS REAL PEOPLE. *** This is the operation that dials.
+
+Voice's own words for this handler are "the one-and-only dial path for
+BE-owned queue sessions" (`dialer_sessions.py:2272`). It picks the next
+contacts off the queue and places outbound calls to them, transitioning
+the session DRAFT -> ACTIVE or PAUSED -> ACTIVE on the way.
+
+`parallel_count` is HOW MANY PEOPLE ARE CALLED AT ONCE. Sending it with a
+session configured for one is how a power-dial becomes a parallel dial.
+
+Each attempt reserves credits and each connected minute charges more, so
+this both spends money and reaches strangers. It is tiered `external`
+rather than `write` for exactly that reason: "dial the next twenty people"
+must not be grantable by the same scope as "rename a session".
+
+`filter_spec` sent here CHANGES WHO IS ELIGIBLE before the batch is
+picked. It is not a display filter.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session to dial. |
+| `body` | `NextBatchRequest` | no | Request body; fields below. |
+
+Body fields (`NextBatchRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.agent_id` | `string \| null` | no |  |
+| `body.campaign_builder_campaign_id` | `string \| null` | no |  |
+| `body.campaign_id` | `string \| null` | no |  |
+| `body.dialing_mode` | `"power" \| "parallel" \| null` | no |  |
+| `body.entity_type` | `string \| null` | no |  |
+| `body.filter_spec` | `FilterSpec \| null` | no |  |
+| `body.force_next_contact` | `ForceNextContact \| null` | no |  |
+| `body.from_phone` | `string \| null` | no |  |
+| `body.from_phone_scope` | `string \| null` | no |  |
+| `body.order_spec` | `OrderSpec \| null` | no |  |
+| `body.parallel_count` | `integer \| null` | no |  |
+| `body.previous_batch_id` | `string \| null` | no |  |
+| `body.resume_intent` | `boolean` | no | default `false` |
+| `body.user_email` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.dialNextBatch({ path: { session_id: "id" } });
+```
+
+---
+
+<a id="op-dropparallelvoicemail"></a>
+
+### `g8.api.dialer.dropParallelVoicemail(input)`
+
+**Drop Parallel Voicemail**
+
+- HTTP: `POST /api/v1/dialer/parallel-calls/calls/{livekit_room_name}/drop-voicemail`
+- operationId: `drop_parallel_voicemail_dialer_parallel_calls_calls__livekit_room_name__drop_voicemail_post` (also callable as `g8.api.call("drop_parallel_voicemail_dialer_parallel_calls_calls__livekit_room_name__drop_voicemail_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: `voice:run`
+
+*** REACHES A REAL PERSON. *** Leaves a voicemail and hangs up.
+
+The script is played in the rep's cloned voice and the call is closed with
+disposition `voicemail`. The person hears it. There is no undo.
+
+The command is queued for the agent on the call (a 120-second window), so
+a 200 means "accepted", not "already played". Tiered `external`.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.livekit_room_name` | `string` | yes | Room name of the live call. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.dropParallelVoicemail({ path: { livekit_room_name: "Example" } });
+```
+
+---
+
+<a id="op-dropsessionvoicemail"></a>
+
+### `g8.api.dialer.dropSessionVoicemail(input)`
+
+**Drop Session Voicemail**
+
+- HTTP: `POST /api/v1/dialer/sessions/calls/drop-voicemail`
+- operationId: `drop_session_voicemail_dialer_sessions_calls_drop_voicemail_post` (also callable as `g8.api.call("drop_session_voicemail_dialer_sessions_calls_drop_voicemail_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: `voice:run`
+
+*** REACHES A REAL PERSON. *** Leaves a voicemail on their phone.
+
+The recording is played in the rep's CLONED VOICE and the call is then
+hung up with disposition `voicemail`. The person hears it; there is no
+undo, and a wrong `call_id` leaves the message on the wrong stranger's
+phone.
+
+Tiered `external`, not `write`: it reaches a human outside graph8.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `VoicemailDropRequest` | yes | Request body; fields below. |
+
+Body fields (`VoicemailDropRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.call_id` | `string` | yes |  |
+| `body.session_id` | `string` | yes |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.dropSessionVoicemail({ body: { call_id: "id", session_id: "id" } });
+```
+
+---
+
+<a id="op-hangupparallelcall"></a>
+
+### `g8.api.dialer.hangupParallelCall(input)`
+
+**Hangup Parallel Call**
+
+- HTTP: `POST /api/v1/dialer/parallel-calls/calls/hangup`
+- operationId: `hangup_parallel_call_dialer_parallel_calls_calls_hangup_post` (also callable as `g8.api.call("hangup_parallel_call_dialer_parallel_calls_calls_hangup_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY NEW. Ends one leg of a parallel session.
+
+The other legs keep ringing. Gated on `voice:dialer:control`, the same
+permission voice declares - re-declared here because voice's own gate does
+not run for a server-to-server call.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `HangupCallRequest` | yes | Request body; fields below. |
+
+Body fields (`HangupCallRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.call_id` | `string` | yes |  |
+| `body.session_id` | `string` | yes |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.hangupParallelCall({ body: { call_id: "id", session_id: "id" } });
+```
+
+---
+
+<a id="op-hangupsessioncall"></a>
+
+### `g8.api.dialer.hangupSessionCall(input)`
+
+**Hangup Session Call**
+
+- HTTP: `POST /api/v1/dialer/sessions/calls/hangup`
+- operationId: `hangup_session_call_dialer_sessions_calls_hangup_post` (also callable as `g8.api.call("hangup_session_call_dialer_sessions_calls_hangup_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY NEW. Ends a call that is already up.
+
+This is the STOP button, not a dial. It gates on `voice:dialer:control`
+rather than the create permission on purpose: hanging up is the action you
+want an operator to be able to take without also being able to start a
+session.
+
+The completion record is written by Twilio's status webhook afterwards, so
+the disposition and duration appear a moment later, not in this response.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `CallControlRequest` | yes | Request body; fields below. |
+
+Body fields (`CallControlRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.call_id` | `string` | yes |  |
+| `body.session_id` | `string` | yes |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.hangupSessionCall({ body: { call_id: "id", session_id: "id" } });
+```
+
+---
+
+<a id="op-listcontactidsbydisposition"></a>
+
+### `g8.api.dialer.listContactIdsByDisposition(input)`
+
+**List Contact Ids By Disposition**
+
+- HTTP: `GET /api/v1/dialer/parallel-calls/sessions/{session_id}/contact-ids-by-disposition`
+- operationId: `list_contact_ids_by_disposition_dialer_parallel_calls_sessions__session_id__contact_ids_by_disposition_get` (also callable as `g8.api.call("list_contact_ids_by_disposition_dialer_parallel_calls_sessions__session_id__contact_ids_by_disposition_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. Which contacts in a session ended at a given outcome.
+
+`latest` and `has_ever` differ for a redialed contact: a `no_answer` that
+later connected is in `has_ever` but not in `latest`. An unrecognised mode
+falls back to `latest` rather than erroring, matching voice.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session id. |
+| `query.disposition` | `string` | yes | Disposition, or several comma-separated. |
+| `query.mode` | `string` | no | `latest` = current outcome; `has_ever` = any attempt. default `"latest"` |
+
+**Returns** `ApiResponse_DialerListPayload_`: the envelope `{ data: DialerListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`DialerListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.listContactIdsByDisposition({ path: { session_id: "id" }, query: { disposition: "example" } });
+```
+
+---
+
+<a id="op-listtransferdepartments"></a>
+
+### `g8.api.dialer.listTransferDepartments(input?)`
+
+**List Transfer Departments**
+
+- HTTP: `GET /api/v1/dialer/transfer/departments`
+- operationId: `list_transfer_departments_dialer_transfer_departments_get` (also callable as `g8.api.call("list_transfer_departments_dialer_transfer_departments_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. Which departments can take a warm transfer right now.
+
+A LITERAL two-segment path beside `/transfer/{call_id}`, so it is declared
+BEFORE it - registered the other way round, `departments` would be read as
+a call id and this route would be unreachable. There is a test that
+`GET /dialer/transfer/<id>` still resolves to the parameter route.
+
+**Input**: none.
+
+**Returns** `ApiResponse_DialerListPayload_`: the envelope `{ data: DialerListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`DialerListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.listTransferDepartments();
+```
+
+---
+
+<a id="op-manualdial"></a>
+
+### `g8.api.dialer.manualDial(input)`
+
+**Manual Dial**
+
+- HTTP: `POST /api/v1/dialer/parallel-calls/manual-dial`
+- operationId: `manual_dial_dialer_parallel_calls_manual_dial_post` (also callable as `g8.api.call("manual_dial_dialer_parallel_calls_manual_dial_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: `voice:run`
+
+*** CALLS A REAL PERSON. *** Dials `to_phone` immediately.
+
+An arbitrary number, inside an existing PAUSED or COMPLETED session. If
+the session is ACTIVE voice refuses rather than dialing over a running
+campaign.
+
+The number does not have to belong to a contact: an unknown number is
+resolved to an existing contact by phone, or a new contact is created for
+it, so the call is attributable afterwards. That means this operation can
+CREATE A CONTACT RECORD as a side effect.
+
+Self-dialing is refused. Tiered `external`.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `ManualDialRequest` | yes | Request body; fields below. |
+
+Body fields (`ManualDialRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.from_phone` | `string` | yes |  |
+| `body.session_id` | `string` | yes |  |
+| `body.to_phone` | `string` | yes |  |
+| `body.user_id` | `string` | yes |  |
+| `body.company` | `string \| null` | no |  |
+| `body.contact_id` | `string \| null` | no |  |
+| `body.email` | `string \| null` | no |  |
+| `body.first_name` | `string \| null` | no |  |
+| `body.last_name` | `string \| null` | no |  |
+| `body.timezone` | `string \| null` | no | default `"America/New_York"` |
+| `body.user_email` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.manualDial({
+  body: {
+    from_phone: "+15555550100",
+    session_id: "id",
+    to_phone: "+15555550100",
+    user_id: "id",
+  },
+});
+```
+
+---
+
+<a id="op-markallmissedcallbacksseen"></a>
+
+### `g8.api.dialer.markAllMissedCallbacksSeen(input)`
+
+**Mark All Missed Callbacks Seen**
+
+- HTTP: `PATCH /api/v1/dialer/parallel-calls/missed-callbacks/seen-all`
+- operationId: `mark_all_missed_callbacks_seen_dialer_parallel_calls_missed_callbacks_seen_all_patch` (also callable as `g8.api.call("mark_all_missed_callbacks_seen_dialer_parallel_calls_missed_callbacks_seen_all_patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Clears the whole missed-callback badge for one rep.
+
+The app carries the organisation in the PATH here
+(`/missed-callbacks/seen-all/{org_id}`). That segment is NOT published: a
+caller must never be able to name the tenant it is clearing, so the org
+comes from the key and the path ends at `seen-all`.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `MissedCallbacksSeenAllRequest` | yes | Request body; fields below. |
+
+Body fields (`MissedCallbacksSeenAllRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.user_email` | `string` | yes |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.markAllMissedCallbacksSeen({ body: { user_email: "jane@acme.com" } });
+```
+
+---
+
+<a id="op-markgradingreviewed"></a>
+
+### `g8.api.dialer.markGradingReviewed(input)`
+
+**Mark Grading Reviewed**
+
+- HTTP: `POST /api/v1/dialer/parallel-calls/calls/{livekit_room_name}/grading/review`
+- operationId: `mark_grading_reviewed_dialer_parallel_calls_calls__livekit_room_name__grading_review_post` (also callable as `g8.api.call("mark_grading_reviewed_dialer_parallel_calls_calls__livekit_room_name__grading_review_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Marks a call's AI grading as reviewed by a human.
+
+An acknowledgement, not a re-grade: it changes no score and runs no model.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.livekit_room_name` | `string` | yes | Room name of the graded call. |
+| `query.sdr_email` | `string` | yes | The rep whose grading was reviewed. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.markGradingReviewed({
+  path: { livekit_room_name: "Example" },
+  query: { sdr_email: "jane@acme.com" },
+});
+```
+
+---
+
+<a id="op-markmissedcallbacksseen"></a>
+
+### `g8.api.dialer.markMissedCallbacksSeen(input)`
+
+**Mark Missed Callbacks Seen**
+
+- HTTP: `PATCH /api/v1/dialer/parallel-calls/missed-callbacks/seen`
+- operationId: `mark_missed_callbacks_seen_dialer_parallel_calls_missed_callbacks_seen_patch` (also callable as `g8.api.call("mark_missed_callbacks_seen_dialer_parallel_calls_missed_callbacks_seen_patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Marks specific missed callbacks as seen.
+
+Seen is not resolved: it clears the notification, it does not say anyone
+called back. `resolve` is the separate, meaningful one.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `MissedCallbacksSeenRequest` | yes | Request body; fields below. |
+
+Body fields (`MissedCallbacksSeenRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.ids` | `Array<integer>` | yes |  |
+| `body.user_email` | `string` | yes |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.markMissedCallbacksSeen({ body: { ids: [123], user_email: "jane@acme.com" } });
+```
+
+---
+
+<a id="op-mintsessionwsticket"></a>
+
+### `g8.api.dialer.mintSessionWsTicket(input)`
+
+**Mint Session Ws Ticket**
+
+- HTTP: `POST /api/v1/dialer/sessions/{session_id}/ws-ticket`
+- operationId: `mint_session_ws_ticket_dialer_sessions__session_id__ws_ticket_post` (also callable as `g8.api.call("mint_session_ws_ticket_dialer_sessions__session_id__ws_ticket_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Mints a one-shot ticket for the session event stream.
+
+The WebSocket itself is not part of this contract - a socket cannot be
+described as a request/response operation or generated into an SDK method.
+This mints the ticket that opens one, which IS an ordinary POST.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session to subscribe to. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.mintSessionWsTicket({ path: { session_id: "id" } });
+```
+
+---
+
+<a id="op-mintsoftphonetoken"></a>
+
+### `g8.api.dialer.mintSoftphoneToken(input)`
+
+**Mint Softphone Token**
+
+- HTTP: `GET /api/v1/dialer/sessions/token`
+- operationId: `mint_softphone_token_dialer_sessions_token_get` (also callable as `g8.api.call("mint_softphone_token_dialer_sessions_token_get", 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: `voice:run`
+
+CONTACTS NOBODY - but the RESPONSE CAN. Mints a softphone credential.
+
+Returns a short-lived (1 hour) Twilio access token carrying a VoiceGrant,
+for a browser running the Twilio Voice SDK. Whoever holds it can register a
+device and place and receive calls as `sdr_{user_id}_{org}` until it
+expires. TREAT THE RESPONSE AS A SECRET: it is a bearer credential, not a
+description of one.
+
+That is why this is the one GET on this router tiered `external` instead of
+`read`, and why it gates on `voice:calls:place` rather than a read
+permission - a read-only key must not be able to mint the ability to dial.
+
+`user_id` is REQUIRED here although voice defaults it. An organisation API
+key has no user of its own, and defaulting would mint a credential for an
+identity nobody named. The organisation half of the identity is always the
+key's own and cannot be supplied.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.user_id` | `string` | yes | The rep this softphone credential is for. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.mintSoftphoneToken({ query: { user_id: "id" } });
+```
+
+---
+
+<a id="op-minttranscriptwsticket"></a>
+
+### `g8.api.dialer.mintTranscriptWsTicket(input)`
+
+**Mint Transcript Ws Ticket**
+
+- HTTP: `POST /api/v1/dialer/sessions/calls/{call_id}/ws-ticket`
+- operationId: `mint_transcript_ws_ticket_dialer_sessions_calls__call_id__ws_ticket_post` (also callable as `g8.api.call("mint_transcript_ws_ticket_dialer_sessions_calls__call_id__ws_ticket_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Mints a one-shot ticket for the live transcript stream.
+
+Same shape as the session ticket, different stream: this one carries the
+words of a call as it happens.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.call_id` | `string` | yes | Call to stream the transcript of. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.mintTranscriptWsTicket({ path: { call_id: "id" } });
+```
+
+---
+
+<a id="op-mutecall"></a>
+
+### `g8.api.dialer.muteCall(input)`
+
+**Mute Call**
+
+- HTTP: `POST /api/v1/dialer/sessions/calls/mute`
+- operationId: `mute_call_dialer_sessions_calls_mute_post` (also callable as `g8.api.call("mute_call_dialer_sessions_calls_mute_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY NEW. Mutes the rep on a call already in progress.
+
+`muted` is explicit rather than a toggle, so a retried request is
+idempotent instead of un-muting someone mid-sentence.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.call_id` | `string` | yes | The live call to mute. |
+| `query.muted` | `boolean` | no | `true` mutes the rep, `false` unmutes. default `true` |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.muteCall({ query: { call_id: "id" } });
+```
+
+---
+
+<a id="op-prewarmvoicemails"></a>
+
+### `g8.api.dialer.prewarmVoicemails(input)`
+
+**Prewarm Voicemails**
+
+- HTTP: `POST /api/v1/dialer/sessions/prewarm-voicemails`
+- operationId: `prewarm_voicemails_dialer_sessions_prewarm_voicemails_post` (also callable as `g8.api.call("prewarm_voicemails_dialer_sessions_prewarm_voicemails_post", input)`)
+- Tier: `billable`: spends credits; the SDK never blindly retries it; confirm cost before bulk use
+- API-key scope: `voice:run`
+
+CONTACTS NOBODY - but it SPENDS. Synthesises voicemail audio in advance.
+
+Text-to-speech is generated per contact and cached so the audio is ready
+before a rep clicks Start Dialing. No phone rings and no one hears
+anything, but it is real generation work per contact, which is why it is
+tiered `billable` rather than a plain `write`.
+
+Returns immediately - the work is fired in the background. Duplicates are
+no-ops (Redis in-flight lock plus a per-contact cache). Voice caps the
+batch at 20 and so does this contract.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `PrewarmVoicemailsRequest` | yes | Request body; fields below. |
+
+Body fields (`PrewarmVoicemailsRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.contacts` | `Array<DialContact>` | yes | min items 1, max items 20 |
+| `body.agent_id` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.prewarmVoicemails({
+  body: { contacts: [{ contact_id: "id", to_phone: "+15555550100" }] },
+});
+```
+
+---
+
+<a id="op-readallsdrtargets"></a>
+
+### `g8.api.dialer.readAllSdrTargets(input?)`
+
+**Read All Sdr Targets**
+
+- HTTP: `GET /api/v1/dialer/parallel-calls/targets/all-sdrs`
+- operationId: `read_all_sdr_targets_dialer_parallel_calls_targets_all_sdrs_get` (also callable as `g8.api.call("read_all_sdr_targets_dialer_parallel_calls_targets_all_sdrs_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. Per-rep goals for everyone in the organisation.
+
+A two-segment LITERAL under `/targets`. Nothing registers
+`/parallel-calls/targets/{something}`, so it cannot be swallowed - and the
+shadowing test asserts that rather than trusting it.
+
+**Input**: none.
+
+**Returns** `ApiResponse_DialerListPayload_`: the envelope `{ data: DialerListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`DialerListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.readAllSdrTargets();
+```
+
+---
+
+<a id="op-readdialerpreferences"></a>
+
+### `g8.api.dialer.readDialerPreferences(input)`
+
+**Read Dialer Preferences**
+
+- HTTP: `GET /api/v1/dialer/settings/preferences/{user_email}`
+- operationId: `read_dialer_preferences_dialer_settings_preferences__user_email__get` (also callable as `g8.api.call("read_dialer_preferences_dialer_settings_preferences__user_email__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. One rep's dialer preferences.
+
+The app's path is `/preferences/{org_id}/{user_email}` and its handler
+reads whichever organisation the path names. The org segment is NOT
+published - it comes from the key - so this cannot read another tenant's
+configuration.
+
+Voice additionally refuses to read a rep other than the authenticated one
+(`dialer_settings.py:23-41`). An organisation API key is not a rep, so it
+supplies the rep the caller named: the tenant boundary holds, the
+rep-versus-rep boundary does not apply to an org credential.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.user_email` | `string` | yes | The rep whose preferences to read. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.readDialerPreferences({ path: { user_email: "jane@acme.com" } });
+```
+
+---
+
+<a id="op-readdialerreport"></a>
+
+### `g8.api.dialer.readDialerReport(input?)`
+
+**Read Dialer Report**
+
+- HTTP: `GET /api/v1/dialer/parallel-calls/analytics/dialer-report`
+- operationId: `read_dialer_report_dialer_parallel_calls_analytics_dialer_report_get` (also callable as `g8.api.call("read_dialer_report_dialer_parallel_calls_analytics_dialer_report_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. Dial counts, connect rates and outcomes.
+
+`aggregation` is closed to the app's own two values, so a typo is a 422
+naming them rather than a silent fallback to daily.
+
+`client_tz` decides where a day starts. Omitting it on a distributed team
+is the usual reason two people get different numbers for "yesterday".
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.session_id` | `string \| null` | no | Restrict to one session. |
+| `query.user_email` | `string \| null` | no | Restrict to one rep. |
+| `query.date_from` | `string \| null` | no | ISO date, inclusive. |
+| `query.date_to` | `string \| null` | no | ISO date, inclusive. |
+| `query.aggregation` | `"daily" \| "total"` | no | `daily` buckets; `total` collapses. default `"daily"` |
+| `query.client_tz` | `string \| null` | no | IANA zone the day boundaries are cut on. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.readDialerReport();
+```
+
+---
+
+<a id="op-readorgtargets"></a>
+
+### `g8.api.dialer.readOrgTargets(input?)`
+
+**Read Org Targets**
+
+- HTTP: `GET /api/v1/dialer/parallel-calls/targets`
+- operationId: `read_org_targets_dialer_parallel_calls_targets_get` (also callable as `g8.api.call("read_org_targets_dialer_parallel_calls_targets_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. The organisation's daily dial and meeting goals.
+
+**Input**: none.
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.readOrgTargets();
+```
+
+---
+
+<a id="op-readproviderreceipt"></a>
+
+### `g8.api.dialer.readProviderReceipt(input?)`
+
+**Read Provider Receipt**
+
+- HTTP: `GET /api/v1/dialer/sessions/assurance/provider-receipt`
+- operationId: `read_provider_receipt_dialer_sessions_assurance_provider_receipt_get` (also callable as `g8.api.call("read_provider_receipt_dialer_sessions_assurance_provider_receipt_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. The telephony provider's assurance receipt for this org.
+
+Declared BEFORE `/sessions/{session_id}/queue-stats` would be a concern if
+the two overlapped; they do not - `assurance/provider-receipt` and
+`{session_id}/queue-stats` differ in their second segment, so neither can
+swallow the other. The org is the key's own and is not a parameter.
+
+**Input**: none.
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.readProviderReceipt();
+```
+
+---
+
+<a id="op-readqueuestats"></a>
+
+### `g8.api.dialer.readQueueStats(input)`
+
+**Read Queue Stats**
+
+- HTTP: `GET /api/v1/dialer/sessions/{session_id}/queue-stats`
+- operationId: `read_queue_stats_dialer_sessions__session_id__queue_stats_get` (also callable as `g8.api.call("read_queue_stats_dialer_sessions__session_id__queue_stats_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. How much of the queue is left, and what has been worked.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session id. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.readQueueStats({ path: { session_id: "id" } });
+```
+
+---
+
+<a id="op-readsessiongrid"></a>
+
+### `g8.api.dialer.readSessionGrid(input)`
+
+**Read Session Grid**
+
+- HTTP: `POST /api/v1/dialer/sessions/{session_id}/grid`
+- operationId: `read_session_grid_dialer_sessions__session_id__grid_post` (also callable as `g8.api.call("read_session_grid_dialer_sessions__session_id__grid_post", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. Reads a page of the session's contact grid.
+
+A POST because the filter and sort specification is too large for a query
+string, not because it changes anything - it mutates nothing and dials
+nobody. Tiered `read` by an explicit rule for that reason, so a read-only
+key can page through a queue.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session id. |
+| `body` | `GridPageRequest` | no | Request body; fields below. |
+
+Body fields (`GridPageRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.filter_spec` | `FilterSpec \| null` | no |  |
+| `body.include_contact_data` | `boolean` | no | default `false` |
+| `body.limit` | `integer` | no | default `100` |
+| `body.offset` | `integer` | no | default `0` |
+| `body.order_spec` | `OrderSpec \| null` | no |  |
+| `body.sort_model` | `Array<Record<string, string>> \| null` | no |  |
+| `body.valid_phones_only` | `boolean` | no | default `false` |
+
+**Returns** `ApiResponse_DialerListPayload_`: the envelope `{ data: DialerListPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+`DialerListPayload` fields:
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `items` | `Array<unknown>` | no |  |
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.readSessionGrid({ path: { session_id: "id" } });
+```
+
+---
+
+<a id="op-readtransferstatus"></a>
+
+### `g8.api.dialer.readTransferStatus(input)`
+
+**Read Transfer Status**
+
+- HTTP: `GET /api/v1/dialer/transfer/{call_id}`
+- operationId: `read_transfer_status_dialer_transfer__call_id__get` (also callable as `g8.api.call("read_transfer_status_dialer_transfer__call_id__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `voice:read`
+
+CONTACTS NOBODY. Where a warm transfer has got to - ringing, taken, declined.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.call_id` | `string` | yes | Call being transferred. |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.readTransferStatus({ path: { call_id: "id" } });
+```
+
+---
+
+<a id="op-redialcontact"></a>
+
+### `g8.api.dialer.redialContact(input)`
+
+**Redial Contact**
+
+- HTTP: `POST /api/v1/dialer/parallel-calls/redial-contact`
+- operationId: `redial_contact_dialer_parallel_calls_redial_contact_post` (also callable as `g8.api.call("redial_contact_dialer_parallel_calls_redial_contact_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: `voice:run`
+
+*** CALLS A REAL PERSON AGAIN. *** Redials a contact already tried.
+
+Voice caps attempts per contact (`MAX_REDIAL_ATTEMPTS`) and refuses past
+it, which is the guard against a retry loop becoming harassment - so treat
+a 400 here as "stop", not as "retry".
+
+It runs the same credit preflight the first dial does and can fail with
+`insufficient_credits`, reserving the attempt fee plus connected minutes.
+Tiered `external`.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `RedialContactRequest` | yes | Request body; fields below. |
+
+Body fields (`RedialContactRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.contact_id` | `string` | yes |  |
+| `body.from_phone` | `string` | yes |  |
+| `body.session_id` | `string` | yes |  |
+| `body.user_id` | `string` | yes |  |
+| `body.campaign_builder_campaign_id` | `string \| null` | no |  |
+| `body.campaign_id` | `string \| null` | no |  |
+| `body.user_email` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.redialContact({
+  body: {
+    contact_id: "id",
+    from_phone: "+15555550100",
+    session_id: "id",
+    user_id: "id",
+  },
+});
+```
+
+---
+
+<a id="op-resolvemissedcallbacks"></a>
+
+### `g8.api.dialer.resolveMissedCallbacks(input)`
+
+**Resolve Missed Callbacks**
+
+- HTTP: `PATCH /api/v1/dialer/parallel-calls/missed-callbacks/resolve`
+- operationId: `resolve_missed_callbacks_dialer_parallel_calls_missed_callbacks_resolve_patch` (also callable as `g8.api.call("resolve_missed_callbacks_dialer_parallel_calls_missed_callbacks_resolve_patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Closes a missed callback.
+
+`resolution` is closed to `manual` (someone called them back) or `ignored`
+(a decision not to). The two are not interchangeable in reporting, which
+is why the field exists at all rather than a single "done" flag.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `MissedCallbacksResolveRequest` | yes | Request body; fields below. |
+
+Body fields (`MissedCallbacksResolveRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.ids` | `Array<integer>` | yes |  |
+| `body.user_email` | `string` | yes |  |
+| `body.resolution` | `"manual" \| "ignored"` | no | default `"manual"` |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.resolveMissedCallbacks({ body: { ids: [123], user_email: "jane@acme.com" } });
+```
+
+---
+
+<a id="op-setcalldisposition"></a>
+
+### `g8.api.dialer.setCallDisposition(input)`
+
+**Set Call Disposition**
+
+- HTTP: `PATCH /api/v1/dialer/parallel-calls/calls/{livekit_room_name}/disposition`
+- operationId: `set_call_disposition_dialer_parallel_calls_calls__livekit_room_name__disposition_patch` (also callable as `g8.api.call("set_call_disposition_dialer_parallel_calls_calls__livekit_room_name__disposition_patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Records how a finished call went.
+
+`disposition` is an open string rather than a closed enum because the
+vocabulary is the system set PLUS the org's own custom dispositions -
+closing it here would refuse a value the customer defined.
+`GET /voice/dispositions` lists what this organisation accepts.
+
+Setting `callback_at` schedules the follow-up; it does not place it.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.livekit_room_name` | `string` | yes | Room name of the call. |
+| `body` | `CallDispositionRequest` | yes | Request body; fields below. |
+
+Body fields (`CallDispositionRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.disposition` | `string` | yes |  |
+| `body.callback_at` | `string (date-time) \| null` | no |  |
+| `body.notes` | `string \| null` | no |  |
+| `body.sentiment` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.setCallDisposition({
+  path: { livekit_room_name: "Example" },
+  body: { disposition: "example" },
+});
+```
+
+---
+
+<a id="op-setdialerpreferences"></a>
+
+### `g8.api.dialer.setDialerPreferences(input)`
+
+**Set Dialer Preferences**
+
+- HTTP: `PUT /api/v1/dialer/settings/preferences`
+- operationId: `set_dialer_preferences_dialer_settings_preferences_put` (also callable as `g8.api.call("set_dialer_preferences_dialer_settings_preferences_put", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY DIRECTLY - but `call_dnc_contacts` decides WHO MAY BE CALLED.
+
+Setting it true lets the dialer call numbers on a do-not-call list. That is
+a COMPLIANCE decision, not a convenience toggle, and it applies to every
+subsequent dial for this rep.
+
+PATCH semantics despite the verb: only fields you send are changed, and
+omitted ones keep their stored value. The verb is the app's.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `DialerPreferencesRequest` | yes | Request body; fields below. |
+
+Body fields (`DialerPreferencesRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.user_email` | `string` | yes |  |
+| `body.auto_rotate_numbers` | `boolean \| null` | no |  |
+| `body.call_dnc_contacts` | `boolean \| null` | no |  |
+| `body.parallel_count` | `integer \| null` | no |  |
+| `body.skip_voicemails` | `boolean \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.setDialerPreferences({ body: { user_email: "jane@acme.com" } });
+```
+
+---
+
+<a id="op-setorgtargets"></a>
+
+### `g8.api.dialer.setOrgTargets(input)`
+
+**Set Org Targets**
+
+- HTTP: `PUT /api/v1/dialer/parallel-calls/targets`
+- operationId: `set_org_targets_dialer_parallel_calls_targets_put` (also callable as `g8.api.call("set_org_targets_dialer_parallel_calls_targets_put", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Sets the organisation's daily goals. Upserts.
+
+Voice takes these as QUERY parameters and applies its defaults (250 dials,
+3 meetings) to anything omitted, so a partial update SILENTLY RESETS the
+field you left out. That behaviour is preserved rather than papered over -
+but it is a body here, and the defaults are stated, so the reset is at
+least visible in the contract. Send both fields every time.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `OrgDialerTargetsRequest` | yes | Request body; fields below. |
+
+Body fields (`OrgDialerTargetsRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.daily_dials_target` | `integer` | no | default `250`, min 0 |
+| `body.daily_meetings_target` | `integer` | no | default `3`, min 0 |
+| `body.updated_by` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.setOrgTargets({ body: {} });
+```
+
+---
+
+<a id="op-setsdrtargets"></a>
+
+### `g8.api.dialer.setSdrTargets(input)`
+
+**Set Sdr Targets**
+
+- HTTP: `PUT /api/v1/dialer/parallel-calls/targets/sdr`
+- operationId: `set_sdr_targets_dialer_parallel_calls_targets_sdr_put` (also callable as `g8.api.call("set_sdr_targets_dialer_parallel_calls_targets_sdr_put", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Overrides one rep's daily goals.
+
+Both targets are REQUIRED here although voice would accept either -
+the org-level route's silent-reset behaviour is the reason, and requiring
+both makes a partial write impossible rather than merely documented.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `SdrDialerTargetsRequest` | yes | Request body; fields below. |
+
+Body fields (`SdrDialerTargetsRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.daily_dials_target` | `integer` | yes | min 0 |
+| `body.daily_meetings_target` | `integer` | yes | min 0 |
+| `body.sdr_email` | `string` | yes |  |
+| `body.updated_by` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.setSdrTargets({
+  body: {
+    daily_dials_target: 0,
+    daily_meetings_target: 0,
+    sdr_email: "jane@acme.com",
+  },
+});
+```
+
+---
+
+<a id="op-skipcontact"></a>
+
+### `g8.api.dialer.skipContact(input)`
+
+**Skip Contact**
+
+- HTTP: `POST /api/v1/dialer/sessions/{session_id}/calls/skip-contact`
+- operationId: `skip_contact_dialer_sessions__session_id__calls_skip_contact_post` (also callable as `g8.api.call("skip_contact_dialer_sessions__session_id__calls_skip_contact_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Marks a contact so the queue stops offering them.
+
+Queue bookkeeping. Reversible with `unskip-contact`, which is why this is
+an ordinary `write` and not a destructive tier.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session id. |
+| `body` | `SkipContactRequest` | yes | Request body; fields below. |
+
+Body fields (`SkipContactRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.contact_id` | `string` | yes |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.skipContact({ path: { session_id: "id" }, body: { contact_id: "id" } });
+```
+
+---
+
+<a id="op-startparallelsession"></a>
+
+### `g8.api.dialer.startParallelSession(input)`
+
+**Start Parallel Session**
+
+- HTTP: `POST /api/v1/dialer/parallel-calls/sessions/start`
+- operationId: `start_parallel_session_dialer_parallel_calls_sessions_start_post` (also callable as `g8.api.call("start_parallel_session_dialer_parallel_calls_sessions_start_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: `voice:run`
+
+*** CALLS REAL PEOPLE. *** Dials every contact in the body, at once.
+
+One request can ring a lot of telephones. The only ceiling is voice's
+per-org `MAX_LIMIT_OF_CALLS_PER_ORG_ID`; this contract does not cap
+`contacts` itself, because a cap here that disagreed with voice's would
+reject batches voice would have accepted.
+
+Contacts whose number cannot be parsed are SKIPPED, not rejected - the
+batch proceeds without them and the response names who was dropped. Read
+it; do not assume every contact you sent was dialed.
+
+Attempts reserve credits and connected minutes charge more. Tiered
+`external`: this reaches strangers on the customer's behalf.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `StartParallelSessionRequest` | yes | Request body; fields below. |
+
+Body fields (`StartParallelSessionRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.contacts` | `Array<DialContact>` | yes |  |
+| `body.from_phone` | `string` | yes |  |
+| `body.user_id` | `string` | yes |  |
+| `body.campaign_builder_campaign_id` | `string \| null` | no |  |
+| `body.campaign_id` | `string \| null` | no |  |
+| `body.name` | `string \| null` | no |  |
+| `body.session_id` | `string \| null` | no |  |
+| `body.session_metadata` | `SessionMetadataIn \| null` | no |  |
+| `body.user_email` | `string \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `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.dialer.startParallelSession({
+  body: {
+    contacts: [{ contact_id: "id", to_phone: "+15555550100" }],
+    from_phone: "+15555550100",
+    user_id: "id",
+  },
+});
+```
+
+---
+
+<a id="op-unresolvemissedcallbacks"></a>
+
+### `g8.api.dialer.unresolveMissedCallbacks(input)`
+
+**Unresolve Missed Callbacks**
+
+- HTTP: `PATCH /api/v1/dialer/parallel-calls/missed-callbacks/unresolve`
+- operationId: `unresolve_missed_callbacks_dialer_parallel_calls_missed_callbacks_unresolve_patch` (also callable as `g8.api.call("unresolve_missed_callbacks_dialer_parallel_calls_missed_callbacks_unresolve_patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Reopens a missed callback closed by mistake.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `MissedCallbacksUnresolveRequest` | yes | Request body; fields below. |
+
+Body fields (`MissedCallbacksUnresolveRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.ids` | `Array<integer>` | yes |  |
+| `body.user_email` | `string` | yes |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.unresolveMissedCallbacks({ body: { ids: [123], user_email: "jane@acme.com" } });
+```
+
+---
+
+<a id="op-unskipcontact"></a>
+
+### `g8.api.dialer.unskipContact(input)`
+
+**Unskip Contact**
+
+- HTTP: `POST /api/v1/dialer/sessions/{session_id}/calls/unskip-contact`
+- operationId: `unskip_contact_dialer_sessions__session_id__calls_unskip_contact_post` (also callable as `g8.api.call("unskip_contact_dialer_sessions__session_id__calls_unskip_contact_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Puts a skipped contact back in the queue.
+
+It does NOT call them - it only makes them eligible again, so the next
+`next-batch` may.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session id. |
+| `body` | `SkipContactRequest` | yes | Request body; fields below. |
+
+Body fields (`SkipContactRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.contact_id` | `string` | yes |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.unskipContact({ path: { session_id: "id" }, body: { contact_id: "id" } });
+```
+
+---
+
+<a id="op-updateredialstate"></a>
+
+### `g8.api.dialer.updateRedialState(input)`
+
+**Update Redial State**
+
+- HTTP: `PATCH /api/v1/dialer/parallel-calls/sessions/{session_id}/redial-state`
+- operationId: `update_redial_state_dialer_parallel_calls_sessions__session_id__redial_state_patch` (also callable as `g8.api.call("update_redial_state_dialer_parallel_calls_sessions__session_id__redial_state_patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Records how far a bulk redial sweep has got.
+
+Bookkeeping so a sweep can resume where it stopped. `reset: true` clears
+it, which makes the NEXT sweep start from the beginning - it does not
+itself redial anyone.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session id. |
+| `body` | `UpdateRedialStateRequest` | yes | Request body; fields below. |
+
+Body fields (`UpdateRedialStateRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.redial_state` | `RedialState \| null` | no |  |
+| `body.reset` | `boolean` | no | default `false` |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.updateRedialState({ path: { session_id: "id" }, body: {} });
+```
+
+---
+
+<a id="op-updatesessionbookingeventtype"></a>
+
+### `g8.api.dialer.updateSessionBookingEventType(input)`
+
+**Update Session Booking Event Type**
+
+- HTTP: `PATCH /api/v1/dialer/sessions/{session_id}/booking-event-type`
+- operationId: `update_session_booking_event_type_dialer_sessions__session_id__booking_event_type_patch` (also callable as `g8.api.call("update_session_booking_event_type_dialer_sessions__session_id__booking_event_type_patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Sets which meeting type a booking on this session creates.
+
+Null clears the selection and falls back to the org default.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session id. |
+| `body` | `BookingEventTypePatchRequest` | yes | Request body; fields below. |
+
+Body fields (`BookingEventTypePatchRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.selected_event_type_id` | `integer \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.updateSessionBookingEventType({ path: { session_id: "id" }, body: {} });
+```
+
+---
+
+<a id="op-updatesessionfilter"></a>
+
+### `g8.api.dialer.updateSessionFilter(input)`
+
+**Update Session Filter**
+
+- HTTP: `PATCH /api/v1/dialer/sessions/{session_id}/filter-spec`
+- operationId: `update_session_filter_dialer_sessions__session_id__filter_spec_patch` (also callable as `g8.api.call("update_session_filter_dialer_sessions__session_id__filter_spec_patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY DIRECTLY - but it decides WHO IS CALLED NEXT.
+
+The filter is the queue's eligibility rule, not a view. Widening it on a
+running session adds people who will then be dialed by the next
+`next-batch`; narrowing it removes people mid-campaign. No call is placed
+by this request itself.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session id. |
+| `body` | `FilterSpecPatchRequest` | yes | Request body; fields below. |
+
+Body fields (`FilterSpecPatchRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.filter_spec` | `FilterSpec \| null` | no |  |
+| `body.order_spec` | `OrderSpec \| null` | no |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.updateSessionFilter({ path: { session_id: "id" }, body: {} });
+```
+
+---
+
+<a id="op-updatesessionhiddenfields"></a>
+
+### `g8.api.dialer.updateSessionHiddenFields(input)`
+
+**Update Session Hidden Fields**
+
+- HTTP: `PATCH /api/v1/dialer/sessions/{session_id}/hidden-custom-fields`
+- operationId: `update_session_hidden_fields_dialer_sessions__session_id__hidden_custom_fields_patch` (also callable as `g8.api.call("update_session_hidden_fields_dialer_sessions__session_id__hidden_custom_fields_patch", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `voice:write`
+
+CONTACTS NOBODY. Hides columns in the rep's grid. Display only.
+
+PUT semantics: the list REPLACES whatever was hidden before, so send the
+whole set rather than the delta. Hiding a field does not remove the data.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.session_id` | `string` | yes | Session id. |
+| `body` | `HiddenCustomFieldsPatchRequest` | yes | Request body; fields below. |
+
+Body fields (`HiddenCustomFieldsPatchRequest`):
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body.hidden_custom_fields` | `Array<string>` | yes |  |
+
+**Returns** `ApiResponse_DialerPayload_`: the envelope `{ data: DialerPayload, ... }`. `g8.api` returns the envelope as-is, so read `result.data`.
+
+Other envelope fields: `pagination` (PaginationMeta).
+
+**Example**
+
+```ts
+const result = await g8.api.dialer.updateSessionHiddenFields({
+  path: { session_id: "id" },
+  body: { hidden_custom_fields: ["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-dialcontact"></a>
+
+### `DialContact`
+
+One person to call. `to_phone` is a REAL phone number of a REAL human. An unparseable number is SKIPPED rather than rejecting the batch, so read the response to learn who was actually dialed.
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `contact_id` | `string` | yes |  |
+| `to_phone` | `string` | yes |  |
+| `all_phones` | `Array<Record<string, unknown>> \| null` | no |  |
+| `company` | `string \| null` | no |  |
+| `default_region` | `string \| null` | no |  |
+| `dynamic_columns` | `Record<string, unknown> \| null` | no |  |
+| `email` | `string \| null` | no |  |
+| `first_name` | `string \| null` | no |  |
+| `is_redial` | `boolean \| null` | no | default `false` |
+| `last_name` | `string \| null` | no |  |
+| `original_call_id` | `string \| null` | no |  |
+| `phone_index` | `integer \| null` | no |  |
+| `redial_count` | `integer \| null` | no | default `0` |
+| `timezone` | `string` | no | default `"America/New_York"` |
+| `title` | `string \| null` | no |  |
+
+<a id="type-filterspec"></a>
+
+### `FilterSpec`
+
+Which contacts in the list are eligible to be dialed. Narrowing this on a RUNNING session changes who gets called next. It is not a display filter.
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `exclude_dispositions` | `Array<string>` | no |  |
+| `predicates` | `Array<FilterPredicate>` | no |  |
+| `search` | `string \| null` | no |  |
+
+<a id="type-forcenextcontact"></a>
+
+### `ForceNextContact`
+
+Jump one specific contact to the front of the next batch.
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `contact_id` | `string` | yes |  |
+| `phone_field` | `string` | yes |  |
+
+<a id="type-orderspec"></a>
+
+### `OrderSpec`
+
+The order the queue is worked in, and which phone field is tried first.
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `mode` | `"natural_skip_dialed" \| "dialed_first"` | no | default `"natural_skip_dialed"` |
+| `phone_priority` | `Array<string>` | no |  |
+| `sort_model` | `Array<Record<string, string>>` | no |  |
+
+<a id="type-redialstate"></a>
+
+### `RedialState`
+
+Where a bulk redial sweep got to, so it can resume.
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `filters_snapshot` | `Record<string, unknown>` | yes |  |
+| `started_at` | `string` | yes |  |
+| `last_contact_id` | `integer` | no | default `0` |
+| `processed_count` | `integer` | no | default `0` |
+
+<a id="type-sessionmetadatain"></a>
+
+### `SessionMetadataIn`
+
+Free-form session context. Open: voice grows this per release.
+
+Type: `Record<string, unknown>`.