@spekoai/sdk 0.4.3 → 0.5.2

package/dist/lib/types/index.d.ts

@@ -1,7 +1,10 @@
+import type { CallDirection, CallJoinCredentials, CallResource, CallStatus } from '../voice-contract.js';
 /** Options for creating a Speko client. */
 export interface SpekoClientOptions {
     /** API key for authentication. */
     apiKey: string;
+    /** Org-defined broker identity used by human-calling methods. */
+    brokerId?: string;
     /** Base URL of the Speko API. Defaults to https://api.speko.dev */
     baseUrl?: string;
     /** Alias for {@link SpekoClientOptions.baseUrl}. If both are set, `baseUrl` wins. */
@@ -89,6 +92,12 @@ export interface PipelineConstraints {
     };
 }
 export interface TranscribeOptions extends RoutingIntent {
+    /**
+     * Optional voice/session identifier forwarded as `x-session-id` for usage
+     * attribution. The value is carried out-of-band so request bodies and STT
+     * provider options stay provider-shaped.
+     */
+    sessionId?: string;
     /** MIME type of the audio body. Defaults to "audio/wav". */
     contentType?: string;
     constraints?: PipelineConstraints;
@@ -99,6 +108,10 @@ export interface TranscribeOptions extends RoutingIntent {
      * ElevenLabs Scribe → `biased_keywords`. Casing matters for proper nouns.
      */
     keywords?: readonly string[];
+    /** Provider-facing STT overrides. Routing continues to use the inherited language. */
+    sttOptions?: {
+        language?: string;
+    };
 }
 export interface TranscribeResult {
     text: string;
@@ -127,6 +140,12 @@ export type TranscribeStreamEvent = {
     code: string;
 };
 export interface SynthesizeOptions extends RoutingIntent {
+    /**
+     * Optional voice/session identifier forwarded as `x-session-id` for usage
+     * attribution. The value is carried out-of-band so request bodies and TTS
+     * provider options stay provider-shaped.
+     */
+    sessionId?: string;
     /** Optional voice override. Otherwise the SDK uses each provider's default. */
     voice?: string;
     /**
@@ -139,6 +158,20 @@ export interface SynthesizeOptions extends RoutingIntent {
      */
     model?: string;
     speed?: number;
+    /**
+     * Free-text speaking-style instruction (tone, pace, emotion) forwarded to the
+     * TTS model. Only instruction-capable models honor it (OpenAI
+     * `gpt-4o-mini-tts`, Hume Octave, `qwen3-tts-instruct-flash`); the router
+     * drops it for any other resolved model, so it's safe to always pass.
+     */
+    instructions?: string;
+    /**
+     * Normalize the text into spoken form before TTS — strip markdown/URLs, spell
+     * out numbers/currency/abbreviations. A deterministic safety net beneath the
+     * voice directive. The voice pipeline sets this; direct TTS callers default
+     * off and get literal text.
+     */
+    spokenForm?: boolean;
     constraints?: PipelineConstraints;
 }
 export interface SynthesizeResult {
@@ -224,6 +257,13 @@ export interface ChatMessage {
  * org-installed Speko app action such as Google Calendar or Slack.
  */
 export type ChatToolExecutionMode = 'inline' | 'webhook' | 'builtin' | 'integration';
+/**
+ * Spoken lead-in behavior before a server-executed tool runs. `auto` lets the
+ * gateway decide from the tool's recent execution durations; `always` forces a
+ * spoken lead-in (the gateway injects one when the model didn't produce any);
+ * `never` runs the tool silently.
+ */
+export type ChatToolPreToolSpeech = 'auto' | 'always' | 'never';
 /**
  * Source-of-execution config. Required when `executionMode` is
  * `webhook`, `builtin`, or `integration`. Mirrors the SpekoTool `source` shape inside
@@ -237,6 +277,15 @@ export type ChatToolSource = {
     /** Pointer into Speko's secrets store. Created via `POST /v1/agents/:id/tools` (which encrypts and stores the raw secret). */
     secretRef: string;
     headers?: Record<string, string>;
+    /**
+     * Outbound auth headers whose values are secret-referenced (resolved and
+     * injected by Speko at call time). The raw credential never leaves the
+     * server — only the `secretRef` pointer is exposed.
+     */
+    authHeaders?: Array<{
+        name: string;
+        secretRef: string;
+    }>;
     timeoutMs?: number;
     /** `async` returns `asyncAck` immediately while Speko dispatches the webhook in the background. */
     responseMode?: 'sync' | 'async';
@@ -269,6 +318,8 @@ export interface ChatTool {
     parameters: Record<string, unknown>;
     executionMode?: ChatToolExecutionMode;
     source?: ChatToolSource;
+    /** Spoken lead-in behavior before this tool executes. Defaults to `auto` for registered tools. */
+    preToolSpeech?: ChatToolPreToolSpeech;
 }
 /** Mirrors LiveKit's `ToolChoice` for parity with the agents framework. */
 export type ChatToolChoice = 'auto' | 'none' | 'required' | {
@@ -342,13 +393,15 @@ export type CompleteStreamEvent = {
     error: string;
     code: string;
 };
-export type RealtimeProvider = 'openai' | 'google' | 'xai' | 'inworld' | 'alibaba';
+export type RealtimeProvider = 'openai' | 'google' | 'xai';
 export interface RealtimeToolSpec {
     name: string;
     description: string;
     parameters: Record<string, unknown>;
 }
 export interface RealtimeConnectParams {
+    /** Persisted agent whose workspace webhook routes should receive lifecycle events. */
+    agentId?: string;
     provider: RealtimeProvider;
     model: string;
     voice?: string;
@@ -357,9 +410,13 @@ export interface RealtimeConnectParams {
     inputSampleRate?: 16000 | 24000;
     outputSampleRate?: 16000 | 24000;
     tools?: RealtimeToolSpec[];
+    /** Exact-match attributes used only for workspace webhook routing. Requires agentId. */
+    webhookTags?: Record<string, string>;
     metadata?: Record<string, unknown>;
     /** Max session duration in seconds. Server-capped at 1800 (30 min). */
     ttlSeconds?: number;
+    /** Reuse when retrying an ambiguous bootstrap timeout. Generated when omitted. */
+    idempotencyKey?: string;
 }
 /**
  * Event shape emitted by a `RealtimeSessionHandle`. Binary audio comes in
@@ -439,6 +496,52 @@ export interface VoiceDialParams {
     systemPrompt?: string;
     /** Optional first utterance. `null` is not accepted by phone dial; omit to use the agent default. */
     firstMessage?: string;
+    /**
+     * Call-time values for template variables in `systemPrompt` / `firstMessage`.
+     * Sending this key (even `{}`) — or dialing with an agent that declares
+     * variables in its registry — compiles both strings as Liquid templates at
+     * call-create time: `{{name}}` interpolation, `{% if %}` / `{% elsif %}`
+     * branching, `| default:` filters, and platform-provided `system.*` values
+     * (`system.now`, `system.caller_number`, `system.call_id`, …).
+     *
+     * Resolution per variable: this map → the agent registry's default → inline
+     * `| default:` → the request fails with 400 `MISSING_TEMPLATE_VARIABLES`
+     * listing every unresolved name. Keys under `system.` are rejected. Omit
+     * this field entirely to send both strings verbatim (no compilation).
+     *
+     * @example
+     * ```ts
+     * await speko.voice.dial({
+     *   to: '+12015551234',
+     *   agentId: 'ag_123',
+     *   systemPrompt:
+     *     'You are {{agent_name | default: "Ava"}} calling {{customer}}. ' +
+     *     '{% if plan == "premium" %}Offer the priority upgrade.{% endif %} ' +
+     *     'The current time is {{system.now}}.',
+     *   variables: { customer: 'Mr. Lee', plan: 'premium' },
+     * });
+     * ```
+     */
+    variables?: Record<string, string>;
+    /**
+     * Per-call values for TOOLS ONLY — e.g. a short-lived access token scoped to
+     * the person being called, or a per-tenant API base URL. Unlike `variables`
+     * these never enter the system prompt, the transcript, or the model's
+     * context; they are stored encrypted and released only to tool execution.
+     * Custom-code tools read `session.secrets.<name>`; webhook tools may
+     * reference `{{name}}` in their `url` and `headers`. Names must be
+     * identifiers (`[A-Za-z_][A-Za-z0-9_]*`); up to 32 entries, 6 chars–4 KB each.
+     *
+     * @example
+     * ```ts
+     * await speko.voice.dial({
+     *   to: '+12015551234',
+     *   agentId: 'ag_123',
+     *   toolSecrets: { base_url: 'https://acme.example.com', access_token: token },
+     * });
+     * ```
+     */
+    toolSecrets?: Record<string, string>;
     llm?: {
         temperature?: number;
         maxTokens?: number;
@@ -449,6 +552,60 @@ export interface VoiceDialParams {
     };
     sttOptions?: {
         keywords?: string[];
+        prompt?: string;
+        language?: string;
+    };
+    /** Server-side wall-clock cap in seconds. Values are clamped server-side to 30s-4h. */
+    maxDurationSeconds?: number;
+    /**
+     * Optional per-call turn-taking overrides. `greetFirst` defaults ON for
+     * outbound (worker-side, 2026-07-03): the greeting plays immediately while
+     * AMD classifies in the background. Pass false to hold the greeting for the
+     * AMD verdict.
+     */
+    turnHandling?: {
+        /** Local VAD for cascaded calls. Omit to use Silero. */
+        vad?: {
+            provider: 'silero' | 'ai-coustics';
+        };
+        /**
+         * Caller-leg input enhancement (ai-coustics). Omit for the platform default;
+         * `enabled: false` turns it off; `model` is plain Quail (default) or Quail Voice
+         * Focus (primary-speaker isolation, explicit opt-in).
+         */
+        noiseCancellation?: {
+            enabled: boolean;
+            model?: 'quail' | 'quail-voice-focus';
+        };
+        profile?: 'conversational' | 'ivr' | 'ivr_patient';
+        endpointing?: {
+            minDelay?: number;
+            maxDelay?: number;
+        };
+        interruption?: {
+            mode?: 'adaptive' | 'vad';
+            minDuration?: number;
+            minWords?: number;
+        };
+        turnDetection?: boolean | 'stt';
+        contextThreshold?: boolean;
+        greetFirst?: boolean;
+        /**
+         * Replaces the built-in prompt the answering-machine detector's classifier
+         * sees when deciding whether a human, an IVR menu or voicemail answered.
+         * Outbound only; max 2,000 characters.
+         */
+        amdPrompt?: string;
+        /**
+         * What happens when native detection identifies recordable voicemail. `hangup` ends the call at the verdict; `leave_message` waits
+         * for the greeting to finish, speaks `voicemailMessage` once, then hangs
+         * up; `agent_decides` (default) hands the verdict to the LLM and lets the
+         * prompt's own voicemail rules act. Unavailable mailboxes always end without
+         * a message. Does not apply to menus/screeners or enable disabled/carrier AMD.
+         */
+        onMachine?: 'hangup' | 'leave_message' | 'agent_decides';
+        /** Spoken once into the mailbox under `onMachine: 'leave_message'`. Renders the same `{{variables}}` as `firstMessage`. Max 2,000 characters. */
+        voicemailMessage?: string;
     };
     /** Optional per-call SIP routing hints. Carrier AMD requires trunk/provider support. */
     telephony?: {
@@ -458,8 +615,17 @@ export interface VoiceDialParams {
             timeoutSeconds?: number;
         };
     };
+    /** Exact-match attributes used only for workspace webhook routing. Requires agentId. */
+    webhookTags?: Record<string, string>;
     /** Free-form metadata round-tripped to your webhooks. */
     metadata?: Record<string, unknown>;
+    /**
+     * @deprecated The agent-initiated end_call tool is now always on; the server
+     * accepts this field for compat but ignores it.
+     */
+    endCall?: {
+        enabled: boolean;
+    };
 }
 export interface VoiceDialResult {
     sessionId: string;
@@ -470,6 +636,64 @@ export interface VoiceDialResult {
     to: string;
     from: string;
 }
+/**
+ * One turn from `GET /v1/sessions/:id/transcript` — the lightweight live
+ * transcript poll. Note the camelCase keys: this endpoint's serialization
+ * differs from the snake_case `CallTranscriptEntry` embedded in `CallDetail`.
+ */
+export interface SessionTranscriptEntry {
+    id: string;
+    index: number;
+    source: 'user' | 'agent' | 'system';
+    text: string;
+    startedAt: string;
+    endedAt: string | null;
+    provider: string | null;
+    model: string | null;
+    /** Per-stage latency legs (ms) — null on user/system turns. */
+    eouMs: number | null;
+    llmTtftMs: number | null;
+    ttsTtfbMs: number | null;
+    latencyStatus: 'partial' | 'complete' | 'interrupted' | 'error' | null;
+    conversationalLatencyMs: number | null;
+    /** Tool calls the agent made on this turn (empty when none). */
+    toolCalls: {
+        name: string;
+        args: string;
+    }[];
+}
+export interface SessionTranscript {
+    entries: SessionTranscriptEntry[];
+}
+/**
+ * One push from `sessions.stream()` (SSE under the hood, auto-reconnecting).
+ * `end` is always the final event; transport-level reconnects and server
+ * stream rotations are handled inside the SDK and never surface here.
+ */
+export type SessionStreamEvent = {
+    type: 'status';
+    status: string;
+    endedAt: string | null;
+} | {
+    type: 'transcript';
+    turn: SessionTranscriptEntry;
+} | {
+    type: 'event';
+    event: CallEvent;
+} | {
+    type: 'end';
+    reason: 'session_ended';
+};
+export interface SessionStreamOptions {
+    /**
+     * Resume position (`"<lastTurnIndex>:<lastEventCreatedAtMs>"`). Rarely
+     * needed — the iterator tracks it internally across reconnects; pass it
+     * only to resume a NEW iterator after your own process restarted.
+     */
+    cursor?: string;
+    /** Abort to stop streaming (the iterator returns). */
+    signal?: AbortSignal;
+}
 export type PhoneNumberDirection = 'inbound' | 'outbound' | 'both';
 export type PhoneNumberSource = 'managed' | 'sip_trunk';
 export type PhoneNumberSmsAssignmentStatus = 'FAILED_ASSIGNMENT' | 'PENDING_ASSIGNMENT' | 'ASSIGNED' | 'PENDING_UNASSIGNMENT' | 'FAILED_UNASSIGNMENT';
@@ -502,16 +726,34 @@ export interface PhoneNumberRow {
     smsCampaignId: string | null;
     smsAssignmentStatus: PhoneNumberSmsAssignmentStatus | null;
     smsAssignmentUpdatedAt: string | null;
+    telnyxMessagingProfileId: string | null;
+    smsMessagingProfileStatus: 'pending' | 'ready' | 'failed';
+    smsMessagingProfileUpdatedAt: string | null;
+    smsMessagingProfileError: string | null;
+    smsAutomationEnabled: boolean;
     /**
      * 1:1 link to a persisted agent. When set, inbound calls hydrate
      * pipeline config from the agent row instead of (or alongside) the
      * dispatch_metadata_template.
      */
     agentId: string | null;
+    /**
+     * Inbound destination when this number answers to a HUMAN rather than an
+     * agent — the org-defined broker whose softphone is rung. Mutually
+     * exclusive with `agentId`: assigning one clears the other, because a number
+     * routed to a broker is provisioned so that no agent joins ahead of them.
+     */
+    routeToBrokerId: string | null;
     setupStatus: PhoneNumberSetupStatus;
     nextChargeAt: string;
     lastChargedAt: string | null;
+    /** Effective billing-or-compliance suspension timestamp. */
     suspendedAt: string | null;
+    /** Billing-only suspension, retained independently from compliance review. */
+    billingSuspendedAt?: string | null;
+    /** Compliance-only suspension for Speko-managed numbers. */
+    complianceSuspendedAt?: string | null;
+    suspensionReason?: 'billing' | 'compliance' | null;
     createdAt: string;
     updatedAt: string;
 }
@@ -550,6 +792,15 @@ export interface PhoneNumberUpdateParams {
     label?: string | null;
     /** Pass `null` to unlink, a string to relink. */
     agentId?: string | null;
+    /**
+     * Route inbound calls on this number to a human broker's softphone instead of
+     * an agent — pass your org-defined broker id, or `null` to stop. Setting
+     * it clears `agentId`, and setting `agentId` clears it; sending both in one
+     * request is a validation error. Requires the human-calling feature.
+     */
+    routeToBrokerId?: string | null;
+    /** Owner/admin-only opt-in for inbound SMS agent replies on this number. */
+    smsAutomationEnabled?: boolean;
 }
 export interface AvailablePhoneNumber {
     e164: string;
@@ -597,24 +848,56 @@ export interface PhoneNumberKybAuthorizedRepresentative {
     email: string;
     phone?: string;
 }
+export interface PhoneNumberKybDeclaration {
+    businessName: string;
+    useCase: string;
+}
+export type PhoneNumberKybAttestor = {
+    kind: 'user';
+    userId: string;
+    name: string;
+    email: string;
+    organizationRole: string | null;
+} | {
+    kind: 'api_key';
+    apiKeyId: string;
+};
+export interface PhoneNumberKybAttestationContract {
+    version: string;
+    text: string;
+    termsVersion: string;
+    termsUrl: string;
+}
 export interface PhoneNumberKybDraftParams {
     businessProfile: PhoneNumberKybBusinessProfile;
     authorizedRepresentative: PhoneNumberKybAuthorizedRepresentative;
     attestationAccepted?: boolean;
 }
-export interface PhoneNumberKybSubmitParams {
+export type PhoneNumberKybSubmitParams = {
+    declaration: PhoneNumberKybDeclaration;
+    attestationAccepted: true;
+    attestationVersion: string;
+} | {
     businessProfile: PhoneNumberKybBusinessProfile;
     authorizedRepresentative: PhoneNumberKybAuthorizedRepresentative;
     attestationAccepted: true;
-}
+    attestationVersion?: string;
+};
 export interface PhoneNumberKybSubmission {
     id: string;
     organizationId: string;
     status: PhoneNumberKybSubmissionStatus;
     businessProfile: PhoneNumberKybBusinessProfile | null;
     authorizedRepresentative: PhoneNumberKybAuthorizedRepresentative | null;
+    declaration?: PhoneNumberKybDeclaration | null;
+    attestor?: PhoneNumberKybAttestor | null;
     attestationAccepted: boolean;
+    attestationVersion?: string | null;
+    attestationText?: string | null;
+    termsVersion?: string | null;
     attestedAt: string | null;
+    accessHoldAt?: string | null;
+    accessHoldReason?: 'rejected' | 'revoked' | null;
     submittedByUserId: string | null;
     submittedByEmail: string | null;
     submittedByApiKeyId: string | null;
@@ -632,6 +915,10 @@ export interface PhoneNumberKybSubmission {
 export interface PhoneNumberKybOverview {
     status: PhoneNumberKybStatus;
     submission: PhoneNumberKybSubmission | null;
+    declarationPrefill?: PhoneNumberKybDeclaration;
+    requiredAttestation?: PhoneNumberKybAttestationContract;
+    attestationRequired?: boolean;
+    complianceAccess?: 'enabled' | 'awaiting_attestation' | 'suspended';
     prefill: {
         businessProfile: PhoneNumberKybBusinessProfile;
         authorizedRepresentative: PhoneNumberKybAuthorizedRepresentative;
@@ -663,6 +950,19 @@ export interface AgentStackPreferences {
 export interface AgentSttOptions {
     /** Vocabulary keywords forwarded to whichever STT provider the router picks. */
     keywords?: string[];
+    /**
+     * Free-text transcription context (domain, names, expected phrases), max
+     * 2000 chars. Honored only by prompt-capable STT models (OpenAI
+     * gpt-4o-transcribe family, AssemblyAI Universal-3 Pro tiers).
+     */
+    prompt?: string;
+    /**
+     * STT stream-language override. A BCP-47-ish tag ('en', 'es-MX'), a
+     * provider keyword like Deepgram's 'multi', or 'auto' to let the provider
+     * detect the spoken language itself (Soniox auto-detects when hints are
+     * omitted). Never affects stack routing — that keeps the agent language.
+     */
+    language?: string;
 }
 /**
  * Built-in ambience clip ids supported by the hosted worker. Custom clip
@@ -670,7 +970,7 @@ export interface AgentSttOptions {
  * keeps the v1 API simple and lets the worker map straight to the
  * `BuiltinAudioClip` enum.
  */
-export type AgentAmbientClip = 'office-ambience' | 'keyboard-typing' | 'keyboard-typing2';
+export type AgentAmbientClip = 'office-ambience' | 'city-ambience' | 'forest-ambience' | 'crowded-room' | 'keyboard-typing' | 'keyboard-typing2';
 /**
  * Per-agent background audio. Today only ambient (continuous loop) is
  * supported. The ambience plays on a separate media track mixed
@@ -680,7 +980,14 @@ export type AgentAmbientClip = 'office-ambience' | 'keyboard-typing' | 'keyboard
 export interface AgentBackgroundAudio {
     ambient?: {
         clip: AgentAmbientClip;
-        /** Linear gain in [0, 1]. Defaults to 1.0 (clip's natural level). */
+        /**
+         * Linear gain in `[0, 16]`, defaulting to 1.0 — the clip's own recorded
+         * level, which is not the same as "full volume". The built-in clips are
+         * mastered roughly 30 dB apart, so the useful range differs per clip:
+         * `office-ambience` is very quiet (about -52 LUFS) and needs ~5-10 to sit
+         * audibly under speech, `city-ambience` is about right at 1, and
+         * `crowded-room` is loud enough that it distorts past ~1.6.
+         */
         volume?: number;
     };
 }
@@ -688,46 +995,312 @@ export interface AgentSpeechNormalization {
     pronunciationDictionary?: Record<string, string>;
     textReplacements?: Record<string, string>;
 }
+/**
+ * A caller-defined post-call extraction field. Only meaningful on the
+ * `postCall` webhook: the call-analysis pass fills each from the transcript per
+ * `description`, typed by `type`, and the values are delivered under the
+ * webhook payload's top-level `custom_data` object keyed by `name`. `options`
+ * is required for `enum` fields.
+ */
+export interface AgentExtractionField {
+    /**
+     * Stable key the value lands under in `custom_data`. Must be a valid
+     * identifier (`^[a-zA-Z_][a-zA-Z0-9_]*$`), up to 64 chars, unique per webhook.
+     */
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'enum';
+    /**
+     * Instruction the LLM uses to extract this field. 1 to 10,000 characters,
+     * and at most 40,000 characters combined across all fields on the webhook.
+     */
+    description: string;
+    /**
+     * Allowed values — required (and only valid) when `type` is `'enum'`.
+     * 1–50 options, each up to 120 characters.
+     */
+    options?: string[];
+}
+/**
+ * Outbound auth header input — `value` is the plaintext credential Speko
+ * encrypts at rest. Required on create; omit on update to keep the value
+ * already stored under this header's ref.
+ */
+export interface AgentWebhookAuthHeaderInput {
+    name: string;
+    value?: string;
+}
+/** Outbound auth header as returned by the API — value stays server-side. */
+export interface AgentWebhookAuthHeader {
+    name: string;
+    secretRef: string;
+}
 export interface AgentLifecycleWebhookCreate {
     url: string;
-    /** Deprecated. Lifecycle webhooks use the org-level signing secret from API keys. */
+    /**
+     * Optional per-webhook signing secret. When supplied, this endpoint signs
+     * with its own secret instead of the shared org-level secret from API keys.
+     */
     secret?: string;
     headers?: Record<string, string>;
+    /** Secret-referenced outbound auth headers (e.g. a Bearer token your endpoint requires). */
+    authHeaders?: AgentWebhookAuthHeaderInput[];
     timeoutMs?: number;
     responseMode?: 'sync' | 'async';
     asyncAck?: string;
+    /** Post-call data-extraction fields. Applies to the `postCall` webhook only. */
+    extractionFields?: AgentExtractionField[];
 }
 export interface AgentLifecycleWebhookUpdate {
     url: string;
-    /** Deprecated. Lifecycle webhooks use the org-level signing secret from API keys. */
+    /**
+     * Optional per-webhook signing secret. Supply to set/rotate a per-webhook
+     * secret; omit to keep the existing (or shared org-level) secret.
+     */
     secret?: string;
     headers?: Record<string, string>;
+    /** Secret-referenced outbound auth headers. Replaces the stored set; omit a `value` to keep it. */
+    authHeaders?: AgentWebhookAuthHeaderInput[];
     timeoutMs?: number;
     responseMode?: 'sync' | 'async';
     asyncAck?: string;
+    /** Post-call data-extraction fields. Applies to the `postCall` webhook only. */
+    extractionFields?: AgentExtractionField[];
 }
 export interface AgentLifecycleWebhookSerialized {
     url: string;
     secretRef: string;
     headers?: Record<string, string>;
+    /** Outbound auth-header pointers; values stay encrypted server-side. */
+    authHeaders?: AgentWebhookAuthHeader[];
     timeoutMs?: number;
     responseMode?: 'sync' | 'async';
     asyncAck?: string;
+    /** Post-call data-extraction fields. Present on the `postCall` webhook only. */
+    extractionFields?: AgentExtractionField[];
 }
 export interface AgentWebhooksSerialized {
     preCall?: AgentLifecycleWebhookSerialized;
     postCall?: AgentLifecycleWebhookSerialized;
     status?: AgentLifecycleWebhookSerialized;
+    /** Dedicated `call.analysis` webhook — LLM analysis results only. */
+    analysis?: AgentLifecycleWebhookSerialized;
+    /** Dedicated `call.recording` webhook — fires when the recording turns terminal. */
+    recording?: AgentLifecycleWebhookSerialized;
 }
 export interface AgentWebhooksCreate {
     preCall?: AgentLifecycleWebhookCreate;
     postCall?: AgentLifecycleWebhookCreate;
     status?: AgentLifecycleWebhookCreate;
+    /**
+     * Dedicated `call.analysis` webhook. Delivered once per call when the LLM
+     * analysis completes: summary, outcome, structured_data, and custom_data —
+     * without the transcript/cost/recording of the combined `call.report`.
+     */
+    analysis?: AgentLifecycleWebhookCreate;
+    /**
+     * Dedicated `call.recording` webhook. Delivered once per call when the
+     * recording reaches a terminal state — `ready` carries the presigned
+     * `recording_url` (7-day TTL), `failed` carries `recording_url: null`.
+     */
+    recording?: AgentLifecycleWebhookCreate;
 }
 export interface AgentWebhooksUpdate {
     preCall?: AgentLifecycleWebhookUpdate | null;
     postCall?: AgentLifecycleWebhookUpdate | null;
     status?: AgentLifecycleWebhookUpdate | null;
+    analysis?: AgentLifecycleWebhookUpdate | null;
+    recording?: AgentLifecycleWebhookUpdate | null;
+}
+/**
+ * Everything a workspace webhook endpoint can subscribe to.
+ *
+ * Two families, and they behave differently on the wire:
+ *
+ * **AI voice-session events** (`call.pre_call` … `call.recording`) describe one
+ * `voice_session` as it progresses, and carry a `session_id`.
+ *
+ * **Programmable-voice control events** (`call.initiated` … `call.hangup`) are
+ * the webhook projection of the human-calling event stream — the same events
+ * {@link CallControl.events} returns. A human call is not a `voice_session`, so
+ * there is no session id to correlate on: the payload carries `call_id`,
+ * `control_id` (null for call-scoped events that belong to no single leg),
+ * `event_id` and `occurred_at`, merged with the event's own payload, and
+ * `call_id` is the correlation key.
+ *
+ * Control events are delivered **once, without automatic retry**. Only
+ * `call.report`, `call.analysis` and `call.recording` are durable — for those, a
+ * failed delivery is re-attempted on a backoff. A control event that misses its
+ * endpoint is gone from the webhook feed; the call's own event history
+ * ({@link CallControl.events}) is the durable record, so reconcile from there
+ * rather than treating the webhook as a queue.
+ */
+export type WorkspaceWebhookEventType = 'call.pre_call' | 'call.status' | 'call.report' | 'call.analysis' | 'call.recording' | 'call.initiated' | 'call.ringing' | 'call.answered' | 'call.bridged' | 'call.hold' | 'call.unhold' | 'call.mute' | 'call.unmute' | 'call.dtmf.sent' | 'call.transfer.initiated' | 'call.transfer.completed' | 'call.transfer.failed' | 'call.leg.hangup' | 'call.hangup' | 'sms.received' | 'sms.accepted' | 'sms.sent' | 'sms.delivered' | 'sms.delivery_failed' | 'sms.submission_unknown' | 'sms.opted_out' | 'sms.opted_in';
+export type WebhookEventType = WorkspaceWebhookEventType | 'imessage.received' | 'imessage.reaction_received' | 'imessage.sent' | 'imessage.delivered' | 'imessage.delivery_failed';
+export type WebhookDeliveryStatus = 'pending' | 'delivering' | 'succeeded' | 'failed' | 'cancelled' | 'expired';
+export interface WebhookEndpointAuthHeaderInput {
+    name: string;
+    /** Write-only plaintext. The server encrypts it and never returns it. */
+    value: string;
+}
+export interface WebhookEndpointAuthHeaderUpdate {
+    name: string;
+    /** Supply to set or rotate; omit to retain the stored value for this header name. */
+    value?: string;
+}
+export interface WebhookEndpointInput {
+    name: string;
+    url: string;
+    events: WorkspaceWebhookEventType[];
+    /** Defaults to true. When false, agentIds must contain at least one agent. */
+    allAgents?: boolean;
+    agentIds?: string[];
+    filterTags?: Record<string, string>;
+    headers?: Record<string, string>;
+    authHeaders?: WebhookEndpointAuthHeaderInput[];
+    timeoutMs?: number;
+    signingSecretSource?: 'workspace' | 'custom';
+    /** Write-only. Required when signingSecretSource is custom. */
+    signingSecret?: string;
+    extractionFields?: AgentExtractionField[];
+    /** Include message text, or emit metadata-only SMS payloads. Defaults to full. */
+    contentMode?: 'full' | 'metadata_only';
+}
+export type WebhookEndpointUpdate = Partial<Omit<WebhookEndpointInput, 'authHeaders'>> & {
+    authHeaders?: WebhookEndpointAuthHeaderUpdate[];
+};
+export interface WebhookEndpoint {
+    id: string;
+    name: string;
+    url: string;
+    events: WorkspaceWebhookEventType[];
+    allAgents: boolean;
+    agentIds: string[];
+    filterTags: Record<string, string>;
+    headers: Record<string, string>;
+    authHeaders: Array<{
+        name: string;
+        configured: true;
+    }>;
+    timeoutMs: number;
+    signingSecretSource: 'workspace' | 'custom';
+    hasCustomSigningSecret: boolean;
+    extractionFields: AgentExtractionField[];
+    contentMode: 'full' | 'metadata_only';
+    legacyManaged: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface WebhookDeliveryListParams {
+    endpointId?: string;
+    event?: WebhookEventType;
+    agentId?: string;
+    status?: WebhookDeliveryStatus;
+    sessionId?: string;
+    eventId?: string;
+    from?: string;
+    to?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface WebhookDelivery {
+    id: string;
+    eventId: string;
+    endpointId: string;
+    endpointName: string;
+    endpointKind: 'workspace' | 'imessage';
+    endpointDeleted: boolean;
+    event: WebhookEventType;
+    sessionId: string | null;
+    agentId: string | null;
+    webhookTags: Record<string, string>;
+    status: WebhookDeliveryStatus;
+    attempts: number;
+    httpStatus: number | null;
+    error: string | null;
+    occurredAt: string;
+    expiresAt: string;
+    deliveredAt: string | null;
+    createdAt: string;
+    /** False for provider-retried iMessage subscriber deliveries. */
+    canRedeliver: boolean;
+}
+export interface WebhookDeliveryEndpointOption {
+    id: string;
+    name: string;
+    kind: 'workspace' | 'imessage';
+    deleted: boolean;
+}
+export interface WebhookDeliveryPage {
+    data: WebhookDelivery[];
+    nextCursor: string | null;
+    endpointOptions: WebhookDeliveryEndpointOption[];
+}
+export interface WebhookDeliveryAttempt {
+    id: string;
+    attemptNumber: number;
+    trigger: 'automatic' | 'manual';
+    requestUrl: string;
+    requestHeaders: Record<string, string>;
+    requestBody: Record<string, unknown>;
+    responseStatus: number | null;
+    responseBody: string | null;
+    responseTruncated: boolean;
+    durationMs: number;
+    error: string | null;
+    createdAt: string;
+}
+export interface WebhookDeliveryDetail extends Omit<WebhookDelivery, 'attempts'> {
+    attemptCount: number;
+    requestPayload: Record<string, unknown>;
+    attempts: WebhookDeliveryAttempt[];
+}
+/**
+ * One prompt-variable registry entry. `defaultValue` fills the variable when a
+ * session/dial call omits it (empty string = declared optional: renders blank
+ * and `{% if %}` branches false). Without a default the variable is required
+ * per call — omitting it fails session create with 400
+ * `MISSING_TEMPLATE_VARIABLES`. Names may not use the reserved `system.`
+ * namespace.
+ */
+export interface AgentPromptVariable {
+    name: string;
+    defaultValue?: string;
+    description?: string;
+}
+/** Turn-taking configuration for cascaded agents. Realtime agents ignore VAD. */
+export interface AgentTurnHandling {
+    /** Local VAD provider. Omit to use Silero. */
+    vad?: {
+        provider: 'silero' | 'ai-coustics';
+    };
+    /**
+     * Caller-leg input enhancement (ai-coustics). Omit for the platform default;
+     * `enabled: false` turns it off; `model` is plain Quail (default) or Quail Voice
+     * Focus (primary-speaker isolation, explicit opt-in).
+     */
+    noiseCancellation?: {
+        enabled: boolean;
+        model?: 'quail' | 'quail-voice-focus';
+    };
+    profile?: 'conversational' | 'ivr' | 'ivr_patient';
+    endpointing?: {
+        minDelay?: number;
+        maxDelay?: number;
+    };
+    interruption?: {
+        mode?: 'adaptive' | 'vad';
+        minDuration?: number;
+        minWords?: number;
+    };
+    turnDetection?: boolean | 'stt';
+    contextThreshold?: boolean;
+    textGate?: boolean;
+    turnDetector?: 'smart_turn' | 'speko_turn_v1';
+    dtmfToolDescription?: string;
+    amdPrompt?: string;
+    waitForCallee?: boolean;
+    onMachine?: 'hangup' | 'leave_message' | 'agent_decides';
+    voicemailMessage?: string;
 }
 export interface AgentRow {
     id: string;
@@ -741,7 +1314,17 @@ export interface AgentRow {
     sttOptions: AgentSttOptions | null;
     backgroundAudio: AgentBackgroundAudio | null;
     speechNormalization: AgentSpeechNormalization | null;
+    turnHandling: AgentTurnHandling | null;
+    /** @deprecated Use organization-owned `speko.webhooks` endpoints. */
     webhooks: AgentWebhooksSerialized | null;
+    /**
+     * Post-call extraction schema on the agent itself — no webhook required.
+     * Merged with `webhooks.postCall.extractionFields`; the agent-level
+     * definition wins on a name collision.
+     */
+    extractionFields: AgentExtractionField[];
+    /** Prompt-variable registry. Returned on single-agent reads; null = empty. */
+    promptVariables?: AgentPromptVariable[] | null;
     createdAt: string;
     updatedAt: string;
 }
@@ -755,10 +1338,30 @@ export interface AgentCreateParams {
     sttOptions?: AgentSttOptions;
     backgroundAudio?: AgentBackgroundAudio;
     speechNormalization?: AgentSpeechNormalization;
+    turnHandling?: AgentTurnHandling;
+    /** @deprecated Use `speko.webhooks.create()` after creating the agent. */
     webhooks?: AgentWebhooksCreate;
-}
-export type AgentUpdateParams = Partial<Omit<AgentCreateParams, 'webhooks'>> & {
+    /**
+     * Post-call extraction schema on the agent itself — no webhook required.
+     * Merged with `webhooks.postCall.extractionFields`; the agent-level
+     * definition wins on a name collision.
+     */
+    extractionFields?: AgentExtractionField[];
+    /** Declare the prompt's `{{variables}}` with per-agent defaults/descriptions. */
+    promptVariables?: AgentPromptVariable[];
+}
+export type AgentUpdateParams = Partial<Omit<AgentCreateParams, 'webhooks' | 'turnHandling'>> & {
+    /** Set to null to clear all stored turn-taking overrides. */
+    turnHandling?: AgentTurnHandling | null;
+    /** @deprecated Use `speko.webhooks.update()` for organization-owned endpoints. */
     webhooks?: AgentWebhooksUpdate | null;
+    /**
+     * Post-call extraction schema on the agent itself — no webhook required.
+     * Merged with `webhooks.postCall.extractionFields`; the agent-level
+     * definition wins on a name collision.
+     */
+    /** `null` clears the schema. */
+    extractionFields?: AgentExtractionField[] | null;
 };
 export interface CallTranscriptEntry {
     id: string;
@@ -770,6 +1373,11 @@ export interface CallTranscriptEntry {
     provider: string | null;
     model: string | null;
     metadata: Record<string, unknown>;
+    eou_ms?: number | null;
+    llm_ttft_ms?: number | null;
+    tts_ttfb_ms?: number | null;
+    latency_status?: 'partial' | 'complete' | 'interrupted' | 'error' | null;
+    conversational_latency_ms?: number | null;
 }
 export interface CallCostLine {
     provider: string;
@@ -778,12 +1386,26 @@ export interface CallCostLine {
     keySource: KeySource;
     costMicroUsd: string;
 }
+export interface CallReportWebhookDelivery {
+    endpointId: string;
+    deliveryId: string;
+    eventId: string;
+    delivered: boolean;
+    status: number | null;
+    error: string | null;
+    createdAt: string;
+}
 export interface CallReport {
     session_id: string;
     organization_id: string;
     summary: string;
     outcome: string;
     structured_data: Record<string, unknown>;
+    /**
+     * Caller-defined extraction values, keyed by field name — the same object the
+     * `call.report` webhook delivers. `{}` when the agent declares no fields.
+     */
+    custom_data: Record<string, unknown>;
     transcript: {
         entries: CallTranscriptEntry[];
     };
@@ -797,11 +1419,18 @@ export interface CallReport {
     analysis_model: string | null;
     analysis_error: string | null;
     analysis_completed_at: string | null;
+    /** @deprecated Aggregate retained through the current SDK major version. */
     post_call_webhook_status: 'not_configured' | 'pending' | 'delivered' | 'failed';
+    /** @deprecated Aggregate retained through the current SDK major version. */
     post_call_webhook_attempts: number;
+    /** @deprecated Aggregate retained through the current SDK major version. */
     post_call_webhook_next_retry_at: string | null;
+    /** @deprecated Aggregate retained through the current SDK major version. */
     post_call_webhook_delivered_at: string | null;
+    /** @deprecated Aggregate retained through the current SDK major version. */
     post_call_webhook_error: string | null;
+    /** Canonical per-endpoint results; singular post-call fields are deprecated aggregates. */
+    webhook_deliveries: CallReportWebhookDelivery[];
     created_at: string;
     updated_at: string;
 }
@@ -846,11 +1475,35 @@ export interface FinalizeCallReportResult {
     summary: string;
     outcome: string;
     cost_micro_usd: string;
+    /** @deprecated Aggregate retained through the current SDK major version. */
     webhook: unknown;
+    webhook_deliveries: CallReportWebhookDelivery[];
 }
 export interface CallRecording {
     url: string;
 }
+export interface WebJoinParams {
+    /** Display name other participants (and transcripts) see for the joiner. */
+    displayName?: string;
+}
+export interface WebJoinResult {
+    /** LiveKit access token for the live call's room. Mint at click time — short TTL. */
+    token: string;
+    /** Public LiveKit URL the browser connects to (pass both to `@spekoai/client`). */
+    url: string;
+    /** Participant identity minted for this join (unique per join). */
+    identity: string;
+    roomName: string;
+    /** ISO timestamp the token stops being accepted for NEW connections. */
+    expiresAt: string;
+}
+export interface EndCallResult {
+    ok: true;
+    /** `ending` when teardown was requested; `already_ended` when the call was over. */
+    status: 'ending' | 'already_ended';
+    /** ISO timestamp, present only with `already_ended`. */
+    ended_at?: string;
+}
 export interface CallEvent {
     id: string;
     session_id: string | null;
@@ -1002,6 +1655,44 @@ export interface AgentCallListPage {
 export interface AgentToolSourceInline {
     kind: 'inline';
 }
+/**
+ * HTTP verb for a webhook tool. Omitting it means `POST`, so a tool
+ * written before this field existed is unchanged.
+ *
+ * `GET` and `DELETE` send NO request body — not a `body` template and not
+ * the default envelope either. Pairing one with `body` is rejected with
+ * `422 WEBHOOK_TEMPLATE_INVALID` rather than silently dropping the body.
+ */
+export type AgentToolWebhookMethod = 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'GET';
+/**
+ * JSON body template for a webhook tool.
+ *
+ * Omit it and Speko sends its fixed envelope —
+ * `{tool, args, idempotency_key, session_id, tool_call_id}` — unchanged.
+ * Supply one and it REPLACES that envelope, so a tool can post the shape
+ * a third-party API actually wants.
+ *
+ * Every string leaf interpolates `{{name}}`: any session `variables` or
+ * `toolSecrets` entry, plus these reserved names —
+ *
+ * | Name                  | Substitutes                                          |
+ * | --------------------- | ---------------------------------------------------- |
+ * | `{{tool_name}}`       | the tool's name                                      |
+ * | `{{session_id}}`      | the session id                                       |
+ * | `{{tool_call_id}}`    | the model's tool-call id                             |
+ * | `{{idempotency_key}}` | `<session_id>:<tool_call_id>`                        |
+ * | `{{args.<name>}}`     | one argument, JSON type preserved                    |
+ * | `{{args}}`            | the whole arguments object — whole values only        |
+ *
+ * Reserved names win over a session value of the same name. `{{args}}`
+ * must be the ENTIRE value of a key; embedding it in a longer string is
+ * rejected at write time instead of being JSON-stringified into it.
+ *
+ * Limits: 8 KB serialized, 8 levels of nesting, and no `__proto__`,
+ * `constructor` or `prototype` key. A URL whose ORIGIN is templated may
+ * not carry a body template at all — see the tool-calling guide.
+ */
+export type AgentToolWebhookBody = Record<string, unknown> | unknown[];
 /**
  * Webhook source as sent to {@link AgentTools.create}. The plaintext
  * `secret` is encrypted server-side; the returned row carries
@@ -1013,6 +1704,12 @@ export interface AgentToolSourceWebhookCreate {
     /** Plaintext shared secret. Encrypted server-side at write time. */
     secret: string;
     headers?: Record<string, string>;
+    /** Secret-referenced outbound auth headers (e.g. a Bearer token your endpoint requires). */
+    authHeaders?: AgentWebhookAuthHeaderInput[];
+    /** HTTP verb. Omit for `POST`. `GET`/`DELETE` send no body and reject `body`. */
+    method?: AgentToolWebhookMethod;
+    /** JSON body template replacing the default envelope. See {@link AgentToolWebhookBody}. */
+    body?: AgentToolWebhookBody;
     timeoutMs?: number;
 }
 /**
@@ -1025,6 +1722,12 @@ export interface AgentToolSourceWebhookSerialized {
     /** Pointer into Speko's secrets store. */
     secretRef: string;
     headers?: Record<string, string>;
+    /** Outbound auth-header pointers; values stay encrypted server-side. */
+    authHeaders?: AgentWebhookAuthHeader[];
+    /** Absent means `POST`. */
+    method?: AgentToolWebhookMethod;
+    /** The stored body template. Configuration, not a secret — returned as saved. */
+    body?: AgentToolWebhookBody;
     timeoutMs?: number;
 }
 export interface AgentToolSourceBuiltin {
@@ -1056,6 +1759,12 @@ export interface AgentToolSourceWebhookUpdate {
     /** Plaintext shared secret. Omit to keep the existing stored secret; supply to rotate. */
     secret?: string;
     headers?: Record<string, string>;
+    /** Secret-referenced outbound auth headers. Replaces the stored set; omit a `value` to keep it. */
+    authHeaders?: AgentWebhookAuthHeaderInput[];
+    /** HTTP verb. Omit for `POST`. `GET`/`DELETE` send no body and reject `body`. */
+    method?: AgentToolWebhookMethod;
+    /** JSON body template replacing the default envelope. See {@link AgentToolWebhookBody}. */
+    body?: AgentToolWebhookBody;
     timeoutMs?: number;
 }
 export type AgentToolSourceCreate = AgentToolSourceInline | AgentToolSourceWebhookCreate | AgentToolSourceBuiltin | AgentToolSourceIntegration;
@@ -1068,6 +1777,8 @@ export interface AgentToolRow {
     description: string;
     parameters: Record<string, unknown>;
     source: AgentToolSourceSerialized;
+    /** Spoken lead-in behavior before this tool executes. */
+    preToolSpeech: ChatToolPreToolSpeech;
     createdAt: string;
     updatedAt: string;
 }
@@ -1076,11 +1787,14 @@ export interface AgentToolCreateParams {
     description: string;
     parameters: Record<string, unknown>;
     source: AgentToolSourceCreate;
+    /** Spoken lead-in behavior before the tool executes. Defaults to `auto`. */
+    preToolSpeech?: ChatToolPreToolSpeech;
 }
 export interface AgentToolUpdateParams {
     description?: string;
     parameters?: Record<string, unknown>;
     source?: AgentToolSourceUpdate;
+    preToolSpeech?: ChatToolPreToolSpeech;
 }
 export interface KnowledgeBaseRow {
     id: string;
@@ -1153,4 +1867,279 @@ export interface KnowledgeBaseDocumentPollOptions {
     /** Total timeout in milliseconds. Default 120000 (2 min). */
     timeoutMs?: number;
 }
+/**
+ * Parameters for {@link CallControl.dial} — an outbound PSTN call placed by a
+ * human broker, not by an AI agent. For an agent dial see
+ * {@link VoiceDialParams}.
+ */
+export interface CallControlDialParams {
+    /** Destination in E.164 format (e.g. "+12015551234"). */
+    to: string;
+    /**
+     * Caller ID to present, E.164. Must be a number your org owns; falls back to
+     * the org's default outbound number when omitted.
+     */
+    from?: string;
+    /** Opaque key/values stored on the call and echoed back on every read. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * What {@link CallControl.dial} resolves to. The join credentials come back
+ * *with* the call rather than from a second request, because the dialing
+ * broker's softphone has to already be in the room when the far end answers —
+ * fetch them afterwards and the first moments of the call are silence.
+ *
+ * Destructure both halves; `call` alone is not enough to be heard:
+ *
+ * ```ts
+ * const { call, join } = await speko.callControl.dial({ to: '+12015551234' });
+ * ```
+ */
+export interface CallControlDialResult {
+    /** The call and both of its legs — the `controlId`s every later command needs. */
+    readonly call: CallResource;
+    /** Room credentials for the dialing broker's own browser leg. */
+    readonly join: CallJoinCredentials;
+}
+/** Filters for {@link CallControl.list}. All optional; all AND-ed together. */
+export interface CallControlListParams {
+    /**
+     * Typed against the contract's `CallStatus` on purpose: the server validates
+     * `?status=` against the same enum and rejects anything else, so a typo is a
+     * compile error here instead of a `VALIDATION_ERROR` at runtime.
+     */
+    status?: CallStatus;
+    direction?: CallDirection;
+    /**
+     * Only calls with a browser leg owned by this broker. Unlike dialing, reading
+     * another broker's calls is allowed — a supervisor view is a legitimate use of
+     * an org-scoped credential.
+     */
+    brokerId?: string;
+    /** Newest first. Server-side default and cap apply. */
+    limit?: number;
+}
+export type SmsMessageStatus = 'queued' | 'scheduled' | 'submitting' | 'accepted' | 'sent' | 'delivered' | 'delivery_failed' | 'rejected' | 'submission_unknown' | 'canceled' | 'received';
+export type SmsMessageDirection = 'inbound' | 'outbound';
+export type SmsMessageOrigin = 'api' | 'dashboard' | 'agent_tool' | 'agent_auto_reply' | 'telnyx';
+export interface SmsSegmentEstimate {
+    readonly encoding: 'gsm7' | 'ucs2';
+    readonly segments: number;
+    readonly units: number;
+    readonly per_segment: number;
+}
+export interface SmsMessage {
+    readonly id: string;
+    readonly conversation_id: string;
+    readonly batch_id: string | null;
+    readonly from_phone_number_id: string;
+    readonly direction: SmsMessageDirection;
+    readonly origin: SmsMessageOrigin;
+    readonly from: string;
+    readonly to: string;
+    readonly text: string | null;
+    readonly campaign_id: string | null;
+    readonly brand_id: string | null;
+    readonly campaign_snapshot: Record<string, unknown> | null;
+    readonly consent_id: string | null;
+    readonly consent_basis: string | null;
+    readonly recipient_timezone: string | null;
+    readonly requested_send_at: string | null;
+    readonly effective_send_at: string | null;
+    readonly terminal_at: string | null;
+    readonly status: SmsMessageStatus;
+    readonly provider_status: string | null;
+    readonly encoding: 'gsm7' | 'ucs2' | null;
+    readonly estimated_segments: number;
+    readonly segment_count: number;
+    readonly estimated: SmsSegmentEstimate;
+    readonly charged_micro_usd: string;
+    readonly provider_cost_micro_usd: string | null;
+    readonly metadata: Record<string, unknown>;
+    readonly error: {
+        readonly code: string;
+        readonly detail: string | null;
+    } | null;
+    readonly created_at: string;
+    readonly updated_at: string;
+}
+export interface SmsPage<T> {
+    readonly data: T[];
+    readonly next_cursor: string | null;
+}
+export interface SmsSendParams {
+    readonly from_phone_number_id: string;
+    readonly to: string;
+    readonly text: string;
+    readonly idempotencyKey: string;
+    readonly send_at?: string;
+    readonly consent_id?: string | null;
+    readonly recipient_timezone?: string | null;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface SmsMessageListParams {
+    readonly conversation_id?: string;
+    readonly batch_id?: string;
+    readonly from_phone_number_id?: string;
+    readonly recipient?: string;
+    readonly campaign_id?: string;
+    readonly status?: SmsMessageStatus;
+    readonly direction?: SmsMessageDirection;
+    readonly origin?: SmsMessageOrigin;
+    readonly created_after?: string;
+    readonly created_before?: string;
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface SmsBatchRecipient {
+    readonly to: string;
+    readonly text: string;
+    readonly consent_id?: string | null;
+    readonly recipient_timezone?: string | null;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface SmsBatchCreateParams {
+    readonly from_phone_number_id: string;
+    readonly recipients: readonly SmsBatchRecipient[];
+    readonly idempotencyKey: string;
+    readonly send_at?: string;
+}
+export interface SmsBatch {
+    readonly id: string;
+    readonly from_phone_number_id: string;
+    readonly status: 'queued' | 'scheduled' | 'processing' | 'completed' | 'partially_failed' | 'failed' | 'canceled';
+    readonly requested_send_at: string | null;
+    readonly total_count: number;
+    readonly accepted_count: number;
+    readonly rejected_count: number;
+    readonly delivered_count: number;
+    readonly failed_count: number;
+    readonly canceled_at: string | null;
+    readonly completed_at: string | null;
+    readonly created_at: string;
+    readonly updated_at: string;
+}
+export interface SmsConversation {
+    readonly id: string;
+    readonly phone_number_id: string;
+    readonly remote_phone_number: string;
+    readonly campaign_id: string | null;
+    readonly campaign_snapshot: Record<string, unknown> | null;
+    readonly status: 'open' | 'closed' | 'spam';
+    readonly automation_status: 'disabled' | 'enabled' | 'paused';
+    readonly assigned_user_id: string | null;
+    readonly assigned_agent_id: string | null;
+    readonly unread_count: number;
+    readonly recipient_timezone: string | null;
+    readonly last_inbound_at: string | null;
+    readonly last_outbound_at: string | null;
+    readonly last_message_at: string;
+    readonly content_redacted_at: string | null;
+    readonly created_at: string;
+    readonly updated_at: string;
+}
+export interface SmsConversationListParams {
+    readonly status?: SmsConversation['status'];
+    readonly phone_number_id?: string;
+    readonly assigned_user_id?: string;
+    readonly assigned_agent_id?: string;
+    readonly recipient?: string;
+    readonly unread?: boolean;
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface SmsConversationUpdate {
+    readonly status?: SmsConversation['status'];
+    readonly assigned_user_id?: string | null;
+    readonly assigned_agent_id?: string | null;
+    readonly automation_status?: SmsConversation['automation_status'];
+    readonly recipient_timezone?: string | null;
+}
+export interface SmsConversationSendParams {
+    readonly text: string;
+    readonly idempotencyKey: string;
+    readonly send_at?: string;
+    readonly consent_id?: string | null;
+    readonly recipient_timezone?: string | null;
+    readonly metadata?: Record<string, unknown>;
+}
+export type SmsConsentSource = 'inbound' | 'api' | 'keyword' | 'webform' | 'paper' | 'verbal' | 'import';
+export interface SmsConsentInput {
+    readonly recipient: string;
+    readonly campaign_id: string;
+    readonly source: SmsConsentSource;
+    readonly proof_reference?: string | null;
+    readonly proof?: string | null;
+    readonly timezone?: string | null;
+    readonly captured_at?: string;
+    readonly expires_at?: string | null;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface SmsConsent {
+    readonly id: string;
+    readonly recipient: string;
+    readonly campaign_id: string;
+    readonly status: 'active' | 'expired' | 'revoked';
+    readonly source: SmsConsentSource;
+    readonly proof_reference: string | null;
+    readonly proof_hash: string | null;
+    readonly timezone: string | null;
+    readonly captured_at: string;
+    readonly expires_at: string | null;
+    readonly revoked_at: string | null;
+    readonly revoked_reason: string | null;
+    readonly metadata: Record<string, unknown>;
+    readonly created_at: string;
+}
+export interface SmsConsentListParams {
+    readonly recipient?: string;
+    readonly campaign_id?: string;
+    readonly status?: SmsConsent['status'];
+    readonly limit?: number;
+}
+export interface SmsSuppression {
+    readonly id: string;
+    readonly recipient: string;
+    readonly status: 'suppressed' | 'lifted';
+    readonly keyword: string | null;
+    readonly source_phone_number_id: string | null;
+    readonly source_message_provider_id: string | null;
+    readonly suppressed_at: string;
+    readonly lifted_at: string | null;
+    readonly updated_at: string;
+}
+export interface SmsSettings {
+    readonly messaging_profile_id: string | null;
+    readonly messaging_profile_status: string;
+    readonly webhook_config_version: number;
+    readonly opt_out_config_version: number;
+    readonly help_message: string;
+    readonly opt_out_message: string;
+    readonly opt_in_message: string;
+    readonly retention_days: number;
+    readonly quiet_hours_start: string;
+    readonly quiet_hours_end: string;
+    readonly default_timezone: string | null;
+    readonly default_automation_enabled: boolean;
+    readonly last_synced_at: string | null;
+    readonly last_error: string | null;
+    readonly updated_at: string;
+}
+export type SmsSettingsUpdate = Partial<Pick<SmsSettings, 'help_message' | 'opt_out_message' | 'opt_in_message' | 'retention_days' | 'quiet_hours_start' | 'quiet_hours_end' | 'default_timezone' | 'default_automation_enabled'>>;
+export interface SmsConversationNote {
+    readonly id: string;
+    readonly conversation_id: string;
+    readonly body: string | null;
+    readonly created_by_user_id: string;
+    readonly redacted_at: string | null;
+    readonly created_at: string;
+}
+export interface SmsStreamEvent {
+    readonly event: string;
+    readonly id?: string;
+    readonly message_id: string;
+    readonly conversation_id: string;
+    readonly status: SmsMessageStatus;
+    readonly occurred_at: string;
+}
 //# sourceMappingURL=index.d.ts.map