@zernio/node 0.2.310 → 0.2.311

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
@@ -1896,7 +2038,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 +2147,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 +2590,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 +2713,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 +3756,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 +4035,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 +4144,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 +4395,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 +5528,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 +5629,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 +5748,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 +7674,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 +7714,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 +15236,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 +15262,7 @@ export type GetWhatsAppCallingConfigError = ({
     error?: string;
 } | unknown);
 
-export type EnableWhatsAppCallingData = {
+export type EnableWhatsAppCallingLegacyData = {
     body: {
         accountId: string;
         /**
@@ -15026,18 +15285,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 +15310,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 +15325,9 @@ export type DisableWhatsAppCallingData = {
     };
 };
 
-export type DisableWhatsAppCallingResponse = (unknown);
+export type DisableWhatsAppCallingLegacyResponse = (unknown);
 
-export type DisableWhatsAppCallingError = ({
+export type DisableWhatsAppCallingLegacyError = ({
     error?: string;
 } | unknown);
 
@@ -15130,6 +15389,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 +15421,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 +15463,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 +15492,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,491 +15548,708 @@ 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;
+export type AppealSmsRegistrationResponse = ({
+    status?: 'pending';
+});
+
+export type AppealSmsRegistrationError = (unknown | {
+    error?: string;
+});
+
+export type ShareSmsRegistrationData = {
+    body: {
         /**
-         * Resolved WhatsApp user ID.
+         * Your phone number's ID (from GET /v1/phone-numbers).
          */
-        waId?: string;
-    }>;
-    /**
-     * Users that could not be blocked, with reasons.
-     */
-    failed?: Array<{
-        input?: string;
-        errors?: Array<(string)>;
-    }>;
+        numberId: string;
+    };
+};
+
+export type ShareSmsRegistrationResponse = ({
+    url?: string;
+    expiresAt?: string;
 });
 
-export type BlockWhatsAppUsersError = ({
+export type ShareSmsRegistrationError = ({
     error?: string;
 } | unknown);
 
-export type UnblockWhatsAppUsersData = {
-    body: {
+export type GetWhatsAppLibraryTemplateData = {
+    query: {
         /**
          * WhatsApp social account ID
          */
         accountId: string;
         /**
-         * Phone numbers (E.164) or WhatsApp user IDs to unblock.
+         * Exact library template name
          */
-        users: Array<(string)>;
+        name: 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 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 UnblockWhatsAppUsersError = ({
+export type GetWhatsAppLibraryTemplateError = (unknown | {
     error?: string;
-} | unknown);
+});
 
-export type GetWhatsAppDatasetData = {
+export type GetWhatsAppBusinessProfileData = {
     query: {
         /**
          * WhatsApp social account ID
@@ -15747,267 +16258,1570 @@ export type GetWhatsAppDatasetData = {
     };
 };
 
-export type GetWhatsAppDatasetResponse = ({
-    /**
-     * Meta dataset ID linked to the WABA, or null if not provisioned yet
-     */
-    datasetId?: (string) | null;
+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 GetWhatsAppDatasetError = ({
+export type GetWhatsAppBusinessProfileError = (unknown | {
     error?: string;
-} | unknown);
+});
 
-export type CreateWhatsAppDatasetData = {
+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;
+        /**
+         * 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 CreateWhatsAppDatasetResponse = ({
+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;
     /**
-     * Meta dataset ID linked to the WABA
+     * Whether deliverable voice inventory exists right now.
      */
-    datasetId?: string;
+    available?: boolean;
+    addressConstraint?: 'geo' | 'country' | 'none';
     /**
-     * True if Meta created a new dataset on this call; false if one already existed
+     * For `geo` only — the area(s) the registered address must be in.
      */
-    created?: boolean;
+    areas?: Array<(string)>;
 });
 
-export type CreateWhatsAppDatasetError = ({
+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;
-} | unknown);
+});
 
-export type GetWhatsAppPhoneNumbersData = {
-    query?: {
+export type CreatePhoneNumberKycLinkData = {
+    body: {
+        profileId: string;
         /**
-         * Filter by profile
+         * ISO 3166-1 alpha-2 country code (must be a regulated/KYC country).
          */
-        profileId?: string;
+        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 +18153,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: {
         /**