@zernio/node 0.2.310 → 0.2.312

package/src/generated/types.gen.ts

@@ -911,6 +911,148 @@ export type BusinessCenter = {
     advertiserCount?: (number) | null;
 };
 
+/**
+ * One call on a number you own, either channel. `channel` tells you which
+ * lane it took: `whatsapp` (WhatsApp Business Calling) or `pstn` (a regular
+ * phone call). List endpoints omit `transcript`; use `lastTranscriptSnippet`
+ * for a preview and the detail endpoint for the full transcript.
+ *
+ */
+export type CallRecord = {
+    _id?: string;
+    /**
+     * Owning social account. The unified /v1/calls/{id} detail + recording endpoints work for any channel; the channel-specific endpoints remain for account-scoped access.
+     */
+    accountId?: string;
+    /**
+     * Inbox conversation with the counterparty, when one exists.
+     */
+    conversationId?: (string) | null;
+    /**
+     * CRM Contact for the counterparty, when resolved.
+     */
+    contactId?: (string) | null;
+    channel?: 'whatsapp' | 'pstn';
+    direction?: 'inbound' | 'outbound';
+    /**
+     * Caller number (E.164).
+     */
+    from?: string;
+    /**
+     * Callee number (E.164).
+     */
+    to?: string;
+    /**
+     * Destination the call was routed to (tel:/sip:/wss:), snapshotted at routing time.
+     */
+    forwardTo?: (string) | null;
+    /**
+     * Outbound PSTN only. Message spoken to the callee on answer, before the bridge.
+     */
+    greeting?: (string) | null;
+    status?: 'ringing' | 'answered' | 'ended' | 'failed';
+    /**
+     * True when an inbound call went to voicemail.
+     */
+    isVoicemail?: boolean;
+    /**
+     * Outbound answering-machine detection was requested for this call.
+     */
+    amd?: boolean;
+    /**
+     * With `amd`, whether a machine (vs a human) answered.
+     */
+    answeredMachine?: (boolean) | null;
+    /**
+     * Caller ID presented on the forwarded leg.
+     */
+    forwardCallerId?: 'business' | 'caller';
+    /**
+     * Effective flag for THIS call (number default + per-call override, resolved at create time).
+     */
+    recordingEnabled?: boolean;
+    transcriptionEnabled?: boolean;
+    transcriptionLanguage?: 'auto' | 'en' | 'es';
+    startedAt?: string;
+    answeredAt?: (string) | null;
+    endedAt?: (string) | null;
+    /**
+     * When the call was blind-transferred (POST /v1/voice/calls/{id}/transfer).
+     */
+    transferredAt?: (string) | null;
+    durationSeconds?: number;
+    endReason?: 'hangup' | 'no_answer' | 'rejected' | 'error';
+    /**
+     * Raw carrier hangup cause behind endReason (e.g. normal_clearing, not_found, time_limit) — the actual motive when endReason is a coarse bucket.
+     */
+    hangupCause?: (string) | null;
+    /**
+     * SIP response code that ended the call, when SIP-signalled (e.g. '403', '488'). The real failure reason for SIP legs.
+     */
+    sipHangupCause?: (string) | null;
+    /**
+     * Per-call failure log (dial failed, bridge failed, recording error).
+     */
+    callErrors?: Array<{
+        code?: number;
+        message?: string;
+    }>;
+    /**
+     * May be expired. Resolve a fresh playable URL via GET /v1/calls/{id}/recording (any channel).
+     */
+    recordingUrl?: (string) | null;
+    /**
+     * Most recent transcript segment, for list previews.
+     */
+    lastTranscriptSnippet?: (string) | null;
+    /**
+     * Full transcript segments (detail endpoint only; omitted from lists).
+     */
+    transcript?: Array<{
+        text?: string;
+        confidence?: number;
+        at?: string;
+    }>;
+    billing?: {
+        metaMinutes?: number;
+        telnyxSeconds?: number;
+        transcriptionSeconds?: number;
+        transcriptionCostUSD?: number;
+        /**
+         * WhatsApp channel only. Meta per-minute charge, billed by Meta directly to your WABA. Display only; not billed by Zernio.
+         */
+        metaCostUSD?: number;
+        telnyxCostUSD?: number;
+        recordingCostUSD?: number;
+        /**
+         * Amount Zernio bills you = telephony leg + recording + transcription (excludes any Meta portion).
+         */
+        billableCostUSD?: number;
+        /**
+         * Full cost incl. any Meta portion you pay directly. Display only.
+         */
+        totalCostUSD?: number;
+        currency?: string;
+    };
+    createdAt?: string;
+    updatedAt?: string;
+};
+
+export type channel = 'whatsapp' | 'pstn';
+
+export type direction = 'inbound' | 'outbound';
+
+export type status2 = 'ringing' | 'answered' | 'ended' | 'failed';
+
+/**
+ * Caller ID presented on the forwarded leg.
+ */
+export type forwardCallerId = 'business' | 'caller';
+
+export type transcriptionLanguage = 'auto' | 'en' | 'es';
+
+export type endReason = 'hangup' | 'no_answer' | 'rejected' | 'error';
+
 /**
  * A discoverable conversion destination on an ad platform — a Meta pixel,
  * Google conversion action, or LinkedIn conversion rule. Returned by
@@ -951,7 +1093,7 @@ export type ConversionDestination = {
  * For LinkedIn, `inactive` means the rule is soft-deleted (`enabled: false`).
  *
  */
-export type status2 = 'active' | 'inactive';
+export type status3 = 'active' | 'inactive';
 
 /**
  * A single conversion event to relay to the ad platform. All PII fields
@@ -1372,7 +1514,7 @@ export type privacy_level = 2;
 /**
  * 1=SCHEDULED, 2=ACTIVE, 3=COMPLETED, 4=CANCELED
  */
-export type status3 = 1 | 2 | 3 | 4;
+export type status4 = 1 | 2 | 3 | 4;
 
 /**
  * 1=STAGE_INSTANCE, 2=VOICE, 3=EXTERNAL
@@ -1868,6 +2010,10 @@ export type InboxWebhookAccount = {
      * Social account ID (same value as id). Canonical field so consumers can filter every webhook event on one field (e.g. route staging vs production by account). id is kept for backward compatibility.
      */
     accountId?: string;
+    /**
+     * Zernio profile (workspace) ID this account belongs to. Use it to route or filter inbox webhooks by workspace. This is the profile ID only, not its name (resolve the name via the API with this ID). Optional; omitted on the shared WhatsApp sandbox account and when the account has no resolvable profile.
+     */
+    profileId?: string;
     platform: string;
     username: string;
     displayName?: string;
@@ -1896,7 +2042,7 @@ export type InboxWebhookConversation = {
     contactId?: string;
 };
 
-export type status4 = 'active' | 'archived';
+export type status5 = 'active' | 'archived';
 
 /**
  * The message object included in inbox webhook payloads.
@@ -2005,7 +2151,7 @@ export type InboxWebhookMessage = {
 
 export type platform2 = 'instagram' | 'facebook' | 'telegram' | 'whatsapp';
 
-export type direction = 'incoming' | 'outgoing';
+export type direction2 = 'incoming' | 'outgoing';
 
 /**
  * Shared account-insights response envelope used by every platform-level
@@ -2448,7 +2594,7 @@ export type PlatformAnalytics = {
     errorMessage?: (string) | null;
 };
 
-export type status5 = 'published' | 'failed';
+export type status6 = 'published' | 'failed';
 
 /**
  * Sync state of analytics for this platform
@@ -2571,7 +2717,7 @@ export type Post = {
     updatedAt?: string;
 };
 
-export type status6 = 'draft' | 'scheduled' | 'publishing' | 'published' | 'failed' | 'partial';
+export type status7 = 'draft' | 'scheduled' | 'publishing' | 'published' | 'failed' | 'partial';
 
 export type visibility = 'public' | 'private' | 'unlisted';
 
@@ -3614,7 +3760,7 @@ export type UploadTokenResponse = {
     status?: 'pending' | 'completed' | 'expired';
 };
 
-export type status7 = 'pending' | 'completed' | 'expired';
+export type status8 = 'pending' | 'completed' | 'expired';
 
 export type UploadTokenStatusResponse = {
     token?: string;
@@ -3893,7 +4039,7 @@ export type WebhookLog = {
 /**
  * Delivery outcome
  */
-export type status8 = 'success' | 'failed';
+export type status9 = 'success' | 'failed';
 
 /**
  * Webhook payload for `account.ads.initial_sync_completed` events.
@@ -4002,7 +4148,7 @@ export type event = 'account.ads.initial_sync_completed';
 /**
  * Overall outcome of the initial sync.
  */
-export type status9 = 'success' | 'failure';
+export type status10 = 'success' | 'failure';
 
 /**
  * Stable category for UX branching. New values may be added; existing ones are
@@ -4253,10 +4399,6 @@ export type WebhookPayloadCallEnded = {
 
 export type event5 = 'call.ended';
 
-export type direction2 = 'inbound' | 'outbound';
-
-export type endReason = 'hangup' | 'no_answer' | 'rejected' | 'error';
-
 /**
  * Webhook payload for the `call.failed` event. Fired when a call
  * setup or in-progress call fails.
@@ -5390,7 +5532,7 @@ export type platform10 = 'whatsapp';
  * request before the template is actually removed.
  *
  */
-export type status10 = 'APPROVED' | 'REJECTED' | 'PENDING' | 'PAUSED' | 'DISABLED' | 'IN_APPEAL' | 'PENDING_DELETION';
+export type status11 = 'APPROVED' | 'REJECTED' | 'PENDING' | 'PAUSED' | 'DISABLED' | 'IN_APPEAL' | 'PENDING_DELETION';
 
 export type WhatsAppBodyComponent = {
     type: 'body';
@@ -5491,7 +5633,7 @@ export type WhatsAppSandboxSession = {
  * list responses.
  *
  */
-export type status11 = 'pending' | 'active';
+export type status12 = 'pending' | 'active';
 
 export type WhatsAppTemplateButton = {
     type: 'quick_reply' | 'url' | 'phone_number' | 'otp' | 'copy_code' | 'flow' | 'mpm' | 'catalog';
@@ -5610,7 +5752,7 @@ export type WorkflowExecutionEvent = {
 
 export type action2 = 'execution_started' | 'execution_completed' | 'execution_exited' | 'execution_paused' | 'execution_resumed' | 'node_started' | 'node_completed' | 'node_failed' | 'node_skipped';
 
-export type status12 = 'success' | 'failed' | 'pending';
+export type status13 = 'success' | 'failed' | 'pending';
 
 /**
  * A node in a workflow graph. `config` shape depends on `type`.
@@ -7536,6 +7678,26 @@ export type GetXApiPricingError = ({
     error?: string;
 });
 
+export type GetUsageData = {
+    query?: {
+        /**
+         * For Stripe subscription users, `true` forces a subscription
+         * reconciliation pass even when cached plan data looks complete.
+         * Omit the parameter, or pass `false`, to use the default
+         * first-time-only reconciliation behavior. Invalid boolean values are
+         * rejected.
+         *
+         */
+        reconcile?: boolean;
+    };
+};
+
+export type GetUsageResponse = (UsageStats);
+
+export type GetUsageError = (unknown | {
+    error?: string;
+});
+
 export type GetUsageStatsData = {
     query?: {
         /**
@@ -7556,6 +7718,107 @@ export type GetUsageStatsError = (unknown | {
     error?: string;
 });
 
+export type GetCallsUsageData = {
+    query?: {
+        channel?: 'whatsapp' | 'pstn';
+        groupBy?: 'day' | 'number' | 'channel';
+        /**
+         * Scope to calls involving this number (typically one of YOUR numbers). E.164, leading + optional.
+         */
+        number?: string;
+        /**
+         * Start of the window (inclusive). Default 30 days before `until`.
+         */
+        since?: string;
+        /**
+         * End of the window (exclusive). Default now.
+         */
+        until?: string;
+    };
+};
+
+export type GetCallsUsageResponse = ({
+    since?: string;
+    until?: string;
+    groupBy?: ('day' | 'number' | 'channel') | null;
+    totals?: {
+        calls?: number;
+        answered?: number;
+        minutes?: number;
+        /**
+         * What Zernio bills for these calls.
+         */
+        billableUSD?: number;
+        /**
+         * WhatsApp only: Meta's per-minute charge, billed by Meta directly to your WABA. Display only.
+         */
+        metaUSD?: number;
+    };
+    /**
+     * Present (possibly empty) when `groupBy` is set.
+     */
+    groups?: Array<{
+        /**
+         * The group key: a `YYYY-MM-DD` UTC day, one of your numbers, or a channel.
+         */
+        key?: string;
+        calls?: number;
+        answered?: number;
+        minutes?: number;
+        billableUSD?: number;
+        metaUSD?: number;
+    }>;
+});
+
+export type GetCallsUsageError = (unknown | {
+    error?: string;
+});
+
+export type GetSmsUsageData = {
+    query?: {
+        groupBy?: 'day' | 'number';
+        /**
+         * Scope to one of YOUR SMS-enabled numbers (E.164, leading + optional).
+         */
+        number?: string;
+        /**
+         * Start of the window (inclusive). Default 30 days before `until`.
+         */
+        since?: string;
+        /**
+         * End of the window (exclusive). Default now.
+         */
+        until?: string;
+    };
+};
+
+export type GetSmsUsageResponse = ({
+    since?: string;
+    until?: string;
+    groupBy?: ('day' | 'number') | null;
+    totals?: {
+        sent?: number;
+        received?: number;
+        total?: number;
+    };
+    /**
+     * Present (possibly empty) when `groupBy` is set.
+     */
+    groups?: Array<{
+        /**
+         * A `YYYY-MM-DD` UTC day or one of your numbers.
+         */
+        key?: string;
+        sent?: number;
+        received?: number;
+        total?: number;
+    }>;
+});
+
+export type GetSmsUsageError = (unknown | {
+    error?: string;
+});
+
 export type ListPostsData = {
     query?: {
         /**
@@ -14977,7 +15240,7 @@ export type GetWhatsAppCallingConfigData = {
 
 export type GetWhatsAppCallingConfigResponse = ({
     /**
-     * WhatsAppPhoneNumber Mongo ID (use on /v1/whatsapp/phone-numbers/{id}/calling)
+     * Phone number record ID (use on /v1/phone-numbers/{id}/whatsapp/calling)
      */
     phoneNumberDocId?: string;
     phoneNumber?: string;
@@ -15003,7 +15266,7 @@ export type GetWhatsAppCallingConfigError = ({
     error?: string;
 } | unknown);
 
-export type EnableWhatsAppCallingData = {
+export type EnableWhatsAppCallingLegacyData = {
     body: {
         accountId: string;
         /**
@@ -15026,18 +15289,18 @@ export type EnableWhatsAppCallingData = {
     };
 };
 
-export type EnableWhatsAppCallingResponse = ({
+export type EnableWhatsAppCallingLegacyResponse = ({
     success?: boolean;
     callingEnabled?: boolean;
     sipHostname?: string;
     forwardTo?: string;
 });
 
-export type EnableWhatsAppCallingError = ({
+export type EnableWhatsAppCallingLegacyError = ({
     error?: string;
 } | unknown);
 
-export type UpdateWhatsAppCallingData = {
+export type UpdateWhatsAppCallingLegacyData = {
     body: {
         accountId: string;
         forwardTo?: string;
@@ -15051,13 +15314,13 @@ export type UpdateWhatsAppCallingData = {
     };
 };
 
-export type UpdateWhatsAppCallingResponse = (unknown);
+export type UpdateWhatsAppCallingLegacyResponse = (unknown);
 
-export type UpdateWhatsAppCallingError = ({
+export type UpdateWhatsAppCallingLegacyError = ({
     error?: string;
 } | unknown);
 
-export type DisableWhatsAppCallingData = {
+export type DisableWhatsAppCallingLegacyData = {
     path: {
         id: string;
     };
@@ -15066,9 +15329,9 @@ export type DisableWhatsAppCallingData = {
     };
 };
 
-export type DisableWhatsAppCallingResponse = (unknown);
+export type DisableWhatsAppCallingLegacyResponse = (unknown);
 
-export type DisableWhatsAppCallingError = ({
+export type DisableWhatsAppCallingLegacyError = ({
     error?: string;
 } | unknown);
 
@@ -15130,6 +15393,12 @@ export type InitiateWhatsAppCallData = {
          */
         biz_opaque_callback_data?: string;
     };
+    headers?: {
+        /**
+         * Optional client-generated unique key (e.g. a UUID) that makes dial retries safe. Same key + same body replays the original response; same key + different body → 422; key still processing → 409.
+         */
+        'Idempotency-Key'?: string;
+    };
 };
 
 export type InitiateWhatsAppCallResponse = ({
@@ -15156,6 +15425,10 @@ export type InitiateWhatsAppCallError = ({
 export type ListWhatsAppCallsData = {
     query: {
         accountId: string;
+        /**
+         * Return calls with startedAt strictly before this instant (use the previous page's nextCursor).
+         */
+        before?: string;
         direction?: 'inbound' | 'outbound';
         limit?: number;
         since?: string;
@@ -15194,6 +15467,10 @@ export type ListWhatsAppCallsResponse = ({
             currency?: string;
         };
     }>;
+    /**
+     * Pass as `before` for the next page; null on the last page.
+     */
+    nextCursor?: (string) | null;
 });
 
 export type ListWhatsAppCallsError = ({
@@ -15219,6 +15496,27 @@ export type GetWhatsAppCallError = ({
     error?: string;
 } | unknown);
 
+export type GetWhatsAppCallRecordingData = {
+    path: {
+        callId: string;
+    };
+    query: {
+        accountId: string;
+        /**
+         * `json` returns `{ url }` instead of a 302 redirect.
+         */
+        as?: 'json';
+    };
+};
+
+export type GetWhatsAppCallRecordingResponse = ({
+    url?: string;
+});
+
+export type GetWhatsAppCallRecordingError = (unknown | {
+    error?: string;
+});
+
 export type GetWhatsAppCallEstimateData = {
     query: {
         accountId: string;
@@ -15254,512 +15552,709 @@ export type GetWhatsAppCallEstimateError = ({
     error?: string;
 });
 
-export type GetWhatsAppLibraryTemplateData = {
-    query: {
+export type ListCallsData = {
+    query?: {
         /**
-         * WhatsApp social account ID
+         * Return calls with startedAt strictly before this instant (use the previous page's nextCursor).
          */
-        accountId: string;
+        before?: string;
+        channel?: 'whatsapp' | 'pstn';
+        direction?: 'inbound' | 'outbound';
+        limit?: number;
         /**
-         * Exact library template name
+         * Exact filter: calls involving this number (typically one of YOUR numbers, to scope history to a single line). E.164, leading + optional.
          */
-        name: string;
+        number?: string;
+        /**
+         * Free-text match on the from/to numbers. Non-digits are stripped, so partial queries like `302` or `+1 302` work.
+         */
+        search?: string;
+        status?: 'ringing' | 'answered' | 'ended' | 'failed';
     };
 };
 
-export type GetWhatsAppLibraryTemplateResponse = ({
-    template?: {
-        name?: string;
-        language?: string;
-        category?: string;
-        body?: string;
-        body_params?: Array<(string)>;
-        buttons?: Array<{
-            /**
-             * QUICK_REPLY, URL, PHONE_NUMBER, OTP, FLOW, ...
-             */
-            type?: string;
-            text?: string;
-        }>;
-    } | null;
+export type ListCallsResponse = ({
+    calls?: Array<(CallRecord & {
+    /**
+     * CRM contact name for the counterparty, when resolved.
+     */
+    contactName?: string;
+})>;
+    /**
+     * Pass as `before` for the next page; null on the last page.
+     */
+    nextCursor?: (string) | null;
 });
 
-export type GetWhatsAppLibraryTemplateError = (unknown | {
+export type ListCallsError = ({
     error?: string;
+} | unknown);
+
+export type GetCallData = {
+    path: {
+        id: string;
+    };
+};
+
+export type GetCallResponse = ({
+    call?: (CallRecord & {
+    /**
+     * CRM contact name for the counterparty, when resolved.
+     */
+    contactName?: string;
+});
 });
 
-export type GetWhatsAppBusinessProfileData = {
-    query: {
+export type GetCallError = ({
+    error?: string;
+} | unknown);
+
+export type GetCallRecordingData = {
+    path: {
+        id: string;
+    };
+    query?: {
         /**
-         * WhatsApp social account ID
+         * `json` returns `{ url }` instead of a 302 redirect.
          */
-        accountId: string;
+        as?: 'json';
     };
 };
 
-export type GetWhatsAppBusinessProfileResponse = ({
-    success?: boolean;
-    businessProfile?: {
-        /**
-         * Short description (max 139 chars)
-         */
-        about?: string;
-        address?: string;
-        /**
-         * Full description (max 512 chars)
-         */
-        description?: string;
-        email?: string;
-        profilePictureUrl?: string;
-        websites?: Array<(string)>;
-        /**
-         * Business category
-         */
-        vertical?: string;
-    };
+export type GetCallRecordingResponse = ({
+    url?: string;
 });
 
-export type GetWhatsAppBusinessProfileError = (unknown | {
+export type GetCallRecordingError = (unknown | {
     error?: string;
 });
 
-export type UpdateWhatsAppBusinessProfileData = {
+export type CreateVoiceCallData = {
     body: {
         /**
-         * WhatsApp social account ID
+         * Destination to dial, E.164 with leading +.
          */
-        accountId: string;
+        to: string;
         /**
-         * Short business description (max 139 characters)
+         * Which of your voice-enabled numbers to dial from. Optional when you have exactly one.
          */
-        about?: string;
+        fromNumber?: string;
         /**
-         * Business address
+         * Per-call agent override (tel:+E164, sip:..., or wss://...); defaults to the number's stored forward destination.
          */
-        address?: string;
+        forwardTo?: string;
         /**
-         * Full business description (max 512 characters)
+         * Spoken to the callee when they answer, before the bridge.
          */
-        description?: string;
+        greeting?: string;
         /**
-         * Business email
+         * Per-call recording toggle; defaults to the number's setting.
          */
-        email?: string;
+        recordOverride?: boolean;
         /**
-         * Business websites (max 2)
+         * Per-call transcription toggle; defaults to the number's setting.
          */
-        websites?: Array<(string)>;
+        transcribeOverride?: boolean;
         /**
-         * Business category (e.g., RETAIL, ENTERTAINMENT, etc.)
+         * 'auto' derives from the callee's country; 'en'/'es' force it.
          */
-        vertical?: string;
+        transcriptionLanguage?: 'auto' | 'en' | 'es';
         /**
-         * Handle from resumable upload for profile picture
+         * A retry with the same key returns the original call instead of dialing again.
          */
-        profilePictureHandle?: string;
+        idempotencyKey?: string;
+        /**
+         * Answering-machine detection; defers the bridge until human vs machine is known.
+         */
+        amd?: boolean;
+        /**
+         * Spoken to a detected machine, then hang up (implies `amd`). For outbound voicemail drops.
+         */
+        voicemailDropMessage?: string;
+    };
+    headers?: {
+        /**
+         * Optional client-generated unique key (e.g. a UUID) that makes dial retries safe. Same key + same body replays the original response; same key + different body → 422; key still processing → 409.
+         */
+        'Idempotency-Key'?: string;
     };
 };
 
-export type UpdateWhatsAppBusinessProfileResponse = ({
+export type CreateVoiceCallResponse = ({
     success?: boolean;
-    message?: string;
+    /**
+     * Internal Call doc ID
+     */
+    callId?: string;
+    telnyxCallControlId?: string;
+    status?: 'dialing';
+    direction?: 'outbound';
+    from?: string;
+    to?: string;
+    forwardTo?: string;
+    greeting?: (string) | null;
+    recordingEnabled?: boolean;
+    transcriptionEnabled?: boolean;
+    transcriptionLanguage?: 'auto' | 'en' | 'es';
 });
 
-export type UpdateWhatsAppBusinessProfileError = (unknown | {
+export type CreateVoiceCallError = ({
     error?: string;
-});
+} | unknown);
 
-export type UploadWhatsAppProfilePhotoData = {
-    body: {
-        /**
-         * WhatsApp social account ID
-         */
-        accountId: string;
+export type ListVoiceCallsData = {
+    query?: {
+        before?: string;
+        direction?: 'inbound' | 'outbound';
+        limit?: number;
         /**
-         * Image file (JPEG or PNG, max 5MB, recommended 640x640)
+         * Exact filter: calls involving this number (typically one of your DIDs). E.164, leading + optional.
          */
-        file: (Blob | File);
+        number?: string;
+        status?: 'ringing' | 'answered' | 'ended' | 'failed';
     };
 };
 
-export type UploadWhatsAppProfilePhotoResponse = ({
-    success?: boolean;
-    message?: string;
+export type ListVoiceCallsResponse = ({
+    calls?: Array<CallRecord>;
+    nextCursor?: (string) | null;
 });
 
-export type UploadWhatsAppProfilePhotoError = (unknown | {
+export type ListVoiceCallsError = ({
     error?: string;
 });
 
-export type GetWhatsAppDisplayNameData = {
-    query: {
-        /**
-         * WhatsApp social account ID
-         */
-        accountId: string;
+export type GetVoiceCallData = {
+    path: {
+        id: string;
     };
 };
 
-export type GetWhatsAppDisplayNameResponse = ({
+export type GetVoiceCallResponse = ({
+    call?: CallRecord;
+});
+
+export type GetVoiceCallError = ({
+    error?: string;
+} | unknown);
+
+export type EndVoiceCallData = {
+    path: {
+        id: string;
+    };
+};
+
+export type EndVoiceCallResponse = ({
     success?: boolean;
-    displayName?: {
-        /**
-         * Current verified display name
-         */
-        name?: string;
-        /**
-         * Meta review status for the display name
-         */
-        status?: 'APPROVED' | 'PENDING_REVIEW' | 'DECLINED' | 'NONE';
+    callId?: string;
+    /**
+     * `ending` when a hangup was issued; otherwise the call's current status.
+     */
+    status?: string;
+});
+
+export type EndVoiceCallError = ({
+    error?: string;
+} | unknown);
+
+export type GetVoiceCallRecordingData = {
+    path: {
+        id: string;
+    };
+    query?: {
         /**
-         * Display phone number
+         * `json` returns `{ url }` instead of a 302 redirect.
          */
-        phoneNumber?: string;
+        as?: 'json';
     };
+};
+
+export type GetVoiceCallRecordingResponse = ({
+    url?: string;
 });
 
-export type GetWhatsAppDisplayNameError = ({
+export type GetVoiceCallRecordingError = (unknown | {
     error?: string;
-} | unknown);
+});
 
-export type UpdateWhatsAppDisplayNameData = {
+export type TransferVoiceCallData = {
     body: {
         /**
-         * WhatsApp social account ID
-         */
-        accountId: string;
-        /**
-         * New display name (must follow WhatsApp naming guidelines)
+         * +E164 phone number (tel: prefix optional) or a sip: URI. wss:// is not a valid transfer target.
          */
-        displayName: string;
+        to: string;
+    };
+    path: {
+        id: string;
     };
 };
 
-export type UpdateWhatsAppDisplayNameResponse = ({
+export type TransferVoiceCallResponse = ({
     success?: boolean;
-    message?: string;
-    displayName?: {
-        name?: string;
-        status?: 'PENDING_REVIEW';
-    };
+    callId?: string;
+    transferredTo?: string;
 });
 
-export type UpdateWhatsAppDisplayNameError = (unknown | {
+export type TransferVoiceCallError = ({
     error?: string;
-});
+} | unknown);
 
-export type GetWhatsappBusinessUsernameData = {
+export type GetVoiceCallEstimateData = {
     query: {
+        minutes?: number;
+        recording?: boolean;
         /**
-         * WhatsApp social account ID
+         * Destination number, E.164 (leading + optional).
          */
-        accountId: string;
+        to: string;
+        transcription?: boolean;
     };
 };
 
-export type GetWhatsappBusinessUsernameResponse = ({
+export type GetVoiceCallEstimateResponse = ({
+    destinationCountry?: (string) | null;
+    minutes?: number;
+    /**
+     * Billable cost per minute for the requested options.
+     */
+    perMinuteUsd?: number;
+    breakdown?: {
+        telnyxCostUSD?: number;
+        recordingCostUSD?: number;
+        transcriptionCostUSD?: number;
+        /**
+         * What Zernio bills for the call.
+         */
+        billableCostUSD?: number;
+        /**
+         * Equals billableCostUSD (no separate Meta bill on PSTN); kept for shape parity with the WhatsApp estimate.
+         */
+        totalCostUSD?: number;
+    };
+});
+
+export type GetVoiceCallEstimateError = ({
+    error?: string;
+});
+
+export type CreateVoiceWebSessionResponse = ({
     success?: boolean;
     /**
-     * The current username, or null if none is set
+     * Login token for the browser WebRTC SDK.
      */
-    username?: (string) | null;
+    token?: string;
     /**
-     * Approval state of the username
+     * Pass to POST /v1/voice/calls/web/dial once the browser is registered.
      */
-    status?: 'approved' | 'reserved' | 'none';
+    credentialId?: string;
+    expiresAt?: string;
+    sdk?: string;
 });
 
-export type GetWhatsappBusinessUsernameError = ({
+export type CreateVoiceWebSessionError = ({
     error?: string;
 } | unknown);
 
-export type SetWhatsappBusinessUsernameData = {
+export type DialVoiceWebCallData = {
     body: {
         /**
-         * WhatsApp social account ID
+         * The number to call, E.164 with leading +.
          */
-        accountId: string;
+        to: string;
         /**
-         * Desired username. Letters, digits, period, and underscore only. Must contain at least one letter. No leading, trailing, or consecutive periods. No www prefix. No domain TLD suffix.
-         *
+         * The WebRTC credential id returned by POST /v1/voice/calls/web (the registered browser).
          */
-        username: string;
+        credentialId: string;
         /**
-         * Pass `force_transfer` to request a transfer if the username is held by another account
+         * Which of your voice-enabled numbers to call from (optional when you have one).
          */
-        transferAction?: 'none' | 'force_transfer';
+        fromNumber?: string;
+        recordOverride?: boolean;
     };
 };
 
-export type SetWhatsappBusinessUsernameResponse = ({
+export type DialVoiceWebCallResponse = ({
     success?: boolean;
-    username?: string;
-    status?: 'approved' | 'reserved' | 'none';
+    callId?: string;
+    telnyxCallControlId?: string;
+    status?: 'dialing';
+    direction?: 'outbound';
+    from?: string;
+    to?: string;
+    recordingEnabled?: boolean;
 });
 
-export type SetWhatsappBusinessUsernameError = (unknown | {
+export type DialVoiceWebCallError = ({
     error?: string;
-});
+} | unknown);
 
-export type DeleteWhatsappBusinessUsernameData = {
+export type SendSmsData = {
     body: {
         /**
-         * WhatsApp social account ID
+         * One of your SMS-enabled numbers (E.164; formatting is normalized).
          */
-        accountId: string;
+        from: string;
+        /**
+         * Recipient number (E.164).
+         */
+        to: string;
+        /**
+         * Message body. Required unless `mediaUrls` is set. Max 10 SMS segments (1530 GSM-7 or 670 unicode characters).
+         */
+        text?: string;
+        /**
+         * Public media URLs to attach (sends as MMS). Max 10.
+         */
+        mediaUrls?: Array<(string)>;
+    };
+    headers?: {
+        /**
+         * Optional client-generated unique key (e.g. a UUID) that makes send retries safe. Same key + same body replays the original response; same key + different body → 422; key still processing → 409.
+         */
+        'Idempotency-Key'?: string;
     };
 };
 
-export type DeleteWhatsappBusinessUsernameResponse = ({
-    success?: boolean;
+export type SendSmsResponse = ({
+    /**
+     * Message ID
+     */
+    id?: string;
+    /**
+     * Inbox conversation the message was threaded into.
+     */
+    conversationId?: string;
+    status?: 'sent';
 });
 
-export type DeleteWhatsappBusinessUsernameError = ({
+export type SendSmsError = ({
     error?: string;
 } | unknown);
 
-export type GetWhatsappBusinessUsernameSuggestionsData = {
+export type LookupSmsNumberData = {
     query: {
         /**
-         * WhatsApp social account ID
+         * Number to look up (E.164; formatting is normalized).
          */
-        accountId: string;
+        number: string;
     };
 };
 
-export type GetWhatsappBusinessUsernameSuggestionsResponse = ({
-    success?: boolean;
+export type LookupSmsNumberResponse = ({
+    phoneNumber?: string;
+    carrierName?: (string) | null;
+    lineType?: 'mobile' | 'landline' | 'voip' | 'toll-free' | 'unknown';
     /**
-     * List of available username suggestions
+     * True when the line type can receive SMS (not a landline).
      */
-    suggestions?: Array<(string)>;
+    smsReachable?: boolean;
 });
 
-export type GetWhatsappBusinessUsernameSuggestionsError = ({
+export type LookupSmsNumberError = ({
     error?: string;
 } | unknown);
 
-export type GetWhatsAppNumberInfoData = {
-    query: {
-        /**
-         * WhatsApp social account ID
-         */
-        accountId: string;
+export type ListSmsOptOutsData = {
+    query?: {
+        format?: 'json' | 'csv';
+        limit?: number;
     };
 };
 
-export type GetWhatsAppNumberInfoResponse = ({
-    phone?: {
-        display_phone_number?: string;
-        verified_name?: string;
+export type ListSmsOptOutsResponse = ({
+    optOuts?: Array<{
+        phoneNumber?: string;
+        optedOutAt?: (string) | null;
         /**
-         * APPROVED, AVAILABLE_WITHOUT_REVIEW, PENDING_REVIEW, DECLINED, EXPIRED, NONE
+         * The keyword they sent (e.g. STOP), when the carrier recorded one.
          */
-        name_status?: string;
+        keyword?: (string) | null;
         /**
-         * GREEN, YELLOW, RED, UNKNOWN
+         * Which of your numbers the recipient opted out from.
          */
-        quality_rating?: string;
+        from?: (string) | null;
+    }>;
+    count?: number;
+});
+
+export type ListSmsOptOutsError = ({
+    error?: string;
+});
+
+export type StartSmsRegistrationData = {
+    body: {
+        registrationType: 'standard_10dlc' | 'sole_prop_10dlc' | 'toll_free';
         /**
-         * e.g. TIER_250, TIER_1K, TIER_UNLIMITED
+         * Your numbers this registration covers.
          */
-        messaging_limit_tier?: string;
-        throughput?: {
+        phoneNumbers: Array<(string)>;
+        /**
+         * Required for 10DLC. The legal entity behind the traffic (TCR brand).
+         */
+        brand?: {
+            entityType: 'PRIVATE_PROFIT' | 'PUBLIC_PROFIT' | 'NON_PROFIT' | 'GOVERNMENT' | 'SOLE_PROPRIETOR';
+            displayName: string;
             /**
-             * STANDARD or HIGH
+             * Legal company name. Required for every entityType except SOLE_PROPRIETOR.
              */
-            level?: string;
+            companyName?: string;
+            /**
+             * Required for every entityType except SOLE_PROPRIETOR.
+             */
+            ein?: string;
+            phone?: string;
+            /**
+             * Required for SOLE_PROPRIETOR; the verification OTP is texted there (US/CA mobile).
+             */
+            mobilePhone?: string;
+            street?: string;
+            city?: string;
+            state?: string;
+            postalCode?: string;
+            country: 'US' | 'CA';
+            /**
+             * Brand contact email; defaults to your account email when omitted.
+             */
+            email?: string;
+            website?: string;
+            vertical: 'AGRICULTURE' | 'COMMUNICATION' | 'CONSTRUCTION' | 'EDUCATION' | 'ENERGY' | 'ENTERTAINMENT' | 'FINANCIAL' | 'GAMBLING' | 'GOVERNMENT' | 'HEALTHCARE' | 'HOSPITALITY' | 'HUMAN_RESOURCES' | 'INSURANCE' | 'LEGAL' | 'MANUFACTURING' | 'NGO' | 'POLITICAL' | 'POSTAL' | 'PROFESSIONAL' | 'REAL_ESTATE' | 'RETAIL' | 'TECHNOLOGY' | 'TRANSPORTATION';
+            stockSymbol?: string;
         };
         /**
-         * e.g. CONNECTED
-         */
-        status?: string;
-        is_official_business_account?: boolean;
-        /**
-         * e.g. CLOUD_API
+         * Required for 10DLC. What you'll send and how recipients opt in/out.
          */
-        platform_type?: string;
+        campaign?: {
+            usecase: string;
+            description: string;
+            /**
+             * How a recipient ends up receiving your messages (the opt-in flow).
+             */
+            messageFlow: string;
+            sample1: string;
+            sample2?: string;
+            helpMessage: string;
+            optinKeywords: string;
+            optinMessage: string;
+            optoutKeywords: string;
+            optoutMessage: string;
+            helpKeywords: string;
+            embeddedLink?: boolean;
+            embeddedPhone?: boolean;
+            numberPool?: boolean;
+            ageGated?: boolean;
+            directLending?: boolean;
+        };
         /**
-         * Meta's can_send_message health object (messaging + calling signals)
+         * Required for toll_free.
          */
-        health_status?: {
-            [key: string]: unknown;
+        tollFree?: {
+            businessName: string;
+            corporateWebsite: string;
+            phoneNumbers: Array<(string)>;
+            useCase: string;
+            useCaseSummary: string;
+            productionMessageContent: string;
+            /**
+             * How recipients opt in to your messages.
+             */
+            optInWorkflow: string;
+            /**
+             * Screenshot URL(s) showing the opt-in flow (at least one).
+             */
+            optInWorkflowImageUrls: Array<(string)>;
+            /**
+             * Expected monthly message volume tier.
+             */
+            messageVolume: '10' | '100' | '1,000' | '10,000' | '100,000' | '250,000' | '500,000' | '750,000' | '1,000,000' | '5,000,000' | '10,000,000+';
+            additionalInformation: string;
+            businessAddr1: string;
+            businessAddr2?: string;
+            businessCity: string;
+            businessState: string;
+            businessZip: string;
+            businessContactFirstName: string;
+            businessContactLastName: string;
+            businessContactEmail: string;
+            businessContactPhone: string;
+            businessRegistrationNumber: string;
+            /**
+             * e.g. EIN (US), Companies House (UK), ABN (AU).
+             */
+            businessRegistrationType: string;
+            /**
+             * ISO 3166-1 alpha-2.
+             */
+            businessRegistrationCountry: string;
         };
     };
-    waba?: {
-        name?: string;
+};
+
+export type StartSmsRegistrationResponse = ({
+    registrationId?: string;
+    status?: 'pending';
+    /**
+     * True for sole-prop 10DLC: an OTP was texted to the brand's mobile; submit it via /verify-otp.
+     */
+    awaitingOtp?: boolean;
+});
+
+export type StartSmsRegistrationError = ({
+    error?: string;
+} | unknown);
+
+export type ListSmsRegistrationsResponse = ({
+    registrations?: Array<{
+        id?: string;
+        registrationType?: 'standard_10dlc' | 'sole_prop_10dlc' | 'toll_free';
+        displayName?: (string) | null;
+        status?: 'pending' | 'approved' | 'rejected';
         /**
-         * verified, not_verified, pending, ...
+         * Carrier-registry brand status (e.g. VERIFIED).
          */
-        business_verification_status?: string;
+        brandStatus?: string;
+        campaignStatus?: string;
         /**
-         * Meta integer timezone-enum id
+         * TCR brand id, useful when referencing the brand in carrier support threads.
          */
-        timezone_id?: string;
-        health_status?: {
-            [key: string]: unknown;
+        brandId?: (string) | null;
+        /**
+         * TCR campaign id.
+         */
+        campaignId?: (string) | null;
+        declineReason?: (string) | null;
+        phoneNumbers?: Array<(string)>;
+        /**
+         * Sole-prop 10DLC only; the OTP step is still pending.
+         */
+        awaitingOtp?: boolean;
+        /**
+         * Carrier-assigned brand trust score; drives throughput.
+         */
+        trustScore?: (number) | null;
+        /**
+         * Carrier throughput tier derived from the trust score.
+         */
+        throughput?: {
+            label?: string;
+            smsPerMinute?: number;
+            smsPerDay?: number;
         };
-    } | null;
+    }>;
 });
 
-export type GetWhatsAppNumberInfoError = (unknown | {
+export type ListSmsRegistrationsError = ({
     error?: string;
 });
 
-export type GetWhatsAppBlockStatusData = {
-    query: {
-        accountId: string;
-        /**
-         * Consumer wa_id or E.164 phone (leading + optional)
-         */
-        user: string;
+export type GetSmsRegistrationData = {
+    path: {
+        id: string;
     };
 };
 
-export type GetWhatsAppBlockStatusResponse = ({
-    blocked?: boolean;
+export type GetSmsRegistrationResponse = ({
+    id?: string;
+    registrationType?: 'standard_10dlc' | 'sole_prop_10dlc' | 'toll_free';
+    status?: 'pending' | 'approved' | 'rejected';
+    brandStatus?: string;
+    campaignStatus?: string;
+    declineReason?: (string) | null;
+    phoneNumbers?: Array<(string)>;
+    awaitingOtp?: boolean;
 });
 
-export type GetWhatsAppBlockStatusError = ({
+export type GetSmsRegistrationError = ({
     error?: string;
 } | unknown);
 
-export type GetWhatsAppBlockedUsersData = {
-    query: {
-        /**
-         * WhatsApp social account ID
-         */
-        accountId: string;
-        /**
-         * Cursor from a previous response's `nextCursor`.
-         */
-        after?: string;
-        /**
-         * Page size.
-         */
-        limit?: number;
+export type VerifySmsRegistrationOtpData = {
+    body: {
+        otpPin: string;
+    };
+    path: {
+        id: string;
     };
 };
 
-export type GetWhatsAppBlockedUsersResponse = ({
-    blockedUsers?: Array<{
-        /**
-         * WhatsApp user ID (usually the phone number without `+`).
-         */
-        waId?: string;
-    }>;
-    /**
-     * Pass as `after` to fetch the next page. Null when there are no more pages.
-     */
-    nextCursor?: (string) | null;
+export type VerifySmsRegistrationOtpResponse = ({
+    verified?: boolean;
 });
 
-export type GetWhatsAppBlockedUsersError = ({
+export type VerifySmsRegistrationOtpError = ({
     error?: string;
 } | unknown);
 
-export type BlockWhatsAppUsersData = {
+export type AppealSmsRegistrationData = {
     body: {
-        /**
-         * WhatsApp social account ID
-         */
-        accountId: string;
-        /**
-         * Phone numbers (E.164, e.g. "+16505551234") or WhatsApp user IDs to block.
-         */
-        users: Array<(string)>;
+        appealReason: string;
+    };
+    path: {
+        id: string;
     };
 };
 
-export type BlockWhatsAppUsersResponse = ({
-    /**
-     * Users successfully blocked.
-     */
-    blocked?: Array<{
-        /**
-         * The value you sent.
-         */
-        input?: string;
-        /**
-         * Resolved WhatsApp user ID.
-         */
-        waId?: string;
-    }>;
-    /**
-     * Users that could not be blocked, with reasons.
-     */
-    failed?: Array<{
-        input?: string;
-        errors?: Array<(string)>;
-    }>;
+export type AppealSmsRegistrationResponse = ({
+    status?: 'pending';
 });
 
-export type BlockWhatsAppUsersError = ({
+export type AppealSmsRegistrationError = (unknown | {
     error?: string;
-} | unknown);
+});
 
-export type UnblockWhatsAppUsersData = {
+export type ShareSmsRegistrationData = {
     body: {
         /**
-         * WhatsApp social account ID
-         */
-        accountId: string;
-        /**
-         * Phone numbers (E.164) or WhatsApp user IDs to unblock.
+         * Your phone number's ID (from GET /v1/phone-numbers).
          */
-        users: Array<(string)>;
+        numberId: string;
     };
 };
 
-export type UnblockWhatsAppUsersResponse = ({
-    /**
-     * Users successfully unblocked.
-     */
-    unblocked?: Array<{
-        /**
-         * The value you sent.
-         */
-        input?: string;
-        /**
-         * Resolved WhatsApp user ID.
-         */
-        waId?: string;
-    }>;
-    /**
-     * Users that could not be unblocked, with reasons.
-     */
-    failed?: Array<{
-        input?: string;
-        errors?: Array<(string)>;
-    }>;
+export type ShareSmsRegistrationResponse = ({
+    url?: string;
+    expiresAt?: string;
 });
 
-export type UnblockWhatsAppUsersError = ({
+export type ShareSmsRegistrationError = ({
     error?: string;
 } | unknown);
 
-export type GetWhatsAppDatasetData = {
+export type GetWhatsAppLibraryTemplateData = {
     query: {
         /**
          * WhatsApp social account ID
          */
         accountId: string;
+        /**
+         * Exact library template name
+         */
+        name: string;
     };
 };
 
-export type GetWhatsAppDatasetResponse = ({
-    /**
-     * Meta dataset ID linked to the WABA, or null if not provisioned yet
-     */
-    datasetId?: (string) | null;
+export type GetWhatsAppLibraryTemplateResponse = ({
+    template?: {
+        name?: string;
+        language?: string;
+        category?: string;
+        body?: string;
+        body_params?: Array<(string)>;
+        buttons?: Array<{
+            /**
+             * QUICK_REPLY, URL, PHONE_NUMBER, OTP, FLOW, ...
+             */
+            type?: string;
+            text?: string;
+        }>;
+    } | null;
 });
 
-export type GetWhatsAppDatasetError = ({
+export type GetWhatsAppLibraryTemplateError = (unknown | {
     error?: string;
-} | unknown);
+});
 
-export type CreateWhatsAppDatasetData = {
-    body: {
+export type GetWhatsAppBusinessProfileData = {
+    query: {
         /**
          * WhatsApp social account ID
          */
@@ -15767,247 +16262,1570 @@ export type CreateWhatsAppDatasetData = {
     };
 };
 
-export type CreateWhatsAppDatasetResponse = ({
-    /**
-     * Meta dataset ID linked to the WABA
-     */
-    datasetId?: string;
-    /**
-     * True if Meta created a new dataset on this call; false if one already existed
-     */
-    created?: boolean;
-});
-
-export type CreateWhatsAppDatasetError = ({
-    error?: string;
-} | unknown);
-
-export type GetWhatsAppPhoneNumbersData = {
-    query?: {
+export type GetWhatsAppBusinessProfileResponse = ({
+    success?: boolean;
+    businessProfile?: {
+        /**
+         * Short description (max 139 chars)
+         */
+        about?: string;
+        address?: string;
+        /**
+         * Full description (max 512 chars)
+         */
+        description?: string;
+        email?: string;
+        profilePictureUrl?: string;
+        websites?: Array<(string)>;
+        /**
+         * Business category
+         */
+        vertical?: string;
+    };
+});
+
+export type GetWhatsAppBusinessProfileError = (unknown | {
+    error?: string;
+});
+
+export type UpdateWhatsAppBusinessProfileData = {
+    body: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+        /**
+         * Short business description (max 139 characters)
+         */
+        about?: string;
+        /**
+         * Business address
+         */
+        address?: string;
+        /**
+         * Full business description (max 512 characters)
+         */
+        description?: string;
+        /**
+         * Business email
+         */
+        email?: string;
+        /**
+         * Business websites (max 2)
+         */
+        websites?: Array<(string)>;
+        /**
+         * Business category (e.g., RETAIL, ENTERTAINMENT, etc.)
+         */
+        vertical?: string;
+        /**
+         * Handle from resumable upload for profile picture
+         */
+        profilePictureHandle?: string;
+    };
+};
+
+export type UpdateWhatsAppBusinessProfileResponse = ({
+    success?: boolean;
+    message?: string;
+});
+
+export type UpdateWhatsAppBusinessProfileError = (unknown | {
+    error?: string;
+});
+
+export type UploadWhatsAppProfilePhotoData = {
+    body: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+        /**
+         * Image file (JPEG or PNG, max 5MB, recommended 640x640)
+         */
+        file: (Blob | File);
+    };
+};
+
+export type UploadWhatsAppProfilePhotoResponse = ({
+    success?: boolean;
+    message?: string;
+});
+
+export type UploadWhatsAppProfilePhotoError = (unknown | {
+    error?: string;
+});
+
+export type GetWhatsAppDisplayNameData = {
+    query: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+    };
+};
+
+export type GetWhatsAppDisplayNameResponse = ({
+    success?: boolean;
+    displayName?: {
+        /**
+         * Current verified display name
+         */
+        name?: string;
+        /**
+         * Meta review status for the display name
+         */
+        status?: 'APPROVED' | 'PENDING_REVIEW' | 'DECLINED' | 'NONE';
+        /**
+         * Display phone number
+         */
+        phoneNumber?: string;
+    };
+});
+
+export type GetWhatsAppDisplayNameError = ({
+    error?: string;
+} | unknown);
+
+export type UpdateWhatsAppDisplayNameData = {
+    body: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+        /**
+         * New display name (must follow WhatsApp naming guidelines)
+         */
+        displayName: string;
+    };
+};
+
+export type UpdateWhatsAppDisplayNameResponse = ({
+    success?: boolean;
+    message?: string;
+    displayName?: {
+        name?: string;
+        status?: 'PENDING_REVIEW';
+    };
+});
+
+export type UpdateWhatsAppDisplayNameError = (unknown | {
+    error?: string;
+});
+
+export type GetWhatsappBusinessUsernameData = {
+    query: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+    };
+};
+
+export type GetWhatsappBusinessUsernameResponse = ({
+    success?: boolean;
+    /**
+     * The current username, or null if none is set
+     */
+    username?: (string) | null;
+    /**
+     * Approval state of the username
+     */
+    status?: 'approved' | 'reserved' | 'none';
+});
+
+export type GetWhatsappBusinessUsernameError = ({
+    error?: string;
+} | unknown);
+
+export type SetWhatsappBusinessUsernameData = {
+    body: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+        /**
+         * Desired username. Letters, digits, period, and underscore only. Must contain at least one letter. No leading, trailing, or consecutive periods. No www prefix. No domain TLD suffix.
+         *
+         */
+        username: string;
+        /**
+         * Pass `force_transfer` to request a transfer if the username is held by another account
+         */
+        transferAction?: 'none' | 'force_transfer';
+    };
+};
+
+export type SetWhatsappBusinessUsernameResponse = ({
+    success?: boolean;
+    username?: string;
+    status?: 'approved' | 'reserved' | 'none';
+});
+
+export type SetWhatsappBusinessUsernameError = (unknown | {
+    error?: string;
+});
+
+export type DeleteWhatsappBusinessUsernameData = {
+    body: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+    };
+};
+
+export type DeleteWhatsappBusinessUsernameResponse = ({
+    success?: boolean;
+});
+
+export type DeleteWhatsappBusinessUsernameError = ({
+    error?: string;
+} | unknown);
+
+export type GetWhatsappBusinessUsernameSuggestionsData = {
+    query: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+    };
+};
+
+export type GetWhatsappBusinessUsernameSuggestionsResponse = ({
+    success?: boolean;
+    /**
+     * List of available username suggestions
+     */
+    suggestions?: Array<(string)>;
+});
+
+export type GetWhatsappBusinessUsernameSuggestionsError = ({
+    error?: string;
+} | unknown);
+
+export type GetWhatsAppNumberInfoData = {
+    query: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+    };
+};
+
+export type GetWhatsAppNumberInfoResponse = ({
+    phone?: {
+        display_phone_number?: string;
+        verified_name?: string;
+        /**
+         * APPROVED, AVAILABLE_WITHOUT_REVIEW, PENDING_REVIEW, DECLINED, EXPIRED, NONE
+         */
+        name_status?: string;
+        /**
+         * GREEN, YELLOW, RED, UNKNOWN
+         */
+        quality_rating?: string;
+        /**
+         * e.g. TIER_250, TIER_1K, TIER_UNLIMITED
+         */
+        messaging_limit_tier?: string;
+        throughput?: {
+            /**
+             * STANDARD or HIGH
+             */
+            level?: string;
+        };
+        /**
+         * e.g. CONNECTED
+         */
+        status?: string;
+        is_official_business_account?: boolean;
+        /**
+         * e.g. CLOUD_API
+         */
+        platform_type?: string;
+        /**
+         * Meta's can_send_message health object (messaging + calling signals)
+         */
+        health_status?: {
+            [key: string]: unknown;
+        };
+    };
+    waba?: {
+        name?: string;
+        /**
+         * verified, not_verified, pending, ...
+         */
+        business_verification_status?: string;
+        /**
+         * Meta integer timezone-enum id
+         */
+        timezone_id?: string;
+        health_status?: {
+            [key: string]: unknown;
+        };
+    } | null;
+});
+
+export type GetWhatsAppNumberInfoError = (unknown | {
+    error?: string;
+});
+
+export type GetWhatsAppBlockStatusData = {
+    query: {
+        accountId: string;
+        /**
+         * Consumer wa_id or E.164 phone (leading + optional)
+         */
+        user: string;
+    };
+};
+
+export type GetWhatsAppBlockStatusResponse = ({
+    blocked?: boolean;
+});
+
+export type GetWhatsAppBlockStatusError = ({
+    error?: string;
+} | unknown);
+
+export type GetWhatsAppBlockedUsersData = {
+    query: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+        /**
+         * Cursor from a previous response's `nextCursor`.
+         */
+        after?: string;
+        /**
+         * Page size.
+         */
+        limit?: number;
+    };
+};
+
+export type GetWhatsAppBlockedUsersResponse = ({
+    blockedUsers?: Array<{
+        /**
+         * WhatsApp user ID (usually the phone number without `+`).
+         */
+        waId?: string;
+    }>;
+    /**
+     * Pass as `after` to fetch the next page. Null when there are no more pages.
+     */
+    nextCursor?: (string) | null;
+});
+
+export type GetWhatsAppBlockedUsersError = ({
+    error?: string;
+} | unknown);
+
+export type BlockWhatsAppUsersData = {
+    body: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+        /**
+         * Phone numbers (E.164, e.g. "+16505551234") or WhatsApp user IDs to block.
+         */
+        users: Array<(string)>;
+    };
+};
+
+export type BlockWhatsAppUsersResponse = ({
+    /**
+     * Users successfully blocked.
+     */
+    blocked?: Array<{
+        /**
+         * The value you sent.
+         */
+        input?: string;
+        /**
+         * Resolved WhatsApp user ID.
+         */
+        waId?: string;
+    }>;
+    /**
+     * Users that could not be blocked, with reasons.
+     */
+    failed?: Array<{
+        input?: string;
+        errors?: Array<(string)>;
+    }>;
+});
+
+export type BlockWhatsAppUsersError = ({
+    error?: string;
+} | unknown);
+
+export type UnblockWhatsAppUsersData = {
+    body: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+        /**
+         * Phone numbers (E.164) or WhatsApp user IDs to unblock.
+         */
+        users: Array<(string)>;
+    };
+};
+
+export type UnblockWhatsAppUsersResponse = ({
+    /**
+     * Users successfully unblocked.
+     */
+    unblocked?: Array<{
+        /**
+         * The value you sent.
+         */
+        input?: string;
+        /**
+         * Resolved WhatsApp user ID.
+         */
+        waId?: string;
+    }>;
+    /**
+     * Users that could not be unblocked, with reasons.
+     */
+    failed?: Array<{
+        input?: string;
+        errors?: Array<(string)>;
+    }>;
+});
+
+export type UnblockWhatsAppUsersError = ({
+    error?: string;
+} | unknown);
+
+export type GetWhatsAppDatasetData = {
+    query: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+    };
+};
+
+export type GetWhatsAppDatasetResponse = ({
+    /**
+     * Meta dataset ID linked to the WABA, or null if not provisioned yet
+     */
+    datasetId?: (string) | null;
+});
+
+export type GetWhatsAppDatasetError = ({
+    error?: string;
+} | unknown);
+
+export type CreateWhatsAppDatasetData = {
+    body: {
+        /**
+         * WhatsApp social account ID
+         */
+        accountId: string;
+    };
+};
+
+export type CreateWhatsAppDatasetResponse = ({
+    /**
+     * Meta dataset ID linked to the WABA
+     */
+    datasetId?: string;
+    /**
+     * True if Meta created a new dataset on this call; false if one already existed
+     */
+    created?: boolean;
+});
+
+export type CreateWhatsAppDatasetError = ({
+    error?: string;
+} | unknown);
+
+export type ListPhoneNumbersData = {
+    query?: {
+        /**
+         * Filter by profile
+         */
+        profileId?: string;
+        /**
+         * Filter by status (by default excludes released numbers). NOTE:
+         * `status=pending_regulatory` returns the "provisioning" view — numbers
+         * still in review PLUS recently-declined (last 30 days) ones, so a
+         * failed registration surfaces (with `regulatoryDeclineReason`) instead
+         * of silently disappearing. Declined numbers can be re-submitted via
+         * POST /v1/phone-numbers/{id}/remediate. `verifying` is the
+         * short-lived state after the number is provisioned on our side while
+         * WhatsApp confirms the activation code; the number is not billed until
+         * it reaches `active`.
+         *
+         */
+        status?: 'provisioning' | 'verifying' | 'pending_payment' | 'pending_regulatory' | 'regulatory_declined' | 'active' | 'suspended' | 'releasing' | 'released';
+    };
+};
+
+export type ListPhoneNumbersResponse = ({
+    numbers?: Array<{
+        _id?: string;
+        phoneNumber?: string;
+        country?: string;
+        status?: 'pending_payment' | 'pending_regulatory' | 'regulatory_declined' | 'provisioning' | 'verifying' | 'active' | 'suspended' | 'releasing' | 'released';
+        /**
+         * For regulated numbers, who it's registered for (company or person) — set from the submitted KYC.
+         */
+        registrantName?: (string) | null;
+        /**
+         * Present once the number order has been placed (i.e. the requirement group was approved). Absent while still in identity review.
+         */
+        telnyxOrderId?: (string) | null;
+        /**
+         * Per-country monthly price in cents ($2..$25).
+         */
+        monthlyCents?: number;
+        /**
+         * False for numbers you brought yourself (connected via Meta embedded signup) — they live on your own carrier, so SMS/Calls can't be enabled on them.
+         */
+        hostedByZernio?: boolean;
+        profileId?: {
+            [key: string]: unknown;
+        };
+        provisionedAt?: string;
+        metaPreverifiedId?: string;
+        metaVerificationStatus?: string;
+        /**
+         * For regulated (Tier 3/4) numbers with an Onfido ID-verification step — the link to forward to the end user. Set once the order is placed; null otherwise. Poll this field after submitting KYC.
+         */
+        onfidoVerificationUrl?: (string) | null;
+        endUserFirstName?: (string) | null;
+        endUserLastName?: (string) | null;
+        /**
+         * Reviewer rejection reason when status is regulatory_declined.
+         */
+        regulatoryDeclineReason?: (string) | null;
+        createdAt?: string;
+    }>;
+    /**
+     * Connected (bring-your-own) WhatsApp numbers — your own WABA
+     * numbers linked via Embedded Signup. Not provisioned or billed
+     * by Zernio, so they are not in `numbers`; `accountId` is the
+     * social-account id used by the messaging and inbox endpoints.
+     * Included only on the default and `status=active` views.
+     *
+     */
+    connected?: Array<{
+        accountId?: string;
+        phoneNumber?: (string) | null;
+        displayName?: (string) | null;
+        profileId?: (string) | null;
+        connectedAt?: (string) | null;
+    }>;
+    /**
+     * The shared WhatsApp sandbox (one Zernio-owned number, all users test
+     * against it). Present when the sandbox is configured; null otherwise.
+     * The `accountId` lets you address the sandbox in compose endpoints.
+     * `template` is the only template a sandbox send is allowed to use.
+     *
+     */
+    sandbox?: {
+        phoneNumber?: string;
+        accountId?: (string) | null;
+        template?: {
+            name?: string;
+            language?: string;
+        };
+        isSandbox?: boolean;
+    } | null;
+});
+
+export type ListPhoneNumbersError = ({
+    error?: string;
+});
+
+export type GetPhoneNumberData = {
+    path: {
+        /**
+         * Phone number record ID
+         */
+        id: string;
+    };
+};
+
+export type GetPhoneNumberResponse = ({
+    phoneNumber?: {
+        id?: string;
+        phoneNumber?: string;
+        status?: 'pending_payment' | 'pending_regulatory' | 'regulatory_declined' | 'provisioning' | 'verifying' | 'active' | 'suspended' | 'releasing' | 'released';
+        country?: string;
+        metaPreverifiedId?: string;
+        metaVerificationStatus?: string;
+        /**
+         * For a regulated number with an Onfido ID step — the link to forward to the end user. Appears once the order is placed; null otherwise.
+         */
+        onfidoVerificationUrl?: (string) | null;
+        endUserFirstName?: (string) | null;
+        endUserLastName?: (string) | null;
+        /**
+         * Reviewer rejection reason when status is regulatory_declined.
+         */
+        regulatoryDeclineReason?: (string) | null;
+        provisionedAt?: string;
+    };
+});
+
+export type GetPhoneNumberError = ({
+    error?: string;
+});
+
+export type ReleasePhoneNumberData = {
+    path: {
+        /**
+         * Phone number record ID
+         */
+        id: string;
+    };
+};
+
+export type ReleasePhoneNumberResponse = ({
+    message?: string;
+    phoneNumber?: {
+        id?: string;
+        phoneNumber?: string;
+        /**
+         * "released"
+         */
+        status?: string;
+        releasedAt?: string;
+    };
+});
+
+export type ReleasePhoneNumberError = (unknown | {
+    error?: string;
+});
+
+export type PurchasePhoneNumberData = {
+    body: {
+        /**
+         * Profile to associate the number with
+         */
+        profileId: string;
+        /**
+         * ISO 3166-1 alpha-2 country for the number (default US). International numbers require usage-based billing. Tier 3/4 countries return 202 { status: "kyc_required", kycUrl } — the customer must complete KYC at that URL before the number is ordered. See GET /v1/phone-numbers/countries.
+         *
+         */
+        country?: string;
+        /**
+         * A phone number is the unit; WhatsApp is one optional feature. Pass false to buy a STANDALONE number (Calls/SMS only): provisioning skips the Meta pre-verify/OTP steps and the number activates immediately. Omitted defaults to the WhatsApp provisioning path. WhatsApp can be connected to a standalone number later from the connect flow.
+         *
+         */
+        connectWhatsapp?: boolean;
+        /**
+         * SMS capability is per-number, not per-country. Pass true to provision from the SMS-capable inventory pool so the number can actually text (see also GET /v1/phone-numbers/available with sms=true, and smsAvailable on GET /v1/phone-numbers/countries).
+         *
+         */
+        wantsSms?: boolean;
+        /**
+         * Optional idempotency key. Send the same value when retrying a purchase: if a number was already bought under this key, the API returns { status: "already_purchased", numberId, phoneNumber } instead of provisioning a second number. Generate a fresh key for each genuinely new purchase.
+         *
+         */
+        purchaseIntentId?: string;
+        /**
+         * Any second purchase within 10 minutes of a previous one is rejected with 409 code PURCHASE_VELOCITY as duplicate protection. Pass true to confirm the additional purchase is intentional (e.g. bulk provisioning).
+         *
+         */
+        allowMultiple?: boolean;
+    };
+};
+
+export type PurchasePhoneNumberResponse = (({
+    message?: string;
+    checkoutUrl?: string;
+} | {
+    message?: string;
+    phoneNumber?: {
+        id?: string;
+        phoneNumber?: string;
+        status?: string;
+        country?: string;
+        provisionedAt?: string;
+        metaPreverifiedId?: string;
+        metaVerificationStatus?: string;
+    };
+} | {
+    status?: 'already_purchased';
+    numberId?: string;
+    phoneNumber?: string;
+}) | {
+    status?: 'kyc_required';
+    country?: string;
+    kycUrl?: string;
+});
+
+export type PurchasePhoneNumberError = (unknown | {
+    error?: string;
+} | {
+    error?: string;
+    code?: 'PURCHASE_VELOCITY';
+});
+
+export type ListPhoneNumberCountriesResponse = ({
+    countries?: Array<{
+        /**
+         * ISO 3166-1 alpha-2
+         */
+        code?: string;
+        tier?: 1 | 2 | 3 | 4;
+        monthlyCents?: number;
+        needsKyc?: boolean;
+        /**
+         * Regular phone (PSTN) calling on the number, inbound + outbound. Available on every offerable country.
+         */
+        callsAvailable?: boolean;
+        /**
+         * WhatsApp can be enabled on numbers from this country.
+         */
+        whatsappAvailable?: boolean;
+        /**
+         * Whether this country's number type can do SMS. Use it to filter the picker when the buyer wants SMS (pair with `wantsSms` on purchase).
+         */
+        smsAvailable?: boolean;
+        /**
+         * WhatsApp Business Calling (BIC) outbound availability, a Meta feature blocked in some countries. NOT the PSTN Calls feature (`callsAvailable`).
+         */
+        outboundCallingAvailable?: boolean;
+    }>;
+});
+
+export type ListPhoneNumberCountriesError = ({
+    error?: string;
+});
+
+export type SearchAvailablePhoneNumbersData = {
+    query?: {
+        /**
+         * Pattern to match within the number
+         */
+        contains?: string;
+        country?: string;
+        limit?: number;
+        /**
+         * City
+         */
+        locality?: string;
+        /**
+         * Area code
+         */
+        prefix?: string;
+        /**
+         * true narrows the pool to SMS-capable numbers. Each result still carries its full `features` list for per-number capability badging.
+         */
+        sms?: boolean;
+        /**
+         * Number type; defaults to the country's WhatsApp-safe type
+         */
+        type?: string;
+    };
+};
+
+export type SearchAvailablePhoneNumbersResponse = ({
+    country?: string;
+    numberType?: string;
+    /**
+     * Echo of the `sms` filter applied to this search.
+     */
+    requireSms?: boolean;
+    numbers?: Array<{
+        phoneNumber?: string;
+        /**
+         * Provider capability list for this number (e.g. voice, sms, mms).
+         */
+        features?: Array<(string)>;
+    }>;
+});
+
+export type SearchAvailablePhoneNumbersError = (unknown | {
+    error?: string;
+});
+
+export type CheckPhoneNumberAvailabilityData = {
+    query: {
+        /**
+         * ISO-2 country code.
+         */
+        country: string;
+    };
+};
+
+export type CheckPhoneNumberAvailabilityResponse = ({
+    country?: string;
+    numberType?: string;
+    /**
+     * Whether deliverable voice inventory exists right now.
+     */
+    available?: boolean;
+    addressConstraint?: 'geo' | 'country' | 'none';
+    /**
+     * For `geo` only — the area(s) the registered address must be in.
+     */
+    areas?: Array<(string)>;
+});
+
+export type CheckPhoneNumberAvailabilityError = (unknown | {
+    error?: string;
+});
+
+export type GetWhatsAppPhoneNumbersData = {
+    query?: {
         /**
          * Filter by profile
          */
-        profileId?: string;
+        profileId?: string;
+        /**
+         * Filter by status (by default excludes released numbers). NOTE:
+         * `status=pending_regulatory` returns the "provisioning" view — numbers
+         * still in review PLUS recently-declined (last 30 days) ones, so a
+         * failed registration surfaces (with `regulatoryDeclineReason`) instead
+         * of silently disappearing. Declined numbers can be re-submitted via
+         * POST /v1/whatsapp/phone-numbers/{id}/remediate. `verifying` is the
+         * short-lived state after the number is provisioned on our side while
+         * WhatsApp confirms the activation code; the number is not billed until
+         * it reaches `active`.
+         *
+         */
+        status?: 'provisioning' | 'verifying' | 'pending_payment' | 'pending_regulatory' | 'regulatory_declined' | 'active' | 'suspended' | 'releasing' | 'released';
+    };
+};
+
+export type GetWhatsAppPhoneNumbersResponse = ({
+    numbers?: Array<{
+        _id?: string;
+        phoneNumber?: string;
+        country?: string;
+        status?: 'pending_payment' | 'pending_regulatory' | 'regulatory_declined' | 'provisioning' | 'verifying' | 'active' | 'suspended' | 'releasing' | 'released';
+        /**
+         * For regulated numbers, who it's registered for (company or person) — set from the submitted KYC.
+         */
+        registrantName?: (string) | null;
+        /**
+         * Present once the number order has been placed (i.e. the requirement group was approved). Absent while still in identity review.
+         */
+        telnyxOrderId?: (string) | null;
+        /**
+         * Per-country monthly price in cents ($2..$25).
+         */
+        monthlyCents?: number;
+        /**
+         * False for numbers you brought yourself (connected via Meta embedded signup) — they live on your own carrier, so SMS/Calls can't be enabled on them.
+         */
+        hostedByZernio?: boolean;
+        profileId?: {
+            [key: string]: unknown;
+        };
+        provisionedAt?: string;
+        metaPreverifiedId?: string;
+        metaVerificationStatus?: string;
+        /**
+         * For regulated (Tier 3/4) numbers with an Onfido ID-verification step — the link to forward to the end user. Set once the order is placed; null otherwise. Poll this field after submitting KYC.
+         */
+        onfidoVerificationUrl?: (string) | null;
+        endUserFirstName?: (string) | null;
+        endUserLastName?: (string) | null;
+        /**
+         * Reviewer rejection reason when status is regulatory_declined.
+         */
+        regulatoryDeclineReason?: (string) | null;
+        createdAt?: string;
+    }>;
+    /**
+     * Connected (bring-your-own) WhatsApp numbers — your own WABA
+     * numbers linked via Embedded Signup. Not provisioned or billed
+     * by Zernio, so they are not in `numbers`; `accountId` is the
+     * social-account id used by the messaging and inbox endpoints.
+     * Included only on the default and `status=active` views.
+     *
+     */
+    connected?: Array<{
+        accountId?: string;
+        phoneNumber?: (string) | null;
+        displayName?: (string) | null;
+        profileId?: (string) | null;
+        connectedAt?: (string) | null;
+    }>;
+    /**
+     * The shared WhatsApp sandbox (one Zernio-owned number, all users test
+     * against it). Present when the sandbox is configured; null otherwise.
+     * The `accountId` lets you address the sandbox in compose endpoints.
+     * `template` is the only template a sandbox send is allowed to use.
+     *
+     */
+    sandbox?: {
+        phoneNumber?: string;
+        accountId?: (string) | null;
+        template?: {
+            name?: string;
+            language?: string;
+        };
+        isSandbox?: boolean;
+    } | null;
+});
+
+export type GetWhatsAppPhoneNumbersError = ({
+    error?: string;
+});
+
+export type PurchaseWhatsAppPhoneNumberData = {
+    body: {
+        /**
+         * Profile to associate the number with
+         */
+        profileId: string;
+        /**
+         * ISO 3166-1 alpha-2 country for the number (default US). International numbers require usage-based billing. Tier 3/4 countries return 202 { status: "kyc_required", kycUrl } — the customer must complete KYC at that URL before the number is ordered. See GET /v1/whatsapp/phone-numbers/countries.
+         *
+         */
+        country?: string;
+        /**
+         * Optional idempotency key. Send the same value when retrying a purchase: if a number was already bought under this key, the API returns { status: "already_purchased", numberId, phoneNumber } instead of provisioning a second number. Generate a fresh key for each genuinely new purchase.
+         *
+         */
+        purchaseIntentId?: string;
+        /**
+         * Any second purchase within 10 minutes of a previous one is rejected with 409 code PURCHASE_VELOCITY as duplicate protection. Pass true to confirm the additional purchase is intentional (e.g. bulk provisioning).
+         *
+         */
+        allowMultiple?: boolean;
+    };
+};
+
+export type PurchaseWhatsAppPhoneNumberResponse = (({
+    message?: string;
+    checkoutUrl?: string;
+} | {
+    message?: string;
+    phoneNumber?: {
+        id?: string;
+        phoneNumber?: string;
+        status?: string;
+        country?: string;
+        provisionedAt?: string;
+        metaPreverifiedId?: string;
+        metaVerificationStatus?: string;
+    };
+} | {
+    status?: 'already_purchased';
+    numberId?: string;
+    phoneNumber?: string;
+}) | {
+    status?: 'kyc_required';
+    country?: string;
+    kycUrl?: string;
+});
+
+export type PurchaseWhatsAppPhoneNumberError = (unknown | {
+    error?: string;
+} | {
+    error?: string;
+    code?: 'PURCHASE_VELOCITY';
+});
+
+export type ListWhatsAppNumberCountriesResponse = ({
+    countries?: Array<{
+        /**
+         * ISO 3166-1 alpha-2
+         */
+        code?: string;
+        tier?: 1 | 2 | 3 | 4;
+        monthlyCents?: number;
+        needsKyc?: boolean;
+        outboundCallingAvailable?: boolean;
+    }>;
+});
+
+export type ListWhatsAppNumberCountriesError = ({
+    error?: string;
+});
+
+export type SearchAvailableWhatsAppNumbersData = {
+    query?: {
+        /**
+         * Pattern to match within the number
+         */
+        contains?: string;
+        country?: string;
+        limit?: number;
+        /**
+         * City
+         */
+        locality?: string;
+        /**
+         * Area code
+         */
+        prefix?: string;
+        /**
+         * Number type; defaults to the country's WhatsApp-safe type
+         */
+        type?: string;
+    };
+};
+
+export type SearchAvailableWhatsAppNumbersResponse = ({
+    country?: string;
+    numberType?: string;
+    numbers?: Array<{
+        phoneNumber?: string;
+    }>;
+});
+
+export type SearchAvailableWhatsAppNumbersError = (unknown | {
+    error?: string;
+});
+
+export type CheckWhatsAppNumberAvailabilityData = {
+    query: {
+        /**
+         * ISO-2 country code.
+         */
+        country: string;
+    };
+};
+
+export type CheckWhatsAppNumberAvailabilityResponse = ({
+    country?: string;
+    numberType?: string;
+    /**
+     * Whether deliverable voice inventory exists right now.
+     */
+    available?: boolean;
+    addressConstraint?: 'geo' | 'country' | 'none';
+    /**
+     * For `geo` only — the area(s) the registered address must be in.
+     */
+    areas?: Array<(string)>;
+});
+
+export type CheckWhatsAppNumberAvailabilityError = (unknown | {
+    error?: string;
+});
+
+export type GetPhoneNumberKycFormData = {
+    query: {
+        country: string;
+    };
+};
+
+export type GetPhoneNumberKycFormResponse = ({
+    country?: string;
+    numberType?: string;
+    fields?: Array<{
+        requirementId?: string;
+        label?: string;
+        /**
+         * "action" = an out-of-band verification (e.g. Onfido); not filled here, fulfilled after the order via a link.
+         */
+        kind?: 'text' | 'date' | 'address' | 'file' | 'action';
+        /**
+         * Plain-English explanation of what to provide.
+         */
+        description?: (string) | null;
+        /**
+         * Concrete example value.
+         */
+        example?: (string) | null;
+        /**
+         * ISO country the value must be local to
+         */
+        localTo?: (string) | null;
+    }>;
+    /**
+     * Present when this account already has an approved verification for the country that can be reused (skip the form). `fromPhoneNumber`/`details` mirror the newest option; `options` lists ALL approved verifications (agencies hold one per end client) — pass the chosen option's `fromPhoneNumber` as `reuseFrom` on POST.
+     */
+    reusable?: {
+        available?: boolean;
+        fromPhoneNumber?: string;
+        /**
+         * Human-readable summary of the verification on file (field labels + values, plus the address as one line). Best-effort — may be empty if the provider lookup fails.
+         */
+        details?: Array<{
+            label?: string;
+            value?: string;
+        }>;
+        /**
+         * One entry per distinct approved verification, newest first.
+         */
+        options?: Array<{
+            fromPhoneNumber?: string;
+            details?: Array<{
+                label?: string;
+                value?: string;
+            }>;
+        }>;
+    } | null;
+});
+
+export type GetPhoneNumberKycFormError = (unknown | {
+    error?: string;
+});
+
+export type SubmitPhoneNumberKycData = {
+    body: {
+        profileId: string;
+        country: string;
+        /**
+         * Idempotency token for this submission attempt. A retry/double-submit with the same token returns the same number; omit and each call creates a new number.
+         */
+        submissionId?: string;
+        /**
+         * Provision several same-country numbers from one submission (1-5). The single verification covers all of them; each number is billed only when it activates. Numbers that fail to order are skipped (best-effort).
+         */
+        quantity?: number;
+        /**
+         * Reuse a prior approved verification for this country (skips document/field collection; places the order immediately).
+         */
+        reuse?: boolean;
+        /**
+         * Which approved verification to reuse when several exist: the phone number it was originally approved for (GET reusable.options[].fromPhoneNumber). Omitted = newest. No match = 409.
+         */
+        reuseFrom?: string;
+        /**
+         * End user's legal first name. Required when the country has an action/ID-verification (Onfido) requirement.
+         */
+        endUserFirstName?: string;
+        /**
+         * End user's legal last name. Same condition as endUserFirstName.
+         */
+        endUserLastName?: string;
+        /**
+         * requirementId → textual value
+         */
+        values?: {
+            [key: string]: (string);
+        };
+        /**
+         * One per document requirement. Each is EITHER inline base64 OR a `documentId` returned by POST /v1/phone-numbers/kyc/upload-document (use the upload endpoint for large files to stay under the request-size limit).
+         */
+        documents?: Array<({
+    requirementId: string;
+    filename: string;
+    base64: string;
+} | {
+    requirementId: string;
+    /**
+     * Id from POST /v1/phone-numbers/kyc/upload-document.
+     */
+    documentId: string;
+})>;
+        address?: {
+            requirementId?: string;
+            country_code?: string;
+            business_name?: string;
+            first_name?: string;
+            last_name?: string;
+            street_address?: string;
+            locality?: string;
+            administrative_area?: string;
+            postal_code?: string;
+        };
+    };
+};
+
+export type SubmitPhoneNumberKycResponse = ({
+    status?: 'kyc_submitted' | 'kyc_reused' | 'kyc_already_submitted';
+    /**
+     * The first/primary number, kept at the top level for backward compatibility. See `numbers` for the full set when `quantity` > 1.
+     */
+    phoneNumber?: {
+        id?: string;
+        status?: string;
+        country?: string;
+    };
+    /**
+     * Every number provisioned from this submission. Length equals the requested `quantity` on full success (fewer if some orders failed; best-effort). The first element mirrors `phoneNumber`.
+     */
+    numbers?: Array<{
+        id?: string;
+        status?: string;
+        phoneNumber?: string;
+        country?: string;
+    }>;
+});
+
+export type SubmitPhoneNumberKycError = (unknown | {
+    error?: string;
+});
+
+export type UploadPhoneNumberKycDocumentData = {
+    body: (Blob | File);
+    headers: {
+        /**
+         * URL-encoded original filename.
+         */
+        'X-Filename': string;
+    };
+};
+
+export type UploadPhoneNumberKycDocumentResponse = ({
+    /**
+     * Reference this id in the KYC submit's documents[].documentId.
+     */
+    documentId?: string;
+});
+
+export type UploadPhoneNumberKycDocumentError = (unknown | {
+    error?: string;
+});
+
+export type ValidatePhoneNumberKycAddressData = {
+    body: {
+        /**
+         * ISO 3166-1 alpha-2 country code.
+         */
+        country: string;
+        street_address: string;
+        /**
+         * City / town.
+         */
+        locality: string;
+        /**
+         * State / province / region. When omitted, the pre-check is skipped (the final submit still validates).
+         */
+        administrative_area?: string;
+        postal_code: string;
+    };
+};
+
+export type ValidatePhoneNumberKycAddressResponse = ({
+    ok?: boolean;
+    /**
+     * true when no `administrative_area` was supplied, so no pre-check ran.
+     */
+    skipped?: boolean;
+});
+
+export type ValidatePhoneNumberKycAddressError = ({
+    /**
+     * Human-readable message.
+     */
+    error?: string;
+    type?: string;
+    code?: string;
+    param?: string;
+    details?: {
+        addressSuggestions?: Array<{
+            field?: string;
+            label?: string;
+            value?: string;
+        }>;
+    };
+} | {
+    error?: string;
+});
+
+export type CreatePhoneNumberKycLinkData = {
+    body: {
+        profileId: string;
+        /**
+         * ISO 3166-1 alpha-2 country code (must be a regulated/KYC country).
+         */
+        country: string;
         /**
-         * Filter by status (by default excludes released numbers). NOTE:
-         * `status=pending_regulatory` returns the "provisioning" view — numbers
-         * still in review PLUS recently-declined (last 30 days) ones, so a
-         * failed registration surfaces (with `regulatoryDeclineReason`) instead
-         * of silently disappearing. Declined numbers can be re-submitted via
-         * POST /v1/whatsapp/phone-numbers/{id}/remediate. `verifying` is the
-         * short-lived state after the number is provisioned on our side while
-         * WhatsApp confirms the activation code; the number is not billed until
-         * it reaches `active`.
+         * Optional white-label of the hosted page the end customer sees.
+         */
+        branding?: {
+            /**
+             * Your company name, shown on the hosted page.
+             */
+            companyName?: string;
+            /**
+             * Logo shown above the form.
+             */
+            logoUrl?: string;
+            /**
+             * Hex color (e.g. #1a73e8) used as a brand accent on the page.
+             */
+            brandColor?: string;
+        };
+        /**
+         * Where to send the end customer's browser after a successful
+         * submit. On completion Zernio appends `kyc=submitted` and
+         * `country=<ISO-2>` as query params. When omitted, the hosted
+         * page shows a built-in confirmation screen instead.
          *
          */
-        status?: 'provisioning' | 'verifying' | 'pending_payment' | 'pending_regulatory' | 'regulatory_declined' | 'active' | 'suspended' | 'releasing' | 'released';
+        redirect_url?: string;
     };
 };
 
-export type GetWhatsAppPhoneNumbersResponse = ({
-    numbers?: Array<{
-        _id?: string;
-        phoneNumber?: string;
-        country?: string;
-        status?: 'pending_payment' | 'pending_regulatory' | 'regulatory_declined' | 'provisioning' | 'verifying' | 'active' | 'suspended' | 'releasing' | 'released';
+export type CreatePhoneNumberKycLinkResponse = ({
+    /**
+     * The hosted link to send your end customer.
+     */
+    url?: string;
+    token?: string;
+    expiresAt?: string;
+});
+
+export type CreatePhoneNumberKycLinkError = (unknown | {
+    error?: string;
+});
+
+export type CreatePhoneNumberPortInData = {
+    body: {
         /**
-         * For regulated numbers, who it's registered for (company or person) — set from the submitted KYC.
+         * E.164 numbers to port in.
          */
-        registrantName?: (string) | null;
+        phoneNumbers: Array<(string)>;
         /**
-         * Present once the number order has been placed (i.e. the requirement group was approved). Absent while still in identity review.
+         * End-user / current-carrier account info that authorizes the port.
          */
-        telnyxOrderId?: (string) | null;
+        endUser: {
+            entityName: string;
+            authPersonName: string;
+            billingPhoneNumber?: string;
+            accountNumber?: string;
+            /**
+             * Transfer PIN. Forwarded to the carrier, never stored.
+             */
+            pinPasscode?: string;
+            streetAddress: string;
+            extendedAddress?: string;
+            locality: string;
+            administrativeArea: string;
+            postalCode: string;
+            countryCode: string;
+        };
         /**
-         * Per-country monthly price in cents ($2..$25).
+         * Document id from POST /v1/phone-numbers/port-in/documents (kind=loa).
          */
-        monthlyCents?: number;
-        profileId?: {
-            [key: string]: unknown;
-        };
-        provisionedAt?: string;
-        metaPreverifiedId?: string;
-        metaVerificationStatus?: string;
+        loaDocumentId: string;
         /**
-         * For regulated (Tier 3/4) numbers with an Onfido ID-verification step — the link to forward to the end user. Set once the order is placed; null otherwise. Poll this field after submitting KYC.
+         * Document id from POST /v1/phone-numbers/port-in/documents (kind=invoice).
          */
-        onfidoVerificationUrl?: (string) | null;
-        endUserFirstName?: (string) | null;
-        endUserLastName?: (string) | null;
+        invoiceDocumentId: string;
         /**
-         * Reviewer rejection reason when status is regulatory_declined.
+         * Requested port date; the carrier confirms the actual FOC later.
          */
-        regulatoryDeclineReason?: (string) | null;
-        createdAt?: string;
-    }>;
+        focDatetimeRequested?: string;
+        customerReference?: string;
+    };
+};
+
+export type CreatePhoneNumberPortInResponse = ({
     /**
-     * Connected (bring-your-own) WhatsApp numbers — your own WABA
-     * numbers linked via Embedded Signup. Not provisioned or billed
-     * by Zernio, so they are not in `numbers`; `accountId` is the
-     * social-account id used by the messaging and inbox endpoints.
-     * Included only on the default and `status=active` views.
-     *
+     * Porting order ID.
      */
-    connected?: Array<{
-        accountId?: string;
-        phoneNumber?: (string) | null;
-        displayName?: (string) | null;
-        profileId?: (string) | null;
-        connectedAt?: (string) | null;
+    id?: string;
+    telnyxPortingOrderId?: string;
+    status?: 'draft' | 'pending' | 'foc_confirmed' | 'ported' | 'exception' | 'cancelled';
+    phoneNumbers?: Array<(string)>;
+    orders?: Array<{
+        id?: string;
+        telnyxPortingOrderId?: string;
+        status?: string;
+        phoneNumbers?: Array<(string)>;
+        /**
+         * Present when this split order failed to submit (it stays as a cancellable draft).
+         */
+        error?: string;
     }>;
-    /**
-     * The shared WhatsApp sandbox (one Zernio-owned number, all users test
-     * against it). Present when the sandbox is configured; null otherwise.
-     * The `accountId` lets you address the sandbox in compose endpoints.
-     * `template` is the only template a sandbox send is allowed to use.
-     *
-     */
-    sandbox?: {
-        phoneNumber?: string;
-        accountId?: (string) | null;
-        template?: {
-            name?: string;
-            language?: string;
-        };
-        isSandbox?: boolean;
-    } | null;
 });
 
-export type GetWhatsAppPhoneNumbersError = ({
+export type CreatePhoneNumberPortInError = ({
     error?: string;
+} | unknown);
+
+export type ListPhoneNumberPortInsResponse = ({
+    orders?: Array<{
+        id?: string;
+        status?: 'draft' | 'pending' | 'foc_confirmed' | 'ported' | 'exception' | 'cancelled';
+        /**
+         * Raw carrier status string.
+         */
+        telnyxStatusValue?: (string) | null;
+        phoneNumbers?: Array<(string)>;
+        fastPortEligible?: (boolean) | null;
+        focDatetimeRequested?: (string) | null;
+        focDatetimeActual?: (string) | null;
+        declineReason?: (string) | null;
+        submittedAt?: (string) | null;
+        portedAt?: (string) | null;
+        createdAt?: string;
+    }>;
 });
 
-export type PurchaseWhatsAppPhoneNumberData = {
+export type ListPhoneNumberPortInsError = ({
+    error?: string;
+});
+
+export type CheckPhoneNumberPortabilityData = {
     body: {
         /**
-         * Profile to associate the number with
+         * E.164 numbers to check, e.g. +13035550000.
          */
-        profileId: string;
+        phoneNumbers: Array<(string)>;
+    };
+};
+
+export type CheckPhoneNumberPortabilityResponse = ({
+    results?: Array<{
+        phoneNumber?: string;
+        portable?: boolean;
         /**
-         * ISO 3166-1 alpha-2 country for the number (default US). International numbers require usage-based billing. Tier 3/4 countries return 202 { status: "kyc_required", kycUrl } — the customer must complete KYC at that URL before the number is ordered. See GET /v1/whatsapp/phone-numbers/countries.
-         *
+         * Qualifies for the carrier's accelerated FastPort lane.
          */
-        country?: string;
+        fastPortable?: boolean;
         /**
-         * Optional idempotency key. Send the same value when retrying a purchase: if a number was already bought under this key, the API returns { status: "already_purchased", numberId, phoneNumber } instead of provisioning a second number. Generate a fresh key for each genuinely new purchase.
-         *
+         * Carrier reason when not portable; null when portable.
          */
-        purchaseIntentId?: string;
+        notPortableReason?: (string) | null;
+    }>;
+});
+
+export type CheckPhoneNumberPortabilityError = ({
+    error?: string;
+});
+
+export type UploadPhoneNumberPortInDocumentData = {
+    body: {
         /**
-         * Any second purchase within 10 minutes of a previous one is rejected with 409 code PURCHASE_VELOCITY as duplicate protection. Pass true to confirm the additional purchase is intentional (e.g. bulk provisioning).
-         *
+         * The document (PDF/JPEG/PNG, 10MB max).
          */
-        allowMultiple?: boolean;
+        file: (Blob | File);
+        /**
+         * Informational; used for the stored filename.
+         */
+        kind?: 'loa' | 'invoice';
     };
 };
 
-export type PurchaseWhatsAppPhoneNumberResponse = (({
-    message?: string;
-    checkoutUrl?: string;
-} | {
-    message?: string;
-    phoneNumber?: {
-        id?: string;
-        phoneNumber?: string;
-        status?: string;
-        country?: string;
-        provisionedAt?: string;
-        metaPreverifiedId?: string;
-        metaVerificationStatus?: string;
-    };
-} | {
-    status?: 'already_purchased';
-    numberId?: string;
-    phoneNumber?: string;
-}) | {
-    status?: 'kyc_required';
-    country?: string;
-    kycUrl?: string;
+export type UploadPhoneNumberPortInDocumentResponse = ({
+    documentId?: string;
 });
 
-export type PurchaseWhatsAppPhoneNumberError = (unknown | {
-    error?: string;
-} | {
+export type UploadPhoneNumberPortInDocumentError = (unknown | {
     error?: string;
-    code?: 'PURCHASE_VELOCITY';
 });
 
-export type ListWhatsAppNumberCountriesResponse = ({
-    countries?: Array<{
+export type CancelPhoneNumberPortInData = {
+    path: {
         /**
-         * ISO 3166-1 alpha-2
+         * Porting order ID (from the port-in list).
          */
-        code?: string;
-        tier?: 1 | 2 | 3 | 4;
-        monthlyCents?: number;
-        needsKyc?: boolean;
-        outboundCallingAvailable?: boolean;
-    }>;
+        id: string;
+    };
+};
+
+export type CancelPhoneNumberPortInResponse = ({
+    id?: string;
+    status?: 'draft' | 'pending' | 'foc_confirmed' | 'ported' | 'exception' | 'cancelled';
 });
 
-export type ListWhatsAppNumberCountriesError = ({
+export type CancelPhoneNumberPortInError = ({
     error?: string;
-});
+} | unknown);
 
-export type SearchAvailableWhatsAppNumbersData = {
-    query?: {
+export type ReviewPhoneNumberKycPacketData = {
+    body: {
+        country: string;
+        numberType: string;
         /**
-         * Pattern to match within the number
+         * requirementId to declared textual value.
          */
-        contains?: string;
-        country?: string;
-        limit?: number;
+        values?: {
+            [key: string]: (string);
+        };
         /**
-         * City
+         * Declared address (street_address, locality, ...), so a mismatched proof-of-address can be flagged.
          */
-        locality?: string;
+        address?: {
+            [key: string]: (string);
+        };
+        docs: Array<{
+            requirementId: string;
+            /**
+             * Id from POST /v1/phone-numbers/kyc/upload-document.
+             */
+            documentId: string;
+        }>;
+    };
+};
+
+export type ReviewPhoneNumberKycPacketResponse = ({
+    advisories?: Array<{
+        requirementId?: string;
         /**
-         * Area code
+         * One short plain-language concern about that requirement's document.
          */
-        prefix?: string;
+        concern?: string;
+    }>;
+});
+
+export type ReviewPhoneNumberKycPacketError = ({
+    error?: string;
+});
+
+export type GetPhoneNumberRemediationData = {
+    path: {
         /**
-         * Number type; defaults to the country's WhatsApp-safe type
+         * Phone number record ID.
          */
-        type?: string;
+        id: string;
     };
 };
 
-export type SearchAvailableWhatsAppNumbersResponse = ({
+export type GetPhoneNumberRemediationResponse = ({
     country?: string;
     numberType?: string;
-    numbers?: Array<{
-        phoneNumber?: string;
+    declineReason?: (string) | null;
+    /**
+     * Same field shape as GET /v1/phone-numbers/kyc.
+     */
+    fields?: Array<{
+        [key: string]: unknown;
     }>;
 });
 
-export type SearchAvailableWhatsAppNumbersError = (unknown | {
+export type GetPhoneNumberRemediationError = (unknown | {
     error?: string;
 });
 
-export type CheckWhatsAppNumberAvailabilityData = {
-    query: {
+export type RemediatePhoneNumberData = {
+    body: {
+        values?: {
+            [key: string]: (string);
+        };
+        documents?: Array<({
+    requirementId: string;
+    filename: string;
+    base64: string;
+} | {
+    requirementId: string;
+    documentId: string;
+})>;
         /**
-         * ISO-2 country code.
+         * Same shape as the KYC submit address.
          */
-        country: string;
+        address?: {
+            [key: string]: unknown;
+        };
+    };
+    path: {
+        id: string;
     };
 };
 
-export type CheckWhatsAppNumberAvailabilityResponse = ({
-    country?: string;
-    numberType?: string;
-    /**
-     * Whether deliverable voice inventory exists right now.
-     */
-    available?: boolean;
-    addressConstraint?: 'geo' | 'country' | 'none';
-    /**
-     * For `geo` only — the area(s) the registered address must be in.
-     */
-    areas?: Array<(string)>;
+export type RemediatePhoneNumberResponse = ({
+    status?: string;
+    phoneNumber?: {
+        id?: string;
+        status?: string;
+    };
 });
 
-export type CheckWhatsAppNumberAvailabilityError = (unknown | {
+export type RemediatePhoneNumberError = (unknown | {
     error?: string;
 });
 
@@ -16339,6 +18157,312 @@ export type RemediateWhatsAppNumberError = (unknown | {
     error?: string;
 });
 
+export type EnableVoiceOnNumberData = {
+    body?: {
+        /**
+         * tel:+E164, sip:..., or wss://... destination for inbound calls. Empty string clears the forward (outbound-only); omitted preserves the current one.
+         */
+        forwardTo?: string;
+        recordingEnabled?: boolean;
+        transcriptionEnabled?: boolean;
+        transcriptionLanguage?: 'auto' | 'en' | 'es';
+        /**
+         * Voicemail is taken when there's no live destination. Default on.
+         */
+        voicemailEnabled?: boolean;
+        /**
+         * Custom spoken greeting; empty string restores the default.
+         */
+        voicemailGreeting?: string;
+        /**
+         * Outside the windows, inbound skips the forward and goes to voicemail. Off = 24/7.
+         */
+        businessHoursEnabled?: boolean;
+        /**
+         * IANA timezone the windows are evaluated in.
+         */
+        businessHoursTimezone?: string;
+        businessHours?: Array<{
+            /**
+             * 0 = Sunday.
+             */
+            day: number;
+            open: string;
+            close: string;
+        }>;
+        /**
+         * E.164 numbers rejected before answer. Replaces the whole list; bare 10-digit values are normalized as US numbers.
+         */
+        blockedCallers?: Array<(string)>;
+        /**
+         * Caller ID on the forwarded leg: your number (`business`) or the original caller's (`caller`).
+         */
+        forwardCallerId?: 'business' | 'caller';
+        /**
+         * IVR menu (supersedes the plain forward within business hours).
+         */
+        ivrEnabled?: boolean;
+        ivrPrompt?: string;
+        ivrOptions?: Array<{
+            digit: string;
+            /**
+             * tel:+E164, sip:..., or wss://... destination for this digit.
+             */
+            forwardTo: string;
+            label?: string;
+        }>;
+    };
+    path: {
+        /**
+         * Phone number record ID (from GET /v1/phone-numbers).
+         */
+        id: string;
+    };
+};
+
+export type EnableVoiceOnNumberResponse = ({
+    enabled?: boolean;
+    phoneNumber?: string;
+    pstnForwardTo?: (string) | null;
+    recordingEnabled?: boolean;
+    transcriptionEnabled?: boolean;
+    transcriptionLanguage?: 'auto' | 'en' | 'es';
+    voicemailEnabled?: boolean;
+    voicemailGreeting?: (string) | null;
+    businessHoursEnabled?: boolean;
+    businessHoursTimezone?: (string) | null;
+    businessHours?: Array<{
+        day?: number;
+        open?: string;
+        close?: string;
+    }>;
+    blockedCallers?: Array<(string)>;
+    forwardCallerId?: 'business' | 'caller';
+    ivrEnabled?: boolean;
+    ivrPrompt?: (string) | null;
+    ivrOptions?: Array<{
+        digit?: string;
+        forwardTo?: string;
+        label?: string;
+    }>;
+});
+
+export type EnableVoiceOnNumberError = ({
+    error?: string;
+} | unknown);
+
+export type DisableVoiceOnNumberData = {
+    path: {
+        id: string;
+    };
+};
+
+export type DisableVoiceOnNumberResponse = ({
+    enabled?: boolean;
+    phoneNumber?: string;
+});
+
+export type DisableVoiceOnNumberError = ({
+    error?: string;
+} | unknown);
+
+export type EnableSmsOnNumberData = {
+    path: {
+        /**
+         * Phone number record ID (from GET /v1/phone-numbers).
+         */
+        id: string;
+    };
+};
+
+export type EnableSmsOnNumberResponse = ({
+    enabled?: boolean;
+    /**
+     * The SMS social account ID (present when enabled).
+     */
+    id?: string;
+    phoneNumber?: string;
+    /**
+     * False for US numbers until their registration is approved.
+     */
+    isActive?: boolean;
+    country?: string;
+    /**
+     * Null when capability can't be read yet (still provisioning).
+     */
+    smsCapable?: (boolean) | null;
+    mmsCapable?: boolean;
+    domesticOnly?: boolean;
+    /**
+     * Number is still provisioning at the carrier; retry shortly.
+     */
+    notReady?: boolean;
+    /**
+     * US only; a carrier registration is required before delivery.
+     */
+    needsRegistration?: boolean;
+    /**
+     * A prior non-rejected registration already covers this number; no re-submit needed.
+     */
+    alreadyRegistered?: boolean;
+    registrationStatus?: ('pending' | 'approved' | 'rejected') | null;
+    /**
+     * Present when an existing approved registration can cover this number via /sms/reuse-registration.
+     */
+    reusable?: {
+        registrationId?: string;
+        status?: string;
+    } | null;
+    /**
+     * Human-readable explanation when `enabled` is false.
+     */
+    message?: string;
+});
+
+export type EnableSmsOnNumberError = ({
+    error?: string;
+} | unknown);
+
+export type DisableSmsOnNumberData = {
+    path: {
+        id: string;
+    };
+};
+
+export type DisableSmsOnNumberResponse = ({
+    enabled?: boolean;
+    phoneNumber?: string;
+    /**
+     * False when SMS was already off. Legacy field; prefer `enabled`.
+     */
+    disabled?: boolean;
+});
+
+export type DisableSmsOnNumberError = ({
+    error?: string;
+} | unknown);
+
+export type ReuseSmsRegistrationForNumberData = {
+    path: {
+        id: string;
+    };
+};
+
+export type ReuseSmsRegistrationForNumberResponse = ({
+    registrationId?: string;
+    status?: 'pending' | 'approved' | 'rejected';
+});
+
+export type ReuseSmsRegistrationForNumberError = ({
+    error?: string;
+} | unknown);
+
+export type GetWhatsAppCallingData = {
+    path: {
+        /**
+         * Phone number record ID (from GET /v1/phone-numbers).
+         */
+        id: string;
+    };
+};
+
+export type GetWhatsAppCallingResponse = ({
+    phoneNumber?: string;
+    callingEnabled?: boolean;
+    /**
+     * Public calling deep link (https://wa.me/call/<number>). Null while calling is disabled.
+     */
+    callDeepLink?: (string) | null;
+    /**
+     * tel:+E164 / sip:... / wss://... destination
+     */
+    forwardTo?: (string) | null;
+    recordingEnabled?: boolean;
+    sipAuthUsername?: (string) | null;
+    /**
+     * True when a SIP digest password is stored. The plaintext is never returned.
+     */
+    sipAuthPasswordConfigured?: boolean;
+    callIconCountries?: Array<(string)> | null;
+    /**
+     * True when the number's country blocks business-initiated (outbound) WhatsApp calling; inbound still works.
+     */
+    outboundDisabled?: boolean;
+});
+
+export type GetWhatsAppCallingError = ({
+    error?: string;
+} | unknown);
+
+export type EnableWhatsAppCallingData = {
+    body: {
+        accountId: string;
+        /**
+         * tel:+E164 / sip:... / wss://... destination
+         */
+        forwardTo: string;
+        sipAuthUsername?: string;
+        /**
+         * Stored encrypted, never returned by any endpoint.
+         */
+        sipAuthPassword?: string;
+        recordingEnabled?: boolean;
+        callIconCountries?: Array<(string)>;
+    };
+    path: {
+        /**
+         * Phone number record ID (from GET /v1/phone-numbers).
+         */
+        id: string;
+    };
+};
+
+export type EnableWhatsAppCallingResponse = ({
+    success?: boolean;
+    callingEnabled?: boolean;
+    sipHostname?: string;
+    forwardTo?: string;
+});
+
+export type EnableWhatsAppCallingError = ({
+    error?: string;
+} | unknown);
+
+export type UpdateWhatsAppCallingData = {
+    body: {
+        accountId: string;
+        forwardTo?: string;
+        sipAuthUsername?: (string) | null;
+        sipAuthPassword?: (string) | null;
+        recordingEnabled?: boolean;
+        callIconCountries?: Array<(string)> | null;
+    };
+    path: {
+        id: string;
+    };
+};
+
+export type UpdateWhatsAppCallingResponse = (unknown);
+
+export type UpdateWhatsAppCallingError = ({
+    error?: string;
+} | unknown);
+
+export type DisableWhatsAppCallingData = {
+    path: {
+        id: string;
+    };
+    query: {
+        accountId: string;
+    };
+};
+
+export type DisableWhatsAppCallingResponse = (unknown);
+
+export type DisableWhatsAppCallingError = ({
+    error?: string;
+} | unknown);
+
 export type GetWhatsAppPhoneNumberData = {
     path: {
         /**