@zavudev/sdk 0.56.0 → 0.58.0

package/types.d.mts

@@ -0,0 +1,4901 @@
+/**
+ * Which namespace a memory belongs to. Scopes are isolated: a search in one never
+ * returns a memory from another.
+ *
+ * - `project`: shared by the whole project. What the agent knows in general.
+ * - `contact`: what the agent knows about one person, across every conversation
+ *   with them.
+ * - `conversation`: what the agent knows about one inbox thread.
+ *
+ * Defaults to `project` everywhere. `contact` and `conversation` require the
+ * matching id.
+ */
+export type MemoryScope = 'project' | 'contact' | 'conversation';
+/**
+ * Scope as a query-string value: `contact:<contactId>`,
+ * `conversation:<conversationId>`, the literal `project`, or omitted for project
+ * scope.
+ *
+ * Only the SHAPE of the id is validated, never its existence — the partition
+ * already carries your project, so an id that matches nothing simply addresses an
+ * empty scope rather than returning 404.
+ */
+export type MemoryScopeQuery = string;
+/** A stored fact, as returned when it is created. */
+export interface MemoryRecord {
+    id: string;
+    scope: MemoryScope;
+    createdAt: string;
+    /**
+     * When the fact self-deletes. Present only when it was stored with `ttlSeconds`,
+     * or when the key is a test-mode key (forced to 30 days).
+     */
+    expiresAt?: string;
+}
+/** A stored fact as returned by a read. `score` appears only on search results. */
+export interface Memory {
+    id: string;
+    /** The remembered text. */
+    text?: string;
+    metadata?: {
+        [key: string]: string;
+    };
+    /**
+     * Cosine similarity to the query, 0 to 1, higher being closer. Present on search
+     * results only — a list or a single read has no query to score against.
+     */
+    score?: number;
+    createdAt: string;
+    expiresAt?: string;
+}
+/**
+ * Store one fact. It is embedded on write, so it becomes searchable by meaning
+ * rather than by keyword.
+ */
+export interface MemoryAddRequest {
+    /**
+     * What to remember. Max 8,192 bytes of UTF-8. Write one fact per call: a paragraph
+     * holding five unrelated facts embeds as an average of all five and is retrieved
+     * well by none of them.
+     */
+    text: string;
+    scope?: MemoryScope;
+    /** Required when `scope` is `contact`. */
+    contactId?: string;
+    /** Required when `scope` is `conversation`. */
+    conversationId?: string;
+    /**
+     * Arbitrary string tags stored alongside the fact and returned with it. Keys max
+     * 64 chars, values max 512, whole object max 2,048 bytes. Not searchable —
+     * search matches `text` only.
+     */
+    metadata?: {
+        [key: string]: string;
+    };
+    /**
+     * Delete the fact after this many seconds. 60 to 63,072,000 (2 years). Omit to
+     * keep it until deleted.
+     */
+    ttlSeconds?: number;
+}
+/**
+ * Retrieve facts by meaning. The query is embedded and compared against every fact
+ * in the scope.
+ */
+export interface MemorySearchRequest {
+    /**
+     * What to recall. Max 8,192 bytes. Phrase it as the fact you hope to find, not as
+     * a keyword: the match is semantic.
+     */
+    query: string;
+    scope?: MemoryScope;
+    /** Required when `scope` is `contact`. */
+    contactId?: string;
+    /** Required when `scope` is `conversation`. */
+    conversationId?: string;
+    /**
+     * Maximum hits to return, closest first.
+     *
+     * @defaultValue `5`
+     */
+    limit?: number;
+    /**
+     * Drop hits below this similarity. Without it every scope returns its `limit`
+     * closest facts, however far away they are — an empty-handed search still
+     * answers with something. Set it (0.3 or above is a reasonable floor) when
+     * "nothing relevant" must be distinguishable from "the least irrelevant thing I
+     * hold".
+     */
+    minScore?: number;
+}
+/**
+ * This month's Memory consumption for the project, with the quota it is measured
+ * against.
+ */
+export interface MemoryUsage {
+    /** The month these counters cover. They reset on the 1st. */
+    monthKey: string;
+    /** Plan tier the quotas come from. */
+    tier: string;
+    /**
+     * Billable units consumed this month. Units are metered from real capacity, and a
+     * write costs 5x a read.
+     */
+    units: number;
+    reads: number;
+    writes: number;
+    /** Facts stored this month. */
+    memAdds: number;
+    /** Semantic searches run this month. */
+    memSearches: number;
+    /**
+     * Whether the plan's unit quota is exhausted. While true, writes are refused with
+     * `429`; reads and deletes keep working, so stored data is never locked away.
+     */
+    capReached: boolean;
+    /** Units included in the plan. Null means unlimited. */
+    quotaUnits?: number | null;
+    /**
+     * Bytes currently stored across facts and collections. Items with a TTL count as
+     * zero.
+     */
+    memoryBytes: number;
+    /** Storage included in the plan, in GB. Null means unlimited. */
+    quotaStorageGB?: number | null;
+}
+/** A namespace of JSON documents addressed by key. */
+export interface MemoryCollection {
+    name: string;
+    /**
+     * Fields that `POST /v1/memory/collections/{collection}/query` can filter on.
+     * Immutable after creation.
+     */
+    indexes: Array<MemoryCollectionIndexesItem>;
+    /**
+     * TTL applied to items written without their own `ttlSeconds`. Null means items
+     * are kept until deleted.
+     */
+    defaultTtlSeconds: number | null;
+    /** `active`, or `deleting` while a delete drains in the background. */
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MemoryCollectionIndexesItem {
+    field: string;
+}
+export interface MemoryCollectionCreateRequest {
+    /**
+     * 1-63 chars: lowercase letters, digits, `-` and `_`, starting with a letter or
+     * digit.
+     */
+    name: string;
+    /**
+     * Up to 2 fields to index for `query`. **This is the only way to declare them**
+     * — a collection created implicitly by its first write has none, and querying an
+     * unindexed field returns `400 field_not_indexed`. Indexes cannot be added later,
+     * so declare them here before the first write.
+     */
+    indexes?: Array<MemoryCollectionCreateRequestIndexesItem>;
+    defaultTtlSeconds?: number;
+}
+export interface MemoryCollectionCreateRequestIndexesItem {
+    /**
+     * 1-64 chars: letters, digits and `_`, starting with a letter. Top-level field of
+     * the stored document.
+     */
+    field: string;
+}
+/** Only the default TTL is mutable. Indexes are fixed at creation. */
+export interface MemoryCollectionUpdateRequest {
+    /** New default TTL, or null to clear it. */
+    defaultTtlSeconds: number | null;
+}
+/** One JSON document in a collection. */
+export interface MemoryItem {
+    key: string;
+    /** The stored JSON. Any JSON value. */
+    value?: unknown;
+    /**
+     * Revision, incremented on every write. Pass it as `If-Match` on a later write to
+     * make that write conditional.
+     */
+    rev: number;
+    createdAt: string;
+    updatedAt: string;
+    expiresAt?: string;
+}
+export interface MemoryItemPutRequest {
+    /**
+     * The document to store. Any JSON value, max 200KB serialized and 32 levels deep.
+     * This is a whole-document write, not a merge: it replaces whatever the key held.
+     */
+    value: unknown;
+    /** Overrides the collection's `defaultTtlSeconds` for this item. */
+    ttlSeconds?: number;
+}
+/** Look items up by an indexed field instead of by key. */
+export interface MemoryItemQueryRequest {
+    /**
+     * One condition on one indexed field. `between` bounds are inclusive and must be
+     * the same type.
+     */
+    where: MemoryItemQueryRequestWhere;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+export interface MemoryItemQueryRequestWhere {
+    field: string;
+    op: MemoryItemQueryRequestWhereOp;
+    /**
+     * The value to match. Used by `eq` (string, number or boolean) and `beginsWith`
+     * (string).
+     */
+    value?: unknown;
+    /** Lower bound, for `between`. */
+    from?: unknown;
+    /** Upper bound, for `between`. */
+    to?: unknown;
+}
+export type MemoryItemQueryRequestWhereOp = 'eq' | 'beginsWith' | 'between';
+/**
+ * Up to 25 writes and deletes in one call. Operations are NOT atomic: each is
+ * reported on its own, and a failure in one does not roll the others back.
+ */
+export interface MemoryItemBatchRequest {
+    ops: Array<MemoryItemBatchRequestOpsItem>;
+}
+export interface MemoryItemBatchRequestOpsItem {
+    op: MemoryItemBatchRequestOpsItemOp;
+    key: string;
+    /** The document, for `set`. */
+    value?: unknown;
+    ttlSeconds?: number;
+}
+export type MemoryItemBatchRequestOpsItemOp = 'set' | 'delete';
+export interface MemoryItemBatchResponse {
+    /**
+     * One entry per submitted operation, in order. Check every `ok`: the call returns
+     * 200 even when some operations failed.
+     */
+    results: Array<MemoryItemBatchResponseResultsItem>;
+}
+export interface MemoryItemBatchResponseResultsItem {
+    key: string;
+    ok: boolean;
+    /** New revision, on a successful `set`. */
+    rev?: number;
+    /** Why this operation failed. Present when `ok` is false. */
+    error?: string;
+}
+/** A subscription that runs a Zavu Function when a messaging event fires. */
+export interface FunctionTrigger {
+    id: string;
+    functionId: string;
+    /**
+     * Event type that fires the function. See GET /v1/functions/event-types for the
+     * supported list. The special type `cron` fires on a schedule instead of a
+     * messaging event and carries a `cron` expression.
+     */
+    eventType: string;
+    /** Restrict the trigger to a single sender. Null means all senders in the project. */
+    senderId?: string | null;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * 5-field cron expression (minute hour day-of-month month day-of-week), evaluated
+     * in UTC. Present only on `cron` triggers.
+     */
+    cron?: string | null;
+    /** Next scheduled fire time. Present only on `cron` triggers. */
+    nextRunAt?: string | null;
+    /** Last time the schedule fired. Null until the first fire. */
+    lastRunAt?: string | null;
+}
+/**
+ * Fields to update on a knowledge base document. Updating content reprocesses the
+ * document for RAG.
+ */
+export interface DocumentUpdateRequest {
+    title?: string;
+    content?: string;
+}
+export interface Error {
+    code: string;
+    message: string;
+    details?: {
+        [key: string]: unknown;
+    };
+}
+export type MessageStatus = 'queued' | 'sending' | 'sent' | 'delivered' | 'read' | 'failed' | 'received' | 'pending_url_verification';
+/** Delivery channel. Use 'auto' for intelligent routing. */
+export type Channel = 'auto' | 'sms' | 'sms_oneway' | 'whatsapp' | 'telegram' | 'email' | 'instagram' | 'messenger' | 'voice';
+/**
+ * Type of message. Non-text types are supported by WhatsApp and Telegram (varies
+ * by type).
+ *
+ * `location_request` asks the recipient to share their location and is
+ * WhatsApp-only. It takes no `content` object — the prompt goes in `text` (max
+ * 1024 characters) and the button label is fixed by WhatsApp. The recipient's
+ * answer arrives as an inbound `location` message whose `content.replyToMessageId`
+ * is the ID of the request.
+ *
+ * `request_contact_info` asks the recipient to share their phone number and is
+ * WhatsApp-only. Like `location_request` it takes no `content` object — the
+ * prompt goes in `text` (max 1024 characters) and WhatsApp renders a fixed **Share
+ * Contact Info** button. The answer arrives as an inbound `contact` message. Use
+ * it to recover the phone number of a contact who adopted a WhatsApp username and
+ * is only known by their business-scoped user ID (BSUID); when they share it, Zavu
+ * automatically links the phone number to that contact.
+ */
+export type MessageType = 'text' | 'image' | 'video' | 'audio' | 'document' | 'sticker' | 'location' | 'contact' | 'buttons' | 'list' | 'cta_url' | 'request_contact_info' | 'location_request' | 'reaction' | 'template';
+/** Content for non-text message types (WhatsApp and Telegram). */
+export interface MessageContent {
+    /** URL of the media file (for image, video, audio, document, sticker). */
+    mediaUrl?: string;
+    /** WhatsApp media ID if already uploaded. */
+    mediaId?: string;
+    /** MIME type of the media. */
+    mimeType?: string;
+    /** Filename for documents. */
+    filename?: string;
+    /** Latitude for location messages. */
+    latitude?: number;
+    /** Longitude for location messages. */
+    longitude?: number;
+    /** Name of the location. */
+    locationName?: string;
+    /** Address of the location. */
+    locationAddress?: string;
+    /** Contact cards for contact messages. */
+    contacts?: Array<MessageContentContactsItem>;
+    /** Interactive buttons (max 3). */
+    buttons?: Array<MessageContentButtonsItem>;
+    /** Button text for list messages. */
+    listButton?: string;
+    /** Sections for list messages. */
+    sections?: Array<MessageContentSectionsItem>;
+    /** Button label for cta_url messages. */
+    ctaDisplayText?: string;
+    /**
+     * Destination URL opened in the device's default browser when the button is
+     * tapped. Used with messageType=cta_url. WhatsApp requires HTTPS in production.
+     */
+    ctaUrl?: string;
+    /** Optional header type for cta_url messages. */
+    ctaHeaderType?: MessageContentCtaHeaderType;
+    /** Header text when ctaHeaderType is 'text'. */
+    ctaHeaderText?: string;
+    /**
+     * Public HTTPS URL of the header media when ctaHeaderType is 'image', 'video', or
+     * 'document'. WhatsApp fetches this URL — it must be publicly reachable and
+     * return the declared content type.
+     */
+    ctaHeaderMediaUrl?: string;
+    /** Optional footer text for cta_url messages. */
+    footerText?: string;
+    /** Emoji for reaction messages. */
+    emoji?: string;
+    /** Message ID to react to. */
+    reactToMessageId?: string;
+    /**
+     * Zavu message ID of the quoted message this message replies to. Present on
+     * inbound messages that quote an earlier message. Omitted when the quoted message
+     * is not found in Zavu (e.g. an old or unknown message) — use
+     * replyToProviderMessageId in that case.
+     */
+    replyToMessageId?: string;
+    /**
+     * Provider message ID (WhatsApp WAMID) of the quoted message. Present whenever an
+     * inbound message is a reply, even if the quoted message is not stored in Zavu.
+     */
+    replyToProviderMessageId?: string;
+    /** Sender of the quoted message (phone number in E.164 format). */
+    replyToFrom?: string;
+    /**
+     * Truncated snippet of the quoted message's text, for display. Empty when the
+     * quoted message has no text (e.g. media).
+     */
+    replyToText?: string;
+    /** Type of the quoted message (text, image, video, etc.). */
+    replyToMessageType?: string;
+    /** Template ID for template messages. */
+    templateId?: string;
+    /**
+     * Variables for body placeholders. Key them to match the template body: by
+     * position (`1`, `2`, ...) for positional templates, or by name (e.g.
+     * `customer_name`) for named templates. Zavu detects the template's format and
+     * sends the correct payload to Meta. Named keys also resolve a named text-header
+     * variable. Do not mix positional and named keys in the same request.
+     */
+    templateVariables?: {
+        [key: string]: string;
+    };
+    /**
+     * Variables for dynamic button placeholders (URL buttons and OTP buttons). Keys
+     * are the button index (0, 1, 2) in the template's `buttons` array — not the
+     * placeholder name. Values substitute the `{{1}}` placeholder inside that button's
+     * URL.
+     *
+     * **WhatsApp constraints:**
+     * - URL buttons only accept `{{1}}` — positional, numeric, no whitespace, no
+     *   name. Named placeholders like `{{token}}` are stored as literal URL text by
+     *   Meta and cannot be substituted.
+     * - At most one placeholder per URL button.
+     * - A template may have at most three buttons.
+     * - Static URL buttons (no placeholder) and `quick_reply` buttons are not included
+     *   here.
+     */
+    templateButtonVariables?: {
+        [key: string]: string;
+    };
+    /**
+     * Value for a text-header variable, keyed by `1` (WhatsApp text headers allow at
+     * most one variable). Optional override. If omitted, Zavu resolves the header from
+     * `templateVariables` using the header placeholder's name (e.g. `novios`). Static
+     * text headers need no value.
+     */
+    templateHeaderVariables?: {
+        [key: string]: string;
+    };
+    referral?: AdReferral;
+}
+export interface MessageContentContactsItem {
+    name?: string;
+    phones?: Array<string>;
+}
+export interface MessageContentButtonsItem {
+    id: string;
+    title: string;
+}
+export interface MessageContentSectionsItem {
+    title: string;
+    rows: Array<MessageContentSectionsItemRowsItem>;
+}
+export interface MessageContentSectionsItemRowsItem {
+    id: string;
+    title: string;
+    description?: string;
+}
+export type MessageContentCtaHeaderType = 'text' | 'image' | 'video' | 'document';
+/**
+ * Click-to-WhatsApp (CTWA) ad attribution: where an inbound conversation came
+ * from.
+ *
+ * WhatsApp only. Present on the **first inbound message** of a conversation opened
+ * from a Meta ad or post, and on no message after it — so store it when it
+ * arrives rather than expecting it again. Organic conversations never carry it.
+ *
+ * Field names are camelCased to match the rest of this API; Meta sends them as
+ * snake_case (`ctwa_clid`, `source_id`, ...). Fields that do not apply are
+ * omitted: a `post` source has no click id, and an image ad has no `videoUrl`.
+ */
+export interface AdReferral {
+    /** Where the click came from. */
+    sourceType?: AdReferralSourceType;
+    /** Identifier of the ad or post that produced the click. */
+    sourceId?: string;
+    /** Meta permalink to the ad or post. */
+    sourceUrl?: string;
+    /** Headline of the ad or post. */
+    headline?: string;
+    /** Body copy of the ad or post. */
+    body?: string;
+    /** Type of media on the ad, when it had any. */
+    mediaType?: AdReferralMediaType;
+    /** Image of the ad. Present when `mediaType` is `image`. */
+    imageUrl?: string;
+    /** Video of the ad. Present when `mediaType` is `video`. */
+    videoUrl?: string;
+    /** Thumbnail of the ad media. */
+    thumbnailUrl?: string;
+    /**
+     * Click-to-WhatsApp click identifier. This is the value Meta's Conversions API
+     * needs to credit a conversion back to the ad that produced the conversation.
+     * Present on `ad` sources; a `post` source has none.
+     */
+    ctwaClid?: string;
+}
+export type AdReferralSourceType = 'ad' | 'post';
+export type AdReferralMediaType = 'image' | 'video';
+/** Email attachment. Provide either `content` (base64) or `path` (URL), not both. */
+export interface EmailAttachmentInput {
+    /** Name of the attached file. */
+    filename: string;
+    /** Content of the attached file as a Base64-encoded string. */
+    content?: string;
+    /** URL where the attachment file is hosted. The server will fetch the file. */
+    path?: string;
+    /** MIME type of the attachment. If not set, will be derived from the filename. */
+    content_type?: string;
+    /**
+     * Content ID for inline images. Reference in HTML as `<img
+     * src="cid:your_content_id">`.
+     */
+    content_id?: string;
+}
+/** Request body to send a message. */
+export interface MessageRequest {
+    /**
+     * Recipient phone number in E.164 format, email address, WhatsApp business-scoped
+     * user ID (BSUID, e.g. `US.13491208655302741918`), or numeric chat ID (for
+     * Telegram/Instagram/Messenger). A BSUID is routed to WhatsApp and sent via the
+     * `recipient` field; use it to message a contact who adopted a username and whose
+     * phone number is hidden.
+     */
+    to: string;
+    /**
+     * Delivery channel. Use 'auto' for intelligent routing. If omitted, channel is
+     * auto-selected based on sender capabilities and recipient type. For email
+     * recipients, defaults to 'email'.
+     *
+     * @defaultValue `"auto"`
+     */
+    channel?: Channel;
+    /**
+     * Type of message. Defaults to 'text'.
+     *
+     * @defaultValue `"text"`
+     */
+    messageType?: MessageType;
+    /** Text body for text messages or caption for media messages. */
+    text?: string;
+    /** Additional content for non-text message types. */
+    content?: MessageContent;
+    /**
+     * Email subject line. Required when channel is 'email' or recipient is an email
+     * address.
+     */
+    subject?: string;
+    /**
+     * HTML body for email messages. If provided, email will be sent as multipart with
+     * both text and HTML.
+     */
+    htmlBody?: string;
+    /** Reply-To email address for email messages. */
+    replyTo?: string;
+    /** Optional idempotency key to avoid duplicate sends. */
+    idempotencyKey?: string;
+    /** Arbitrary metadata to associate with the message. */
+    metadata?: {
+        [key: string]: string;
+    };
+    /**
+     * Whether a failed WhatsApp text or template message is retried over SMS, when the
+     * sender also has SMS. When omitted, it is on if `channel` is omitted or `auto`,
+     * and off if a channel is set explicitly: a send with `channel: "whatsapp"` does
+     * not fall back unless this is `true`. Media, buttons, lists and other
+     * WhatsApp-only types never fall back.
+     */
+    fallbackEnabled?: boolean;
+    /**
+     * Language code for voice text-to-speech (e.g., 'en-US', 'es-ES', 'pt-BR'). If
+     * omitted, language is auto-detected from recipient's country code.
+     */
+    voiceLanguage?: string;
+    /**
+     * Email attachments. Only supported when channel is 'email'. Maximum 40MB total
+     * size.
+     */
+    attachments?: Array<EmailAttachmentInput>;
+}
+export interface Message {
+    id: string;
+    to: string;
+    from?: string;
+    senderId?: string;
+    channel: Channel;
+    /**
+     * Who sent the message. Needed to render a thread: `status` cannot tell the two
+     * apart, because an inbound message is also stored as `delivered`.
+     */
+    direction: MessageDirection;
+    messageType: MessageType;
+    status: MessageStatus;
+    /** Text content or caption. */
+    text?: string;
+    content?: MessageContent;
+    /**
+     * ID of the conversation (inbox thread) this message belongs to. Use it to build a
+     * direct dashboard link:
+     * `https://dashboard.zavu.dev/{locale}/inbox?conv={conversationId}`. Omitted only
+     * on legacy messages created before conversation threading.
+     */
+    conversationId?: string;
+    /** Message ID from the delivery provider. */
+    providerMessageId?: string;
+    errorCode?: string | null;
+    errorMessage?: string | null;
+    /**
+     * Zavu platform charge in USD for this message. Messaging is billed against your
+     * plan's monthly limits plus usage-based overage.
+     */
+    cost?: number | null;
+    /** Carrier and delivery cost in USD. */
+    costProvider?: number | null;
+    /** Total cost in USD (platform charge + delivery cost). */
+    costTotal?: number | null;
+    metadata?: {
+        [key: string]: string;
+    };
+    createdAt: string;
+    updatedAt?: string;
+}
+export type MessageDirection = 'inbound' | 'outbound';
+export interface MessageResponse {
+    message: Message;
+}
+/** A stored file attachment for an email message (inbound or outbound). */
+export interface MessageAttachment {
+    id: string;
+    filename: string;
+    /** MIME type of the attachment. */
+    mimeType: string;
+    /** Size of the attachment in bytes. */
+    size: number;
+    /**
+     * Content-ID for inline attachments (referenced in the HTML body as
+     * `cid:<contentId>`). Null for regular attachments.
+     */
+    contentId: string | null;
+    /**
+     * Whether the attachment is inline (embedded in the HTML body) rather than a
+     * regular attachment.
+     */
+    isInline: boolean;
+    /**
+     * Short-lived signed URL to download the attachment bytes. Freshly generated on
+     * each request and expires; do not cache it. Null if the stored file is no longer
+     * available.
+     */
+    downloadUrl: string | null;
+    createdAt: string;
+}
+export interface MessageAttachmentsResponse {
+    items: Array<MessageAttachment>;
+}
+/** WhatsApp template category. */
+export type WhatsAppCategory = 'UTILITY' | 'MARKETING' | 'AUTHENTICATION';
+export interface Template {
+    id: string;
+    /** Template name. For WhatsApp, must match the approved template name in Meta. */
+    name: string;
+    /** Language code. */
+    language: string;
+    /**
+     * Default template body with variables: positional ({{1}}, {{2}}) or named
+     * ({{customer_name}}, {{contact.first_name}}). Templates created in Zavu are
+     * submitted to Meta as positional; templates imported from a WhatsApp Business
+     * Account keep their original format (named or positional). Used when no
+     * channel-specific body is set.
+     */
+    body: string;
+    /** Channel-specific body for SMS messages. Falls back to `body` if not set. */
+    smsBody?: string;
+    /** Channel-specific body for Telegram messages. Falls back to `body` if not set. */
+    telegramBody?: string;
+    /** Channel-specific body for Instagram messages. Falls back to `body` if not set. */
+    instagramBody?: string;
+    /**
+     * The category the template is billed under. For a template linked to WhatsApp
+     * this is the category **Meta currently assigns**, not the one it was submitted
+     * with: Meta can recategorize a template at approval or at any point afterwards,
+     * and that changes what the message costs.
+     *
+     * A recategorization reaches this field through the `template.status_changed`
+     * webhook, which carries `data.category`, and through `POST /v1/templates/sync`,
+     * which reconciles it against Meta. Read one of those rather than assuming the
+     * category you sent is the one in force.
+     *
+     * For a template that was never submitted to WhatsApp, this is the category stored
+     * locally, defaulting to `UTILITY`.
+     */
+    category: WhatsAppCategory;
+    /** @defaultValue `"draft"` */
+    status?: TemplateStatus;
+    /** List of variable names for documentation. */
+    variables?: Array<string>;
+    /** Type of header (text, image, video, document). */
+    headerType?: string;
+    /** Header content (text or media URL). */
+    headerContent?: string;
+    /** Footer text for the template. */
+    footer?: string;
+    /** Template buttons. */
+    buttons?: Array<TemplateButtonsItem>;
+    /** Add 'Do not share this code' disclaimer. Only for AUTHENTICATION templates. */
+    addSecurityRecommendation?: boolean;
+    /** Code expiration time in minutes. Only for AUTHENTICATION templates. */
+    codeExpirationMinutes?: number;
+    /** WhatsApp-specific template information. */
+    whatsapp?: TemplateWhatsapp;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export type TemplateStatus = 'draft' | 'pending' | 'approved' | 'rejected';
+export interface TemplateButtonsItem {
+    type?: TemplateButtonsItemType;
+    text?: string;
+    url?: string;
+    /**
+     * Sample value used to substitute `{{1}}` in the URL when submitting the template
+     * to Meta for review. Only present for dynamic URL buttons.
+     */
+    example?: string;
+    phoneNumber?: string;
+    /** OTP button type. Required when type is 'otp'. */
+    otpType?: TemplateButtonsItemOtpType;
+    /** Android package name. Required for ONE_TAP buttons. */
+    packageName?: string;
+    /** Android app signature hash. Required for ONE_TAP buttons. */
+    signatureHash?: string;
+}
+export type TemplateButtonsItemType = 'quick_reply' | 'url' | 'phone' | 'otp' | 'request_contact_info';
+export type TemplateButtonsItemOtpType = 'COPY_CODE' | 'ONE_TAP';
+export interface TemplateWhatsapp {
+    /** WhatsApp template name. */
+    templateName?: string;
+    /** WhatsApp Business Account namespace. */
+    namespace?: string;
+    /** WhatsApp approval status. */
+    status?: string;
+}
+export interface TemplateCreateRequest {
+    name: string;
+    /** @defaultValue `"en"` */
+    language: string;
+    /** Default template body. Used when no channel-specific body is set. */
+    body: string;
+    /** Channel-specific body for SMS. Falls back to `body` if not set. */
+    smsBody?: string;
+    /** Channel-specific body for Telegram. Falls back to `body` if not set. */
+    telegramBody?: string;
+    /** Channel-specific body for Instagram. Falls back to `body` if not set. */
+    instagramBody?: string;
+    whatsappCategory?: WhatsAppCategory;
+    /** Type of header for the template. */
+    headerType?: TemplateCreateRequestHeaderType;
+    /** Header content (text string or media URL). */
+    headerContent?: string;
+    /** Footer text for the template. */
+    footer?: string;
+    variables?: Array<string>;
+    /** Template buttons (max 3). */
+    buttons?: Array<TemplateCreateRequestButtonsItem>;
+    /** Add 'Do not share this code' disclaimer. Only for AUTHENTICATION templates. */
+    addSecurityRecommendation?: boolean;
+    /** Code expiration time in minutes. Only for AUTHENTICATION templates. */
+    codeExpirationMinutes?: number;
+}
+export type TemplateCreateRequestHeaderType = 'text' | 'image' | 'video' | 'document';
+export interface TemplateCreateRequestButtonsItem {
+    /**
+     * `request_contact_info` renders a fixed **Share Contact Info** button that asks
+     * the recipient to share their phone number — useful when a contact adopted a
+     * WhatsApp username and you only know their BSUID. It takes no other fields.
+     */
+    type: TemplateCreateRequestButtonsItemType;
+    /**
+     * Button label. Required for every type except `request_contact_info`, whose label
+     * is fixed by WhatsApp.
+     */
+    text?: string;
+    /**
+     * Button destination. Use `{{1}}` exactly once for a dynamic URL (e.g.
+     * `https://example.com/orders/{{1}}`); WhatsApp only accepts the strict `{{1}}`
+     * form. Static URLs must not contain any `{{...}}` placeholder.
+     */
+    url?: string;
+    /**
+     * Sample value Meta uses to review templates with a dynamic URL button.
+     * Substituted into `{{1}}` of the URL when the template is submitted to Meta. Only
+     * meaningful when `url` contains `{{1}}`; ignored for static URLs.
+     */
+    example?: string;
+    phoneNumber?: string;
+    /**
+     * Required when type is 'otp'. COPY_CODE shows copy button, ONE_TAP enables
+     * Android autofill.
+     */
+    otpType?: TemplateCreateRequestButtonsItemOtpType;
+    /** Android package name. Required for ONE_TAP buttons. */
+    packageName?: string;
+    /** Android app signature hash. Required for ONE_TAP buttons. */
+    signatureHash?: string;
+}
+export type TemplateCreateRequestButtonsItemType = 'quick_reply' | 'url' | 'phone' | 'otp' | 'request_contact_info';
+export type TemplateCreateRequestButtonsItemOtpType = 'COPY_CODE' | 'ONE_TAP';
+/**
+ * Type of event that triggers the webhook.
+ *
+ * **Message lifecycle events:**
+ * - `message.queued`: Message created and queued for sending. `data.status` =
+ *   `queued`
+ * - `message.sent`: Message accepted by the provider. `data.status` = `sent`
+ * - `message.delivered`: Message delivered to recipient. `data.status` =
+ *   `delivered`
+ * - `message.read`: Message was read by the recipient (WhatsApp only).
+ *   `data.status` = `read`
+ * - `message.failed`: Message failed to send. `data.status` = `failed`
+ *
+ * **Inbound events:**
+ * - `message.inbound`: New message received from a contact. `data.conversationId`,
+ *   the inbox thread id (deep-link with
+ *   `https://dashboard.zavu.dev/{locale}/inbox?conv={conversationId}`), is sent on
+ *   **email** messages only, and is `null` there on the first message of a
+ *   brand-new thread. On every other channel it is absent: read it from `GET
+ *   /v1/messages/{messageId}`, which always has it, or from `conversation.new` for
+ *   a new contact. Reactions are delivered as `message.inbound` with
+ *   `messageType='reaction'`. When the contact replied to (quoted) an earlier
+ *   message, `data.content` carries the reply context: `replyToMessageId`,
+ *   `replyToProviderMessageId`, `replyToFrom`, `replyToText`, and
+ *   `replyToMessageType`. `data.providerTimestamp` is the provider's original
+ *   receive time in Unix milliseconds (the moment the channel received the message
+ *   from the contact — WhatsApp, Telegram, Instagram, Messenger; `null` for SMS
+ *   and email). Compare it against the top-level `timestamp` (when Zavu dispatched
+ *   the webhook) to detect and ignore delayed deliveries. When the conversation
+ *   was opened from a Click-to-WhatsApp ad or post, `data.referral` carries the ad
+ *   attribution — including `ctwaClid`, the identifier Meta's Conversions API
+ *   needs to credit a conversion back to that ad. WhatsApp only, and only on the
+ *   first message of the thread: it is absent from every later message, so persist
+ *   it when it arrives.
+ * - `message.unsupported`: Received a message type that is not supported
+ *
+ * **Broadcast events:**
+ * - `broadcast.status_changed`: Broadcast status changed (pending_review,
+ *   approved, rejected, sending, completed, cancelled)
+ *
+ * **Other events:**
+ * - `conversation.new`: New conversation started with a contact. `data` carries
+ *   `conversationId` (the inbox thread id — deep-link with
+ *   `https://dashboard.zavu.dev/{locale}/inbox?conv={conversationId}`), the
+ *   `phoneNumber` or `email` key, `channel`, `firstMessageId`, `firstMessageText`,
+ *   and `profileName`.
+ * - `template.status_changed`: WhatsApp template approval status changed. `data`
+ *   carries `templateId`, `name`, `previousStatus`, `currentStatus`,
+ *   `rejectionReason`, and `category` — the category Meta currently bills the
+ *   template under. Meta can recategorize a template (typically `UTILITY` to
+ *   `MARKETING`) at approval or long afterwards, which changes what each message
+ *   costs; `category` is how that reaches you. A recategorization with no status
+ *   change is delivered as this same event, so compare `category` against what you
+ *   hold rather than only reacting to `currentStatus`.
+ *
+ * **Partner events:**
+ * - `invitation.status_changed`: A partner invitation's stored status changed: to
+ *   `in_progress`, `completed`, `failed`, `cancelled`, or back to `pending` when
+ *   it is resent from the dashboard. A change to the same status sends nothing,
+ *   and expiry is not a stored change, so no event is sent when an invitation
+ *   expires. Delivered to the project webhook (`POST /v1/invitations/webhook`) of
+ *   the project that created the invitation; a parent project does not receive its
+ *   sub-accounts' events. `data` carries `invitationId`, `clientName`,
+ *   `clientEmail`, `connectionType` (`whatsapp_waba` or `messenger`),
+ *   `previousStatus`, and `currentStatus`. On `completed` it also carries
+ *   `senderId`, `connectedAccount` (`channel`, `id`, `name`) — the WhatsApp
+ *   number or Facebook Page that was linked — and, for WhatsApp,
+ *   `wabaAccountId`. On `failed` it carries `failureReason`; the invitation link
+ *   stays usable, so a client can retry it.
+ *
+ * **Voice Agent events:**
+ * For every voice event, `data` carries `callId`, `direction`, `from`, `to`,
+ * `status`, `durationSeconds`, `endReason`, and `transcriptAvailable`. The
+ * terminal events (`call.completed`, `call.failed`) additionally carry `cost` —
+ * what the call was billed, in USD, combining telephony and the managed voice
+ * pipeline — and `currency`. They are dispatched after the call is charged, so
+ * `cost` is populated rather than zero; telephony can still be settling on an
+ * outbound call, in which case `GET /v1/calls/{callId}` holds the reconciled
+ * figure.
+ * - `call.initiated`: An outbound call was created and is dialing, or an inbound
+ *   call was received. `data.status` = `ringing`
+ * - `call.answered`: The call was answered and the voice agent is connected.
+ *   `data.status` = `in_progress`
+ * - `call.completed`: The call ended after a conversation. `data.status` =
+ *   `completed`; `durationSeconds` and `endReason` describe how it ended, and
+ *   `transcriptAvailable` indicates whether a transcript can be fetched.
+ * - `call.failed`: The call could not be completed (busy, no answer, canceled, or
+ *   an error). `data.status` is the terminal status and `endReason` explains the
+ *   cause.
+ *
+ * **Custom domain events:**
+ * - `domain.verified`: A custom email domain passed verification (DKIM, and
+ *   SPF/DMARC/MAIL FROM if enhanced records are enabled)
+ * - `domain.failed`: A custom email domain failed verification or is partially
+ *   verified
+ */
+export type WebhookEvent = 'message.queued' | 'message.sent' | 'message.delivered' | 'message.read' | 'message.status' | 'message.failed' | 'message.inbound' | 'message.unsupported' | 'broadcast.status_changed' | 'conversation.new' | 'template.status_changed' | 'invitation.status_changed' | 'call.initiated' | 'call.answered' | 'call.completed' | 'call.failed' | 'domain.verified' | 'domain.failed';
+/** Webhook payload structure sent to your endpoint. */
+export interface WebhookPayload {
+    /** Unique event identifier. */
+    id: string;
+    type: WebhookEvent;
+    /** Unix timestamp in milliseconds when the event was created. */
+    timestamp: number;
+    /** ID of the sender associated with this event. */
+    senderId: string;
+    /** ID of the project. */
+    projectId: string;
+    /**
+     * Event-specific data. For message events, contains messageId, to, channel,
+     * status, errorCode, and errorMessage.
+     */
+    data: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Data payload for message webhook events (queued, sent, delivered, failed,
+ * inbound).
+ */
+export interface WebhookMessageData {
+    /** ID of the message. */
+    messageId: string;
+    /**
+     * Recipient phone number or email. On `message.inbound` this is your own number
+     * (the message's destination).
+     */
+    to: string;
+    /**
+     * Sender of the message. Present on `message.inbound`: the contact who sent the
+     * message.
+     */
+    from?: string;
+    channel: Channel;
+    status: MessageStatus;
+    /** Type of the message. Present on `message.inbound`. */
+    messageType?: MessageType;
+    /**
+     * ID of the conversation (inbox thread) this message belongs to. Sent on
+     * `message.inbound` for **email** messages only; on SMS, WhatsApp, Telegram,
+     * Instagram and Messenger it is absent. Use it to deep-link to the dashboard
+     * inbox: `https://dashboard.zavu.dev/{locale}/inbox?conv={conversationId}`. On
+     * email it is `null` on the first message of a brand-new thread. In every case,
+     * fetch it via `GET /v1/messages/{messageId}`, whose `conversationId` is always
+     * populated, or take it from the `conversation.new` event for a new contact.
+     */
+    conversationId?: string | null;
+    /**
+     * Text body or media caption. Present on `message.inbound` when the message has
+     * text.
+     */
+    text?: string;
+    /** Error code if the message failed. */
+    errorCode?: string | null;
+    /** Error message if the message failed. */
+    errorMessage?: string | null;
+    /**
+     * The provider's original receive time in Unix milliseconds (when the channel
+     * received the message from the contact). Present on `message.inbound` for
+     * channels that report it (WhatsApp, Telegram, Instagram, Messenger); null for SMS
+     * and email.
+     */
+    providerTimestamp?: number | null;
+    /**
+     * Click-to-WhatsApp ad attribution. Present on `message.inbound` only when this is
+     * the first message of a conversation opened from a Meta ad or post — absent on
+     * every later message in that same thread, and on organic conversations. Read
+     * `referral.ctwaClid` here to attribute the conversation, and persist it on your
+     * side: this webhook is the only delivery. `GET /v1/messages/{messageId}` also
+     * returns it, under `content.referral`.
+     */
+    referral?: AdReferral;
+}
+/** Webhook configuration for the sender. */
+export interface SenderWebhook {
+    /** HTTPS URL that will receive webhook events. */
+    url: string;
+    /** List of events the webhook is subscribed to. */
+    events: Array<WebhookEvent>;
+    /**
+     * Webhook secret for signature verification. Only returned on create or
+     * regenerate.
+     */
+    secret?: string;
+    /**
+     * Whether the webhook is active.
+     *
+     * @defaultValue `true`
+     */
+    active: boolean;
+    signatureVersion: WebhookSignatureVersion;
+}
+export interface Sender {
+    id: string;
+    name: string;
+    /**
+     * Phone number in E.164 format. Absent on a sender that has none: an email-only
+     * sender, or one created with only `enableSmsOneway`.
+     */
+    phoneNumber?: string;
+    /**
+     * Channels this sender can actually send on right now: configured AND activated.
+     * Empty means the sender cannot send or receive anything yet: a phoneNumber alone
+     * does not enable SMS or voice, and a connected account that is not activated is
+     * left out, because every send on it is refused. Check this rather than inferring
+     * capability from phoneNumber or emailAddress, and turn a connected channel on
+     * with `POST /v1/senders/{senderId}/channels/{channel}/activate`.
+     */
+    channels?: Array<string>;
+    /**
+     * Whether this sender is the project's default.
+     *
+     * @defaultValue `false`
+     */
+    isDefault?: boolean;
+    webhook?: SenderWebhook;
+    /** WhatsApp Business Account information. Only present if a WABA is connected. */
+    whatsapp?: SenderWhatsapp;
+    /** From-address for the email channel, if configured. */
+    emailAddress?: string;
+    /**
+     * Whether inbound email receiving is enabled for this sender.
+     *
+     * @defaultValue `false`
+     */
+    emailReceivingEnabled?: boolean;
+    /**
+     * Whether catch-all receiving is enabled. When true (and emailReceivingEnabled is
+     * true), this sender receives email addressed to any local part at its domain, not
+     * just its own address. The original recipient is delivered in the message.inbound
+     * webhook's data.to.
+     *
+     * @defaultValue `false`
+     */
+    emailCatchAllEnabled?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface SenderWhatsapp {
+    /** WhatsApp phone number ID from Meta. */
+    phoneNumberId?: string;
+    /** Display phone number. */
+    displayPhoneNumber?: string;
+    /** Payment configuration status from Meta. */
+    paymentStatus?: SenderWhatsappPaymentStatus;
+}
+export interface SenderWhatsappPaymentStatus {
+    /** Payment setup status (COMPLETE, NOT_STARTED, etc.). */
+    setupStatus?: string;
+    /** Payment method status (VALID, NONE, etc.). */
+    methodStatus?: string;
+    /**
+     * Whether template messages can be sent. Requires setupStatus=COMPLETE and
+     * methodStatus=VALID.
+     */
+    canSendTemplates?: boolean;
+}
+/**
+ * Create a sender. Provide `phoneNumber` for an SMS/WhatsApp sender,
+ * `emailAddress` (with a verified email domain) for an email sender, or
+ * `enableSmsOneway: true` for a zero-setup one-way SMS sender — at least one is
+ * required.
+ */
+export interface SenderCreateRequest {
+    name: string;
+    /**
+     * Phone number in E.164 format, and it must be a number your project already owns
+     * (see `GET /v1/phone-numbers`). The number is routed to the sender as part of
+     * this call, which is what turns the SMS channel on. Passing a number the project
+     * does not own, one already attached to another sender, or one rejected in
+     * regulatory review returns 400 rather than creating a sender that cannot send. A
+     * number still under review is attached and starts carrying messages when it is
+     * approved. Omit for an email-only sender.
+     */
+    phoneNumber?: string;
+    /**
+     * Let this sender place and answer phone calls. Requires `phoneNumber`; enabling
+     * it without one returns 400. Check the `channels` array on the response to
+     * confirm `voice` is on.
+     *
+     * @defaultValue `false`
+     */
+    enableVoice?: boolean;
+    /**
+     * Enable the one-way SMS channel (`sms_oneway`). No phone number and no
+     * credential, so it is the fastest way to get a sender that can send. Recipients
+     * cannot reply. Sending to a US or Canadian (+1) number still needs an approved
+     * 10DLC campaign, and is refused with `403 ten_dlc_required` until then. Confirm
+     * with `sms_oneway` in the `channels` array on the response.
+     *
+     * @defaultValue `false`
+     */
+    enableSmsOneway?: boolean;
+    /** @defaultValue `false` */
+    setAsDefault?: boolean;
+    /** HTTPS URL for webhook events. */
+    webhookUrl?: string;
+    /** Events to subscribe to. */
+    webhookEvents?: Array<WebhookEvent>;
+    /**
+     * From-address for the email channel (e.g. noreply@yourdomain.com). The address's
+     * domain must be a verified email domain in your project. Setting this attaches
+     * the email channel to the sender.
+     */
+    emailAddress?: string;
+    /**
+     * ID of the verified email domain to attach. Optional — resolved from
+     * `emailAddress`'s domain when omitted.
+     */
+    emailDomainId?: string;
+    /** Display name shown in the recipient's inbox for the email channel. */
+    emailFromName?: string;
+    /**
+     * Enable inbound email receiving on this sender. Requires a verified inbound MX
+     * record on the domain; the request is ignored otherwise. Read
+     * `emailReceivingEnabled` back off the response to see whether it was applied —
+     * it comes back `false` when the MX has not verified.
+     */
+    emailReceivingEnabled?: boolean;
+    /**
+     * Signature scheme for this sender's webhook. Defaults to `v2`, which is correct
+     * for a new receiver. Pass `v1+v2` when this sender points at an endpoint that
+     * already serves an older sender still verifying `v1`.
+     */
+    webhookSignatureVersion?: WebhookSignatureVersion;
+}
+export interface SenderUpdateRequest {
+    name?: string;
+    /**
+     * Turn the voice channel on or off. The sender must already have a phone number
+     * provisioned for calls; enabling it otherwise returns 400 instead of storing a
+     * flag that changes nothing. Confirm with the `channels` array on the response.
+     */
+    enableVoice?: boolean;
+    /**
+     * Turn the one-way SMS channel on or off. Enabling needs no number or credential
+     * and takes effect immediately (US and Canadian destinations still need an
+     * approved 10DLC campaign); disabling removes the channel from the sender. Confirm
+     * with the `channels` array on the response.
+     */
+    enableSmsOneway?: boolean;
+    setAsDefault?: boolean;
+    /** HTTPS URL for webhook events. Set to null to remove webhook. */
+    webhookUrl?: string | null;
+    /** Events to subscribe to. */
+    webhookEvents?: Array<WebhookEvent>;
+    /** Whether the webhook is active. */
+    webhookActive?: boolean;
+    /**
+     * Enable or disable inbound email receiving for this sender. Enabling requires a
+     * verified inbound MX record on the domain; the request is ignored otherwise, and
+     * `emailReceivingEnabled` comes back `false` on the response. Disabling always
+     * applies.
+     */
+    emailReceivingEnabled?: boolean;
+    /**
+     * Enable or disable domain catch-all. When enabled (with emailReceivingEnabled
+     * true), this sender receives email for any address at its domain. Ignored
+     * (treated as false) if receiving is not enabled.
+     */
+    emailCatchAllEnabled?: boolean;
+    /**
+     * Attach or change the sender's email from-address (e.g. noreply@yourdomain.com).
+     * The domain must be a verified email domain in your project.
+     */
+    emailAddress?: string;
+    /**
+     * ID of the verified email domain to attach. Optional — resolved from
+     * `emailAddress`'s domain when omitted.
+     */
+    emailDomainId?: string;
+    /** Display name shown in the recipient's inbox for the email channel. */
+    emailFromName?: string;
+    /**
+     * Move this webhook between signature schemes. `v1` -> `v2` directly returns
+     * `400`; go through `v1+v2` first. See
+     * https://docs.zavu.dev/guides/receiving-messages/signature-migration
+     */
+    webhookSignatureVersion?: WebhookSignatureVersion;
+}
+export interface WebhookSecretResponse {
+    /** The new webhook secret. */
+    secret: string;
+}
+/** A communication channel for a contact. */
+export interface ContactChannel {
+    id: string;
+    /** Channel type. */
+    channel: ContactChannelChannel;
+    /** Channel identifier (phone number or email address). */
+    identifier: string;
+    /** ISO country code for phone numbers. */
+    countryCode?: string;
+    /** Optional label for the channel. */
+    label?: string;
+    /** Whether this is the primary channel for its type. */
+    isPrimary: boolean;
+    /** Whether this channel has been verified. */
+    verified: boolean;
+    /** Delivery metrics for this channel. */
+    metrics?: ContactChannelMetrics;
+    /** Last time a message was received on this channel. */
+    lastInboundAt?: string;
+    metadata?: {
+        [key: string]: string;
+    };
+    createdAt: string;
+    updatedAt?: string;
+}
+export type ContactChannelChannel = 'sms' | 'whatsapp' | 'email' | 'telegram' | 'instagram' | 'messenger' | 'voice';
+export interface ContactChannelMetrics {
+    successCount?: number;
+    failureCount?: number;
+    totalAttempts?: number;
+    avgDeliveryTimeMs?: number;
+    lastSuccessAt?: string;
+}
+export interface Contact {
+    id: string;
+    /** Display name for the contact. */
+    displayName?: string;
+    /** DEPRECATED: Use primaryPhone instead. Primary phone number in E.164 format. */
+    phoneNumber?: string;
+    /** Primary phone number in E.164 format. */
+    primaryPhone?: string;
+    /** Primary email address. */
+    primaryEmail?: string;
+    countryCode?: string;
+    /** Contact's WhatsApp profile name. Only available for WhatsApp contacts. */
+    profileName?: string | null;
+    /** List of available messaging channels for this contact. */
+    availableChannels: Array<string>;
+    /** Preferred channel for this contact. */
+    defaultChannel?: ContactDefaultChannel;
+    /** Whether this contact has been verified. */
+    verified: boolean;
+    /** All communication channels for this contact. */
+    channels?: Array<ContactChannel>;
+    metadata: {
+        [key: string]: string;
+    };
+    createdAt: string;
+    updatedAt?: string;
+}
+export type ContactDefaultChannel = 'sms' | 'whatsapp' | 'telegram' | 'email' | 'instagram' | 'messenger' | 'voice';
+export interface ContactUpdateRequest {
+    /**
+     * Human-readable name for this contact. Set to null to clear it and fall back to
+     * the contact's identifier. Contacts created automatically from an inbound message
+     * have no display name until you set one.
+     */
+    displayName?: string | null;
+    /** Preferred channel for this contact. Set to null to clear. */
+    defaultChannel?: ContactUpdateRequestDefaultChannel | null;
+    metadata?: {
+        [key: string]: string;
+    };
+}
+export type ContactUpdateRequestDefaultChannel = 'sms' | 'whatsapp' | 'telegram' | 'email' | 'instagram' | 'messenger' | 'voice';
+/** Input for creating a contact channel. */
+export interface ContactChannelInput {
+    /** Channel type. */
+    channel: ContactChannelInputChannel;
+    /** Channel identifier (phone number in E.164 format or email address). */
+    identifier: string;
+    /** ISO country code for phone numbers. */
+    countryCode?: string;
+    /** Optional label for the channel. */
+    label?: string;
+    /**
+     * Whether this should be the primary channel for its type.
+     *
+     * @defaultValue `false`
+     */
+    isPrimary?: boolean;
+}
+export type ContactChannelInputChannel = 'sms' | 'whatsapp' | 'email' | 'telegram' | 'instagram' | 'messenger' | 'voice';
+/** Request body to create a contact with channels. */
+export interface ContactCreateRequest {
+    /** Display name for the contact. */
+    displayName?: string;
+    /** Communication channels for the contact. */
+    channels: Array<ContactChannelInput>;
+    /** Arbitrary metadata to associate with the contact. */
+    metadata?: {
+        [key: string]: string;
+    };
+}
+/** Request body to add a channel to a contact. */
+export interface AddChannelRequest {
+    /** Channel type. */
+    channel: AddChannelRequestChannel;
+    /** Channel identifier (phone number in E.164 format or email address). */
+    identifier: string;
+    /** ISO country code for phone numbers. */
+    countryCode?: string;
+    /** Optional label for the channel. */
+    label?: string;
+    /**
+     * Whether this should be the primary channel for its type.
+     *
+     * @defaultValue `false`
+     */
+    isPrimary?: boolean;
+}
+export type AddChannelRequestChannel = 'sms' | 'whatsapp' | 'email' | 'telegram' | 'instagram' | 'messenger' | 'voice';
+/** Request body to update a channel. */
+export interface UpdateChannelRequest {
+    /** Optional label for the channel. Set to null to clear. */
+    label?: string | null;
+    /** Whether the channel is verified. */
+    verified?: boolean;
+    metadata?: {
+        [key: string]: string;
+    };
+}
+/** Request body to merge contacts. */
+export interface MergeContactsRequest {
+    /**
+     * ID of the contact to merge into the target contact. The source contact will be
+     * marked as merged.
+     */
+    sourceContactId: string;
+}
+export interface ContactChannelResponse {
+    channel: ContactChannel;
+}
+/**
+ * An inbox thread with one contact. A conversation groups every message exchanged
+ * with that contact across channels, so a contact who writes on WhatsApp and later
+ * by email stays in one thread.
+ */
+export interface Conversation {
+    id: string;
+    /**
+     * ID of the contact this thread belongs to. Absent on group threads and on threads
+     * whose contact has not been resolved yet.
+     */
+    contactId?: string;
+    /**
+     * The key this thread is filed under: a phone number in E.164, a WhatsApp
+     * business-scoped user ID (BSUID), or a numeric chat ID
+     * (Telegram/Instagram/Messenger). It is not always a phone number, so do not parse
+     * it as one.
+     */
+    contactIdentifier: string;
+    /** Email address of the thread, when the contact was reached by email. */
+    email?: string;
+    /** Every channel this thread has carried messages on. */
+    channels: Array<string>;
+    /**
+     * Denormalized preview of the most recent message, so a thread list needs no extra
+     * fetch.
+     */
+    lastMessage: ConversationLastMessage;
+    /**
+     * Sender that last handled this thread. Use it as the `Zavu-Sender` header when
+     * replying so the answer leaves from the same number the contact knows.
+     */
+    senderId?: string;
+    messageCount: number;
+    /**
+     * Inbound messages not yet marked read. Reset with POST
+     * /v1/conversations/{conversationId}/read.
+     */
+    unreadCount: number;
+    /** WhatsApp identity, present when the contact adopted a username. */
+    whatsapp?: ConversationWhatsapp;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ConversationLastMessage {
+    id: string;
+    /** Text or caption. Empty when the last message carried no text (e.g. media). */
+    text: string;
+    channel: Channel;
+    direction: ConversationLastMessageDirection;
+    at: string;
+}
+export type ConversationLastMessageDirection = 'inbound' | 'outbound';
+export interface ConversationWhatsapp {
+    /** Business-scoped user ID. Can be used as `to` when sending. */
+    bsuid?: string;
+    username?: string;
+}
+export interface ConversationResponse {
+    conversation: Conversation;
+}
+export interface PhoneIntrospectionRequest {
+    phoneNumber: string;
+}
+/** Type of phone line. */
+export type LineType = 'mobile' | 'landline' | 'voip' | 'toll_free' | 'unknown';
+/** Carrier information for the phone number. */
+export interface Carrier {
+    /** Carrier name. */
+    name?: string | null;
+    type?: LineType;
+}
+export interface PhoneIntrospectionResponse {
+    phoneNumber: string;
+    countryCode: string;
+    validNumber: boolean;
+    /** Phone number in national format. */
+    nationalFormat?: string;
+    lineType?: LineType;
+    carrier?: Carrier;
+    /** List of available messaging channels for this phone number. */
+    availableChannels?: Array<string>;
+}
+/**
+ * Validate one email (`email`) or a batch (`emails`). At most 100 addresses per
+ * request across both fields.
+ */
+export interface EmailIntrospectionRequest {
+    /** Single email address to validate. */
+    email?: string;
+    /** Batch of email addresses to validate (max 100). */
+    emails?: Array<string>;
+}
+export interface EmailValidationResult {
+    /** The address exactly as submitted. */
+    email: string;
+    /** Lowercased, trimmed form of the address. Null when the syntax is invalid. */
+    normalized: string | null;
+    /** Domain part of the address. Null when the syntax is invalid. */
+    domain: string | null;
+    /**
+     * Validation verdict.
+     * - `deliverable`: nothing suggests the address will bounce.
+     * - `risky`: sendable, but a signal predicts elevated bounce/complaint odds (role
+     *   address, disposable domain, MX-less domain, prior soft bounce).
+     * - `undeliverable`: will bounce or is blocked (invalid syntax, dead domain, or
+     *   the address is on your suppression list after a hard bounce/complaint).
+     */
+    verdict: EmailValidationResultVerdict;
+    /** Signals behind the verdict. Empty for a clean `deliverable` address. */
+    reasons: Array<EmailValidationResultReasonsItem>;
+}
+export type EmailValidationResultVerdict = 'deliverable' | 'risky' | 'undeliverable';
+export type EmailValidationResultReasonsItem = 'invalid_syntax' | 'domain_not_found' | 'domain_no_mx' | 'disposable_domain' | 'role_address' | 'suppressed_hard_bounce' | 'suppressed_soft_bounce' | 'suppressed_complaint' | 'suppressed_manual' | 'suppressed_unsubscribe';
+export interface EmailIntrospectionResponse {
+    /** One result per submitted address, in the same order. */
+    results: Array<EmailValidationResult>;
+    summary: EmailIntrospectionResponseSummary;
+}
+export interface EmailIntrospectionResponseSummary {
+    total: number;
+    deliverable: number;
+    risky: number;
+    undeliverable: number;
+}
+export interface InteractiveButton {
+    /** Unique button identifier returned in webhook when clicked. */
+    id: string;
+    /** Button text displayed to user. */
+    title: string;
+}
+export interface ListSection {
+    /** Section title. */
+    title: string;
+    rows: Array<ListRow>;
+}
+export interface ListRow {
+    /** Unique row identifier. */
+    id: string;
+    /** Row title. */
+    title: string;
+    /** Optional row description. */
+    description?: string;
+}
+export interface ContactCard {
+    name: ContactCardName;
+    phones?: Array<ContactCardPhonesItem>;
+    emails?: Array<ContactCardEmailsItem>;
+}
+export interface ContactCardName {
+    formatted_name: string;
+    first_name?: string;
+    last_name?: string;
+}
+export interface ContactCardPhonesItem {
+    phone?: string;
+    type?: ContactCardPhonesItemType;
+}
+export type ContactCardPhonesItemType = 'MOBILE' | 'HOME' | 'WORK';
+export interface ContactCardEmailsItem {
+    email?: string;
+    type?: ContactCardEmailsItemType;
+}
+export type ContactCardEmailsItemType = 'HOME' | 'WORK';
+export interface ReactionRequest {
+    /** Single emoji character to react with. */
+    emoji: string;
+}
+/** Broadcast delivery channel. Use 'smart' for per-contact intelligent routing. */
+export type BroadcastChannel = 'smart' | 'sms' | 'sms_oneway' | 'whatsapp' | 'telegram' | 'email';
+/**
+ * Current status of the broadcast. `pending_review`: in the automated content
+ * review. `pending_admin_review`: the automated review passed and it waits for a
+ * person, which is where every channel but a WhatsApp broadcast on an approved
+ * template goes. `rejected`: the review refused it; edit it and retry the review,
+ * or escalate. `scheduled` and `sending` follow approval.
+ */
+export type BroadcastStatus = 'draft' | 'pending_review' | 'pending_admin_review' | 'approved' | 'rejected' | 'escalated' | 'rejected_final' | 'scheduled' | 'sending' | 'paused' | 'completed' | 'cancelled' | 'failed';
+/**
+ * Status of a contact within a broadcast.
+ *
+ * - `pending`, `queued`, `sending`: not handed to the provider yet.
+ * - `sent`: accepted by the provider; delivery is not confirmed yet. Channels that
+ *   never report delivery leave the recipient here.
+ * - `delivered`: the channel confirmed delivery to the device. A WhatsApp read
+ *   receipt also counts as delivered.
+ * - `failed`: not delivered. A recipient can move from `sent` or `delivered` to
+ *   `failed` when the provider reports a failure late.
+ * - `skipped`: not sent, because the recipient opted out of the channel or the
+ *   broadcast was cancelled before reaching it.
+ */
+export type BroadcastContactStatus = 'pending' | 'queued' | 'sending' | 'sent' | 'delivered' | 'failed' | 'skipped';
+/** Type of message for broadcast. */
+export type BroadcastMessageType = 'text' | 'image' | 'video' | 'audio' | 'document' | 'template';
+/** Content for non-text broadcast message types. */
+export interface BroadcastContent {
+    /** URL of the media file. */
+    mediaUrl?: string;
+    /** Media ID if already uploaded. */
+    mediaId?: string;
+    /** MIME type of the media. */
+    mimeType?: string;
+    /** Filename for documents. */
+    filename?: string;
+    /** Template ID for template messages. */
+    templateId?: string;
+    /**
+     * Default body variables (can be overridden per contact). Key them to match the
+     * template body: by position (`1`, `2`, ...) for positional templates, or by name
+     * (e.g. `customer_name`) for named templates. Zavu detects the template's format
+     * and sends the correct payload to Meta. Do not mix positional and named keys.
+     */
+    templateVariables?: {
+        [key: string]: string;
+    };
+    /**
+     * Default button variables for dynamic URL/OTP buttons. Keys are the button index
+     * (0, 1, 2). Per-contact values override these.
+     */
+    templateButtonVariables?: {
+        [key: string]: string;
+    };
+    /**
+     * Default value for a text-header variable, keyed by `1` (can be overridden per
+     * contact). If omitted, Zavu resolves the header from `templateVariables` by the
+     * header placeholder's name.
+     */
+    templateHeaderVariables?: {
+        [key: string]: string;
+    };
+}
+export interface BroadcastCreateRequest {
+    /** Name of the broadcast campaign. */
+    name: string;
+    channel: BroadcastChannel;
+    /** @defaultValue `"text"` */
+    messageType?: BroadcastMessageType;
+    /** Text content or caption. Supports template variables: {{name}}, {{1}}, etc. */
+    text?: string;
+    content?: BroadcastContent;
+    /** Sender profile ID. Uses default sender if omitted. */
+    senderId?: string;
+    /** Email subject line. Required for email broadcasts. */
+    emailSubject?: string;
+    /** HTML body for email broadcasts. */
+    emailHtmlBody?: string;
+    /** Schedule the broadcast for future delivery. */
+    scheduledAt?: string;
+    metadata?: {
+        [key: string]: string;
+    };
+    /** Idempotency key to prevent duplicate broadcasts. */
+    idempotencyKey?: string;
+}
+export interface BroadcastUpdateRequest {
+    name?: string;
+    text?: string;
+    content?: BroadcastContent;
+    emailSubject?: string;
+    emailHtmlBody?: string;
+    metadata?: {
+        [key: string]: string;
+    };
+}
+export interface BroadcastContactInput {
+    /**
+     * Phone number (E.164) or email address. On a `telegram` broadcast, the numeric
+     * chat ID of someone who has already written to your bot (`838360395`, or
+     * `telegram:838360395`); a phone number is rejected there, because a bot cannot
+     * start a chat.
+     */
+    recipient: string;
+    /**
+     * Per-contact body variables. Key them to match the template body: by position
+     * (`1`, `2`, ...) for positional templates, or by name (e.g. `customer_name`) for
+     * named templates. Zavu detects the template's format and sends the correct
+     * payload to Meta. Do not mix positional and named keys.
+     */
+    templateVariables?: {
+        [key: string]: string;
+    };
+    /**
+     * Per-contact button variables for dynamic URL/OTP buttons. Keys are the button
+     * index (0, 1, 2).
+     */
+    templateButtonVariables?: {
+        [key: string]: string;
+    };
+    /**
+     * Per-contact value for a text-header variable, keyed by `1`. If omitted, Zavu
+     * resolves the header from `templateVariables` by the header placeholder's name.
+     */
+    templateHeaderVariables?: {
+        [key: string]: string;
+    };
+}
+export interface BroadcastContactsAddRequest {
+    /** List of contacts to add (max 1000 per request). */
+    contacts: Array<BroadcastContactInput>;
+}
+export interface BroadcastContactsAddResponse {
+    /** Number of contacts successfully added. */
+    added: number;
+    /** Number of duplicate contacts skipped. */
+    duplicates: number;
+    /** Number of invalid contacts rejected. */
+    invalid: number;
+    /** Details about invalid contacts. */
+    errors?: Array<BroadcastContactsAddResponseErrorsItem>;
+}
+export interface BroadcastContactsAddResponseErrorsItem {
+    recipient?: string;
+    reason?: string;
+}
+export interface BroadcastSendRequest {
+    /** Schedule for future delivery. Omit to send immediately. */
+    scheduledAt?: string;
+}
+export interface BroadcastRescheduleRequest {
+    /** New scheduled time for the broadcast. */
+    scheduledAt: string;
+}
+export interface Broadcast {
+    id: string;
+    name: string;
+    status: BroadcastStatus;
+    channel: BroadcastChannel;
+    messageType: BroadcastMessageType;
+    text?: string;
+    content?: BroadcastContent;
+    senderId?: string;
+    emailSubject?: string;
+    /** Total number of contacts in the broadcast. */
+    totalContacts: number;
+    pendingCount?: number;
+    sendingCount?: number;
+    /**
+     * Recipients whose message the provider accepted, without a confirmed delivery
+     * yet. Channels that never report delivery keep their recipients here.
+     */
+    sentCount?: number;
+    /** Recipients with confirmed delivery to the device. */
+    deliveredCount?: number;
+    failedCount?: number;
+    /** Estimated total cost in USD. */
+    estimatedCost?: number | null;
+    /** Amount reserved from balance in USD. */
+    reservedAmount?: number | null;
+    /** Actual cost so far in USD. */
+    actualCost?: number | null;
+    scheduledAt?: string;
+    startedAt?: string;
+    completedAt?: string;
+    metadata?: {
+        [key: string]: string;
+    };
+    createdAt: string;
+    updatedAt?: string;
+    /** AI content review result. */
+    reviewResult?: BroadcastReviewResult | null;
+    /** Number of review attempts (max 3). */
+    reviewAttempts?: number | null;
+}
+export interface BroadcastReviewResult {
+    /** Content safety score from 0.0 to 1.0, where 1.0 is completely safe. */
+    score?: number;
+    /** Policy categories violated, if any. */
+    categories?: Array<string>;
+    /** Explanation of the review decision. */
+    reasoning?: string;
+    reviewedAt?: string;
+    /** Problematic text fragments, if any. */
+    flaggedContent?: Array<string> | null;
+}
+export interface BroadcastResponse {
+    broadcast: Broadcast;
+}
+export interface BroadcastContact {
+    id: string;
+    recipient: string;
+    recipientType: BroadcastContactRecipientType;
+    status: BroadcastContactStatus;
+    templateVariables?: {
+        [key: string]: string;
+    };
+    templateButtonVariables?: {
+        [key: string]: string;
+    };
+    templateHeaderVariables?: {
+        [key: string]: string;
+    };
+    /** Associated message ID after processing. */
+    messageId?: string;
+    errorCode?: string;
+    errorMessage?: string;
+    cost?: number | null;
+    processedAt?: string;
+    createdAt: string;
+}
+export type BroadcastContactRecipientType = 'phone' | 'email';
+export interface BroadcastProgress {
+    broadcastId: string;
+    status: BroadcastStatus;
+    /** Total contacts in broadcast. */
+    total: number;
+    /** Not yet queued for sending. */
+    pending: number;
+    /** Currently being sent. */
+    sending: number;
+    /** Accepted by the provider, delivery not confirmed yet. */
+    sent?: number;
+    /** Confirmed delivered to the device. */
+    delivered: number;
+    /** Failed to deliver. */
+    failed: number;
+    /** Skipped (broadcast cancelled). */
+    skipped: number;
+    /** Percentage complete (0-100). */
+    percentComplete: number;
+    /** Estimated total cost in USD. */
+    estimatedCost?: number | null;
+    /** Amount reserved from balance in USD. */
+    reservedAmount?: number | null;
+    /** Actual cost so far in USD. */
+    actualCost?: number | null;
+    startedAt?: string;
+    estimatedCompletionAt?: string;
+}
+/**
+ * Billing state of an owned number, separate from `regulatoryStatus`. `pending` is
+ * legacy and is not written to numbers today. The SDKs carry `active`, `suspended`
+ * and `pending` only; `releasing` and `released` are returned by the REST API
+ * until their next release.
+ */
+export type PhoneNumberStatus = 'active' | 'suspended' | 'pending' | 'releasing' | 'released';
+/**
+ * Type of phone number. `mobile` is stocked in countries where no geographic
+ * (`local`) or non-geographic (`national`) inventory exists, and in several
+ * markets it is the only type that can receive SMS.
+ */
+export type PhoneNumberType = 'local' | 'national' | 'tollFree' | 'mobile';
+export interface PhoneNumberCapabilities {
+    sms?: boolean;
+    voice?: boolean;
+    mms?: boolean;
+}
+export interface PhoneNumberPricing {
+    /** Monthly price in USD. */
+    monthlyPrice?: number;
+    /** One-time purchase price in USD. */
+    upfrontPrice?: number;
+    /**
+     * Whether this number qualifies as the plan-included number: a US or Canadian
+     * number (a +1 number) costing $20 a month or less. The benefit is one per
+     * account: it is never offered again once claimed, not even after the number is
+     * released.
+     */
+    isFreeEligible?: boolean;
+}
+export interface AvailablePhoneNumber {
+    phoneNumber: string;
+    friendlyName?: string;
+    locality?: string;
+    region?: string;
+    capabilities: PhoneNumberCapabilities;
+    pricing: PhoneNumberPricing;
+}
+export interface OwnedPhoneNumberPricing {
+    /** Monthly price in USD. */
+    monthlyPrice?: number;
+    /** One-time purchase cost in cents. */
+    upfrontCost?: number;
+    /** Monthly cost in cents. */
+    monthlyCost?: number;
+    /** Whether this is a free number. */
+    isFreeNumber?: boolean;
+}
+export interface OwnedPhoneNumber {
+    id: string;
+    phoneNumber: string;
+    /** Optional custom name for the phone number. */
+    name?: string;
+    capabilities: Array<string>;
+    status: PhoneNumberStatus;
+    /** Sender ID if the phone number is assigned to a sender. */
+    senderId?: string;
+    pricing: OwnedPhoneNumberPricing;
+    /**
+     * Regulatory review state. Numbers that need no review are `approved` immediately.
+     * A number bought with regulatory information is owned and billed from purchase
+     * and starts `pending_review`; it cannot send messages or place calls until this
+     * is `approved`. The state is re-checked every 6 hours: poll `GET
+     * /v1/phone-numbers/{phoneNumberId}` to follow it.
+     *
+     * Assign it to a sender with `PATCH /v1/phone-numbers/{phoneNumberId}`
+     * (`senderId`) before or after approval. A number assigned while under review is
+     * recorded and connected to that sender when it is approved; the connection is
+     * retried until it succeeds. A sender created over the API is set up for SMS as
+     * part of the assignment. `rejected` means review refused the information: the
+     * number cannot be assigned to a sender. A number that stays `pending_review` may
+     * be waiting on information the API cannot supply; contact support.
+     */
+    regulatoryStatus: OwnedPhoneNumberRegulatoryStatus;
+    nextRenewalDate?: string;
+    createdAt: string;
+    updatedAt?: string;
+}
+export type OwnedPhoneNumberRegulatoryStatus = 'approved' | 'pending_review' | 'rejected';
+export interface PhoneNumberPurchaseRequest {
+    /** Phone number in E.164 format. */
+    phoneNumber: string;
+    /** Optional custom name for the phone number. */
+    name?: string;
+    /**
+     * Type the number was found under in `GET /v1/phone-numbers/available`. Used to
+     * look the number up and to keep regulatory information for reuse. Required when
+     * `regulatoryRequirements` is sent. `toll_free` is accepted as an alias of
+     * `tollFree`. A number not listed under this type is refused with `400
+     * number_unavailable` saying so.
+     */
+    type?: PhoneNumberType;
+    /**
+     * Regulatory information, for numbers whose requirements list is not empty. Get
+     * the list with `GET /v1/phone-numbers/requirements?phoneNumber=...` and send one
+     * entry per requirement id, except `action` requirements, which take no value.
+     * Every required id must be present, once, and no unknown id may be sent;
+     * otherwise the purchase is refused with `400 invalid_request` before anything is
+     * charged.
+     *
+     * The information is kept for your project under the number's country and `type`.
+     * A later purchase there may omit this field if what is kept still covers that
+     * number's requirements. Omit it for numbers without requirements.
+     */
+    regulatoryRequirements?: Array<PhoneNumberPurchaseRequestRegulatoryRequirementsItem>;
+}
+export interface PhoneNumberPurchaseRequestRegulatoryRequirementsItem {
+    /**
+     * A `requirementTypes[].id` from `GET /v1/phone-numbers/requirements`. Each id may
+     * appear only once.
+     */
+    requirementType: string;
+    /**
+     * Depends on the requirement's `type`: the text itself for `textual`; for
+     * `address`, the `id` of an address created in this project with `POST
+     * /v1/addresses`; for `document`, the `id` of a document created with `POST
+     * /v1/documents`. An address or document from another project, or one rejected in
+     * review, is refused.
+     */
+    fieldValue: string;
+}
+export interface PhoneNumberUpdateRequest {
+    /** Custom name for the phone number. Set to null to clear. */
+    name?: string | null;
+    /**
+     * Sender ID to assign the phone number to. Set to null to unassign. A number under
+     * regulatory review is recorded now and connected to the sender when approved; a
+     * rejected number is refused.
+     */
+    senderId?: string | null;
+}
+export interface PhoneNumberResponse {
+    phoneNumber: OwnedPhoneNumber;
+}
+/**
+ * Current status of the partner invitation.
+ *
+ * `failed` means the client started the connection and it did not finish (they
+ * cancelled Meta's dialog, denied a permission, or abandoned the tab). A failed
+ * invitation is still usable: the same link can be retried, and it moves back to
+ * `in_progress` when the client tries again.
+ */
+export type InvitationStatus = 'pending' | 'in_progress' | 'completed' | 'expired' | 'cancelled' | 'failed';
+export interface InvitationCreateRequest {
+    /** Name of the client being invited. */
+    clientName?: string;
+    /** Email of the client being invited. */
+    clientEmail?: string;
+    /** Phone number of the client in E.164 format. */
+    clientPhone?: string;
+    /**
+     * ID of a Zavu phone number to pre-assign for WhatsApp registration. If provided,
+     * the client will use this number instead of their own. Only valid when
+     * `connectionType` is `whatsapp_waba` — sending it with `messenger` returns 400,
+     * since a Facebook Page has no phone number.
+     */
+    phoneNumberId?: string;
+    /**
+     * Number of days until the invitation expires.
+     *
+     * @defaultValue `7`
+     */
+    expiresInDays?: number;
+    /**
+     * ISO country codes for allowed phone numbers. Only valid when `connectionType` is
+     * `whatsapp_waba` — sending it with `messenger` returns 400.
+     */
+    allowedPhoneCountries?: Array<string>;
+    /**
+     * Which Meta channel the client connects, and how.
+     * - `whatsapp_waba` (default): Meta's embedded signup links an official WhatsApp
+     *   Business Account. Accepts `phoneNumberId` and `allowedPhoneCountries`.
+     * - `messenger`: the client authorizes with Facebook and picks a Facebook Page
+     *   they administer. The Page's Messenger inbox — including Marketplace chats
+     *   — is routed to Zavu. They must be an admin of at least one Page. A Page can
+     *   only be connected to one Zavu project at a time: if the client picks a Page
+     *   that another project already connected, the newer connection wins and the
+     *   older one is disconnected.
+     *
+     * One invitation connects one channel. To onboard a client on several channels,
+     * create one invitation per channel; each completes into its own sender.
+     *
+     * @defaultValue `"whatsapp_waba"`
+     */
+    connectionType?: InvitationCreateRequestConnectionType;
+}
+export type InvitationCreateRequestConnectionType = 'whatsapp_waba' | 'messenger';
+export interface Invitation {
+    id: string;
+    /** Full URL to share with the client. */
+    url: string;
+    /** Unique invitation token. */
+    token: string;
+    clientName?: string | null;
+    clientEmail?: string | null;
+    clientPhone?: string | null;
+    /**
+     * ID of a pre-assigned Zavu phone number for WhatsApp registration. Always null
+     * for `messenger` invitations.
+     */
+    phoneNumberId?: string | null;
+    /**
+     * Which Meta channel the client connects: `whatsapp_waba` (official WhatsApp Cloud
+     * API via embedded signup) or `messenger` (a Facebook Page's Messenger inbox,
+     * including Marketplace chats).
+     */
+    connectionType?: InvitationConnectionType;
+    status: InvitationStatus;
+    /** ID of the sender created when invitation is completed. */
+    senderId?: string | null;
+    /**
+     * The account the client linked, populated once the invitation is `completed`.
+     * Null before that. Use it to show the partner what was connected without fetching
+     * the sender.
+     */
+    connectedAccount?: InvitationConnectedAccount | null;
+    /**
+     * Stable code for why the last attempt failed, present when `status` is `failed`.
+     * Values include `fb_cancelled` (client closed Meta's dialog), `fb_not_authorized`
+     * (permission denied), `signup_abandoned` (started but never finished),
+     * `meta_no_pages` (the client administers no Facebook Page), and `internal_error`.
+     * Treat unknown codes as a generic failure.
+     */
+    failureReason?: string | null;
+    failedAt?: string | null;
+    expiresAt: string;
+    viewedAt?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export type InvitationConnectionType = 'whatsapp_waba' | 'messenger';
+export interface InvitationConnectedAccount {
+    channel: InvitationConnectedAccountChannel;
+    /** Provider-side identifier: the WhatsApp phone number ID, or the Facebook Page ID. */
+    id: string;
+    /**
+     * Display name of the connected account: the WhatsApp verified name, or the
+     * Facebook Page name.
+     */
+    name?: string | null;
+}
+export type InvitationConnectedAccountChannel = 'whatsapp' | 'messenger';
+export interface InvitationResponse {
+    invitation: Invitation;
+}
+/** Business category for WhatsApp Business profile. */
+export type WhatsAppBusinessProfileVertical = 'UNDEFINED' | 'OTHER' | 'AUTO' | 'BEAUTY' | 'APPAREL' | 'EDU' | 'ENTERTAIN' | 'EVENT_PLAN' | 'FINANCE' | 'GROCERY' | 'GOVT' | 'HOTEL' | 'HEALTH' | 'NONPROFIT' | 'PROF_SERVICES' | 'RETAIL' | 'TRAVEL' | 'RESTAURANT' | 'NOT_A_BIZ';
+/** WhatsApp Business profile information. */
+export interface WhatsAppBusinessProfile {
+    /** Short description of the business (max 139 characters). */
+    about?: string;
+    /** Physical address of the business (max 256 characters). */
+    address?: string;
+    /** Extended description of the business (max 512 characters). */
+    description?: string;
+    /** Business email address. */
+    email?: string;
+    /** URL of the business profile picture. */
+    profilePictureUrl?: string;
+    /** Business website URLs (maximum 2). */
+    websites?: Array<string>;
+    vertical?: WhatsAppBusinessProfileVertical;
+}
+/** Request body to update WhatsApp Business profile. */
+export interface WhatsAppBusinessProfileUpdateRequest {
+    /** Short description of the business (max 139 characters). */
+    about?: string;
+    /** Physical address of the business (max 256 characters). */
+    address?: string;
+    /** Extended description of the business (max 512 characters). */
+    description?: string;
+    /** Business email address. */
+    email?: string;
+    /** Business website URLs (maximum 2). */
+    websites?: Array<string>;
+    vertical?: WhatsAppBusinessProfileVertical;
+}
+export interface WhatsAppBusinessProfileResponse {
+    profile: WhatsAppBusinessProfile;
+}
+/** Request body to upload a profile picture. */
+export interface WhatsAppBusinessProfilePictureRequest {
+    /** URL of the image to upload. */
+    imageUrl: string;
+    /** MIME type of the image. */
+    mimeType: WhatsAppBusinessProfilePictureRequestMimeType;
+}
+export type WhatsAppBusinessProfilePictureRequestMimeType = 'image/jpeg' | 'image/png';
+/** Status of WhatsApp message history sync. */
+export type WhatsAppSyncHistoryStatus = 'not_requested' | 'pending' | 'syncing' | 'completed' | 'rejected';
+/** Status of WhatsApp contacts sync. */
+export type WhatsAppSyncContactsStatus = 'not_requested' | 'pending' | 'syncing' | 'completed';
+/** History sync status details. */
+export interface WhatsAppSyncHistory {
+    status: WhatsAppSyncHistoryStatus;
+    /** Whether history sync can be initiated. */
+    canSync: boolean;
+    /** When the sync was last requested. */
+    requestedAt?: string | null;
+    /** When the sync was completed. */
+    completedAt?: string | null;
+}
+/** Contacts sync status details. */
+export interface WhatsAppSyncContacts {
+    status: WhatsAppSyncContactsStatus;
+    /** Whether contacts sync can be initiated. */
+    canSync: boolean;
+    /** When the sync was last requested. */
+    requestedAt?: string | null;
+}
+/** WhatsApp coexistence sync status. */
+export interface WhatsAppSyncStatus {
+    /** Whether the account is in coexistence mode. */
+    isCoexistence: boolean;
+    /** WhatsApp account status. */
+    status: WhatsAppSyncStatusStatus;
+    history: WhatsAppSyncHistory;
+    contacts: WhatsAppSyncContacts;
+}
+export type WhatsAppSyncStatusStatus = 'pending_verification' | 'pending_registration' | 'active' | 'disconnected' | 'error';
+export interface WhatsAppSyncStatusResponse {
+    sync: WhatsAppSyncStatus;
+}
+export interface WhatsAppSyncStartResponse {
+    /** Success message. */
+    message: string;
+    sync: WhatsAppSyncStatus;
+}
+/** LLM provider for the AI agent. */
+export type AgentProvider = 'openai' | 'anthropic' | 'google' | 'mistral' | 'zavu';
+/** Status of an agent execution. */
+export type AgentExecutionStatus = 'success' | 'error' | 'filtered' | 'rate_limited' | 'balance_insufficient';
+/** AI Agent configuration for a sender. */
+export interface Agent {
+    id: string;
+    /**
+     * The sender the agent was created on, its primary. Absent on an agent created
+     * with `POST /v1/agents`, which has no primary even after senders are connected to
+     * it. `senderIds` lists every sender the agent answers on.
+     */
+    senderId?: string;
+    name: string;
+    /** Whether the agent is active. */
+    enabled: boolean;
+    provider: AgentProvider;
+    /** Model ID (e.g., gpt-4o-mini, claude-3-5-sonnet). */
+    model: string;
+    /** System prompt for the agent. */
+    systemPrompt: string;
+    /**
+     * Number of previous messages to include as context.
+     *
+     * @defaultValue `10`
+     */
+    contextWindowMessages?: number;
+    /**
+     * Whether to include contact metadata in context.
+     *
+     * @defaultValue `true`
+     */
+    includeContactMetadata?: boolean;
+    /** Maximum tokens for LLM response. */
+    maxTokens?: number | null;
+    /** LLM temperature (0-2). */
+    temperature?: number | null;
+    /** Channels that trigger the agent. */
+    triggerOnChannels?: Array<string>;
+    /** Message types that trigger the agent. */
+    triggerOnMessageTypes?: Array<string>;
+    stats?: AgentStatsTotals;
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * Voice Agent configuration. When present and enabled, the agent can answer
+     * inbound phone calls and place outbound calls with Zavu's managed voice pipeline.
+     */
+    voice?: AgentVoiceConfig;
+    /**
+     * Senders this agent answers on. An agent can serve several; `senderId` remains
+     * the primary one, for compatibility.
+     */
+    senderIds?: Array<string>;
+}
+export interface AgentStatsTotals {
+    totalInvocations?: number;
+    totalTokensUsed?: number;
+    /** Total cost in USD. */
+    totalCost?: number;
+}
+export interface AgentCreateRequest {
+    name: string;
+    provider: AgentProvider;
+    model: string;
+    systemPrompt: string;
+    /** API key for the LLM provider. Required unless provider is 'zavu'. */
+    apiKey?: string;
+    /** @defaultValue `10` */
+    contextWindowMessages?: number;
+    /** @defaultValue `true` */
+    includeContactMetadata?: boolean;
+    maxTokens?: number;
+    temperature?: number;
+    /** @defaultValue `["*"]` */
+    triggerOnChannels?: Array<string>;
+    /** @defaultValue `["text"]` */
+    triggerOnMessageTypes?: Array<string>;
+    /**
+     * Voice Agent configuration. Enable this to let the agent answer and place phone
+     * calls with Zavu's managed voice pipeline.
+     */
+    voice?: AgentVoiceConfig;
+}
+export interface AgentUpdateRequest {
+    name?: string;
+    enabled?: boolean;
+    provider?: AgentProvider;
+    model?: string;
+    systemPrompt?: string;
+    /**
+     * API key for the LLM provider, stored and attached to the agent. Send it with
+     * `provider` when the agent does not already hold a key for that provider: an
+     * update that would leave the agent on a key for a different provider is refused
+     * with `400 invalid_request`, and one that leaves it with no key at all is refused
+     * too. Moving to `zavu` needs no key.
+     */
+    apiKey?: string;
+    contextWindowMessages?: number;
+    includeContactMetadata?: boolean;
+    maxTokens?: number | null;
+    temperature?: number | null;
+    triggerOnChannels?: Array<string>;
+    triggerOnMessageTypes?: Array<string>;
+    /**
+     * Voice Agent configuration. Patch this object to enable voice, change the
+     * greeting, or adjust call limits.
+     */
+    voice?: AgentVoiceConfig;
+}
+export interface AgentResponse {
+    agent: Agent;
+}
+export interface AgentStats {
+    totalInvocations: number;
+    totalTokensUsed: number;
+    /** Total cost in USD. */
+    totalCost: number;
+    /**
+     * Successful executions among the agent's 100 most recent. Executions with status
+     * `filtered` (messages the agent never ran on) are not counted here, in
+     * `errorCount` or in `avgLatencyMs`.
+     */
+    successCount: number;
+    /** Failed executions among the agent's 100 most recent. */
+    errorCount: number;
+    /**
+     * Average latency of the agent's 100 most recent executions, `filtered` excluded.
+     * Null when there are none.
+     */
+    avgLatencyMs?: number | null;
+}
+export interface AgentExecution {
+    id: string;
+    agentId: string;
+    inboundMessageId?: string;
+    responseMessageId?: string | null;
+    responseText?: string | null;
+    status: AgentExecutionStatus;
+    errorMessage?: string | null;
+    inputTokens: number;
+    outputTokens: number;
+    latencyMs: number;
+    /** Cost in USD. */
+    cost: number;
+    createdAt: string;
+    /**
+     * Knowledge-base chunks retrieved for this answer. Zero on an agent that has
+     * documents attached means the reply was not grounded in them, which is otherwise
+     * indistinguishable from a correct answer in this record. Absent on executions
+     * recorded before this field existed, which is not the same as zero.
+     */
+    knowledgeChunksUsed?: number | null;
+    /**
+     * Tools the agent called while producing this reply. Zero on an agent that has
+     * tools configured means it answered without calling any — the case where a
+     * reply says it will look something up and nothing ever reaches your endpoint.
+     * Absent on executions recorded before this field existed, which is not the same
+     * as zero.
+     */
+    toolCalls?: number | null;
+}
+/**
+ * What starts a flow.
+ *
+ * - `keyword`: the message contains one of the words listed in `keywords`. Plain
+ *   substring matching, so a word inside another word still counts.
+ * - `intent`: the message MEANS what `intent` describes, whatever words it uses.
+ * - `always`: any message starts it.
+ * - `manual`: reserved. Nothing starts a `manual` flow today — it is accepted
+ *   and stored, and no message or endpoint runs it.
+ */
+export type FlowTriggerType = 'keyword' | 'intent' | 'always' | 'manual';
+/** Type of flow step. */
+export type FlowStepType = 'message' | 'collect' | 'condition' | 'tool' | 'llm' | 'transfer';
+export interface FlowTrigger {
+    type: FlowTriggerType;
+    /**
+     * Words that start the flow, for `keyword` triggers. Matched as substrings,
+     * case-insensitively, against the whole message: a flow on `info` also starts on
+     * "no quiero info". Use `intent` when that matters.
+     */
+    keywords?: Array<string>;
+    /**
+     * One plain sentence describing what the contact wants, for `intent` triggers. Any
+     * language.
+     *
+     * The message is judged for meaning, not for words, so "kiero saber el presio"
+     * starts a flow whose intent is "quiere saber precios o cotizar", and "no quiero
+     * info de precios" starts nothing.
+     *
+     * A `keyword` or `always` flow with a higher `priority` is matched first and wins.
+     * At most 12 intent flows are considered per message, highest priority first. When
+     * the classification is unavailable or uncertain, the message is handled as if no
+     * intent matched, so a flow never starts on a guess.
+     */
+    intent?: string;
+}
+export interface FlowStep {
+    /** Unique step identifier. */
+    id: string;
+    type: FlowStepType;
+    /** Step configuration (varies by type). */
+    config: {
+        [key: string]: unknown;
+    };
+    /** ID of the next step to execute. */
+    nextStepId?: string | null;
+}
+export interface AgentFlow {
+    id: string;
+    agentId: string;
+    name: string;
+    description?: string | null;
+    trigger: FlowTrigger;
+    steps: Array<FlowStep>;
+    enabled: boolean;
+    /** Priority when multiple flows match (higher = more priority). */
+    priority: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface FlowCreateRequest {
+    name: string;
+    description?: string;
+    trigger: FlowTrigger;
+    /**
+     * The first step runs on the message that started the flow. It cannot be a
+     * `condition` without a `defaultGoto`: nothing has been collected yet, so its
+     * conditions evaluate the same way on every message, and the request is refused
+     * with `400 invalid_request`.
+     *
+     * A flow that ends on that first message without replying hands the message to the
+     * agent, which answers it. A `transfer` step stays silent.
+     */
+    steps: Array<FlowStep>;
+    /** @defaultValue `false` */
+    enabled?: boolean;
+    /** @defaultValue `0` */
+    priority?: number;
+}
+export interface FlowUpdateRequest {
+    name?: string;
+    description?: string;
+    trigger?: FlowTrigger;
+    /**
+     * The first step runs on the message that started the flow. It cannot be a
+     * `condition` without a `defaultGoto`: nothing has been collected yet, so its
+     * conditions evaluate the same way on every message, and the request is refused
+     * with `400 invalid_request`.
+     *
+     * A flow that ends on that first message without replying hands the message to the
+     * agent, which answers it. A `transfer` step stays silent.
+     */
+    steps?: Array<FlowStep>;
+    enabled?: boolean;
+    priority?: number;
+}
+export interface FlowResponse {
+    flow: AgentFlow;
+}
+export interface FlowDuplicateRequest {
+    newName: string;
+}
+export interface ToolParameters {
+    type: 'object';
+    properties: {
+        [key: string]: ToolParametersPropertiesValue;
+    };
+    required: Array<string>;
+}
+export interface ToolParametersPropertiesValue {
+    type?: string;
+    description?: string;
+}
+export interface AgentTool {
+    id: string;
+    agentId: string;
+    name: string;
+    /** Description for the LLM to understand when to use this tool. */
+    description: string;
+    parameters: ToolParameters;
+    /** HTTPS URL to call when the tool is executed. */
+    webhookUrl: string;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * Signing secret for this tool's webhook. **Returned only when the tool is
+     * created**, never on a later read.
+     *
+     * Zavu generates one if you do not supply it, and signs every call to this tool
+     * with it: `X-Zavu-Signature: <hex>`, the HMAC-SHA256 of the request body. Verify
+     * it before trusting the call. Lost it? Rotate with `POST
+     * /v1/senders/{senderId}/agent/tools/{toolId}/webhook/secret`.
+     */
+    webhookSecret?: string;
+}
+export interface ToolCreateRequest {
+    name: string;
+    description: string;
+    parameters: ToolParameters;
+    /** Must be HTTPS. */
+    webhookUrl: string;
+    /**
+     * Signing secret for the webhook. Optional: Zavu generates one when omitted and
+     * returns it on this response only. Supply your own if you already have a secret
+     * you want reused.
+     */
+    webhookSecret?: string;
+    /** @defaultValue `true` */
+    enabled?: boolean;
+}
+export interface ToolUpdateRequest {
+    name?: string;
+    description?: string;
+    parameters?: ToolParameters;
+    webhookUrl?: string;
+    webhookSecret?: string | null;
+    enabled?: boolean;
+}
+export interface ToolResponse {
+    tool: AgentTool;
+}
+export interface ToolTestRequest {
+    /** Parameters to pass to the tool for testing. */
+    testParams: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * One run of a tool triggered from the test endpoint. Recorded so a test is
+ * verifiable after the fact rather than only visible in the response.
+ */
+export interface AgentToolTestRun {
+    id: string;
+    toolId: string;
+    /** The parameters the tool was called with. */
+    params?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Whether the tool returned without error. A tool that answered with a non-2xx
+     * status is a failed run, not an error of this endpoint.
+     */
+    success: boolean;
+    /**
+     * HTTP status the tool's webhook returned. Absent for tools that do not go over
+     * HTTP.
+     */
+    statusCode?: number | null;
+    /** The tool's response body, truncated. */
+    response?: string | null;
+    /** Why the run failed, when it did. */
+    error?: string | null;
+    durationMs: number;
+    createdAt: string;
+}
+export interface ToolTestResponse {
+    run: AgentToolTestRun;
+}
+export interface AgentKnowledgeBase {
+    id: string;
+    agentId: string;
+    name: string;
+    description?: string | null;
+    documentCount: number;
+    totalChunks: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface KnowledgeBaseCreateRequest {
+    name: string;
+    description?: string;
+}
+export interface KnowledgeBaseUpdateRequest {
+    name?: string;
+    description?: string | null;
+}
+export interface KnowledgeBaseResponse {
+    knowledgeBase: AgentKnowledgeBase;
+}
+export interface AgentDocument {
+    id: string;
+    knowledgeBaseId: string;
+    title: string;
+    /** Length of the document content in characters. */
+    contentLength: number;
+    /** Number of chunks created from this document. */
+    chunkCount: number;
+    /** Whether the document has been processed for RAG. */
+    isProcessed: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface DocumentCreateRequest {
+    title: string;
+    content: string;
+}
+export interface DocumentResponse {
+    document: AgentDocument;
+}
+/** Type of requirement field. */
+export type RequirementFieldType = 'textual' | 'address' | 'document' | 'action';
+/** Acceptance criteria for a requirement. */
+export interface RequirementAcceptanceCriteria {
+    minLength?: number | null;
+    maxLength?: number | null;
+    allowedValues?: Array<string> | null;
+    regexPattern?: string | null;
+}
+/** A specific requirement type within a requirement group. */
+export interface RequirementType {
+    /** Send this as `requirementType` in `regulatoryRequirements` when purchasing. */
+    id: string;
+    name: string;
+    description: string;
+    type: RequirementFieldType;
+    example?: string | null;
+    acceptanceCriteria?: RequirementAcceptanceCriteria;
+}
+/**
+ * The requirements for ordering a number: for a country and number type, or for
+ * one specific number when requested with `phoneNumber` (then `id` is that phone
+ * number and `countryCode` is taken from it).
+ */
+export interface Requirement {
+    id: string;
+    countryCode: string;
+    phoneNumberType: string;
+    action: string;
+    requirementTypes: Array<RequirementType>;
+}
+export type AddressStatus = 'pending' | 'verified' | 'rejected';
+/** A regulatory address for phone number requirements. */
+export interface Address {
+    id: string;
+    firstName?: string | null;
+    lastName?: string | null;
+    businessName?: string | null;
+    streetAddress: string;
+    extendedAddress?: string | null;
+    locality: string;
+    administrativeArea?: string | null;
+    postalCode: string;
+    countryCode: string;
+    status: AddressStatus;
+    createdAt: string;
+    updatedAt?: string;
+}
+/**
+ * A regulatory address. `firstName` and `lastName` are required: the carrier will
+ * not register an address without a named person. Requests that omit them are
+ * refused with `400 invalid_request`, and the SDKs still type them as optional
+ * until their next release.
+ */
+export interface AddressCreateRequest {
+    /** First name of the person the address is registered to. */
+    firstName: string;
+    /** Last name of the person the address is registered to. */
+    lastName: string;
+    /**
+     * Business name, when the address belongs to a business. Defaults to the person's
+     * full name.
+     */
+    businessName?: string;
+    streetAddress: string;
+    extendedAddress?: string;
+    locality: string;
+    administrativeArea?: string;
+    postalCode: string;
+    countryCode: string;
+}
+export interface AddressResponse {
+    address: Address;
+}
+export type RegulatoryDocumentStatus = 'pending' | 'uploaded' | 'verified' | 'rejected';
+export type RegulatoryDocumentType = 'passport' | 'national_id' | 'drivers_license' | 'utility_bill' | 'tax_id' | 'business_registration' | 'proof_of_address' | 'other';
+/** A regulatory document for phone number requirements. */
+export interface RegulatoryDocument {
+    id: string;
+    name: string;
+    documentType: RegulatoryDocumentType;
+    mimeType?: string;
+    fileSize?: number;
+    status: RegulatoryDocumentStatus;
+    rejectionReason?: string | null;
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface RegulatoryDocumentCreateRequest {
+    name: string;
+    documentType: RegulatoryDocumentType;
+    /** Storage ID from the upload-url endpoint. */
+    storageId: string;
+    mimeType: string;
+    fileSize: number;
+}
+export interface RegulatoryDocumentResponse {
+    document: RegulatoryDocument;
+}
+export interface UploadUrlResponse {
+    /** Pre-signed URL for uploading the file. */
+    uploadUrl: string;
+}
+/** Status of a verified URL. */
+export type VerifiedUrlStatus = 'pending' | 'approved' | 'rejected' | 'escalated' | 'malicious';
+/** How the URL was approved or rejected. */
+export type VerifiedUrlApprovalType = 'manual' | 'auto_web_risk';
+export interface VerifiedUrl {
+    id: string;
+    /** The verified URL. */
+    url: string;
+    /** Domain extracted from the URL. */
+    domain: string;
+    status: VerifiedUrlStatus;
+    approvalType?: VerifiedUrlApprovalType;
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface VerifiedUrlSubmitRequest {
+    /** The URL to submit for verification. */
+    url: string;
+}
+export interface VerifiedUrlResponse {
+    url: VerifiedUrl;
+}
+/**
+ * `active` and `inactive` are set with PATCH. `pending_deletion` is read-only: the
+ * sub-account was deactivated with DELETE, its API keys are revoked, and it is
+ * removed after 14 days.
+ */
+export type SubAccountStatus = 'active' | 'inactive' | 'pending_deletion';
+export interface SubAccount {
+    id: string;
+    name: string;
+    /** External reference ID set by the parent account. */
+    externalId?: string | null;
+    status: SubAccountStatus;
+    /** Total amount spent by this sub-account in cents. */
+    totalSpent: number;
+    /**
+     * Spending cap in cents. When reached, messages from this sub-account will be
+     * blocked.
+     */
+    creditLimit?: number | null;
+    metadata?: {
+        [key: string]: unknown;
+    } | null;
+    /** API key for the sub-account. Only returned on creation. */
+    apiKey?: string;
+    createdAt: string;
+}
+export interface SubAccountCreateRequest {
+    /** Name of the sub-account. */
+    name: string;
+    /** External reference ID for your own tracking. */
+    externalId?: string;
+    /**
+     * Spending cap in cents. When reached, messages from this sub-account will be
+     * blocked. Omit or set to 0 for no limit.
+     */
+    creditLimit?: number;
+    metadata?: {
+        [key: string]: unknown;
+    };
+}
+export interface SubAccountUpdateRequest {
+    name?: string;
+    externalId?: string;
+    creditLimit?: number | null;
+    metadata?: {
+        [key: string]: unknown;
+    };
+    status?: SubAccountStatus;
+}
+export interface SubAccountResponse {
+    subAccount: SubAccount;
+}
+export interface BalanceResponse {
+    /** Team balance in cents. All charges are billed to the parent team. */
+    balance: number;
+    currency: string;
+    /** Spending cap in cents (only for sub-accounts). */
+    creditLimit?: number | null;
+    /** Total amount spent by this sub-account in cents (only for sub-accounts). */
+    totalSpent?: number | null;
+    /** Whether this API key belongs to a sub-account. */
+    isSubAccount?: boolean;
+}
+export interface SubAccountApiKey {
+    id: string;
+    name: string;
+    /** Full API key. Only returned on creation. */
+    key?: string;
+    /** First characters of the key for identification. */
+    keyPrefix: string;
+    environment: SubAccountApiKeyEnvironment;
+    permissions?: Array<string>;
+    lastUsedAt?: number | null;
+    revokedAt?: number | null;
+    createdAt: number;
+}
+export type SubAccountApiKeyEnvironment = 'live' | 'test';
+export interface SubAccountApiKeyCreateRequest {
+    name: string;
+    /** @defaultValue `"live"` */
+    environment?: SubAccountApiKeyCreateRequestEnvironment;
+    permissions?: Array<string>;
+}
+export type SubAccountApiKeyCreateRequestEnvironment = 'live' | 'test';
+/** Business entity type for 10DLC brand registration. */
+export type TenDlcEntityType = 'PRIVATE_PROFIT' | 'PUBLIC_PROFIT' | 'NON_PROFIT' | 'GOVERNMENT' | 'SOLE_PROPRIETOR';
+/**
+ * Status of a 10DLC brand registration.
+ *
+ * - `draft`: created, not yet submitted to the carrier.
+ * - `pending`: submitted, awaiting the carrier's answer.
+ * - `verified`: the carrier registered the brand AND verified the business behind
+ *   it.
+ * - `unverified`: the carrier registered the brand but did not verify the business
+ *   — the registration exists, the identity check did not pass or has not been
+ *   resolved. Campaigns are allowed, with lower daily limits. Read
+ *   `identityStatus` for the carrier's own wording.
+ * - `rejected`: refused by the carrier.
+ * - `failed`: the registration never reached the carrier; the fee is refunded.
+ */
+export type TenDlcBrandStatus = 'draft' | 'pending' | 'verified' | 'unverified' | 'rejected' | 'failed';
+export interface TenDlcBrand {
+    id: string;
+    entityType: TenDlcEntityType;
+    /** Display name of the brand. */
+    displayName: string;
+    /** Legal company name. */
+    companyName?: string | null;
+    /** Employer Identification Number (EIN). */
+    ein?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
+    email: string;
+    /** Contact phone number in E.164 format. */
+    phone: string;
+    street: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    /** Two-letter ISO country code. */
+    country: string;
+    website?: string | null;
+    /** Industry vertical. */
+    vertical: string;
+    stockSymbol?: string | null;
+    stockExchange?: string | null;
+    status: TenDlcBrandStatus;
+    /**
+     * The carrier's raw identity verdict on the business, as the carrier spells it
+     * (`VERIFIED`, `VETTED_VERIFIED`, `SELF_DECLARED`, `UNVERIFIED`). Null while the
+     * identity has not been resolved — which is not the same as verified, and is why
+     * such a brand reports `status: unverified`.
+     */
+    identityStatus?: string | null;
+    /** Trust score assigned by TCR after vetting. */
+    brandScore?: number | null;
+    brandRelationship?: string | null;
+    /** Reason for rejection, if applicable. */
+    failureReason?: string | null;
+    submittedAt?: string | null;
+    verifiedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TenDlcBrandCreateRequest {
+    entityType: TenDlcEntityType;
+    /** Display name of the brand. */
+    displayName: string;
+    /** Legal company name. */
+    companyName?: string;
+    /** Employer Identification Number (format: XX-XXXXXXX). */
+    ein?: string;
+    firstName?: string;
+    lastName?: string;
+    email: string;
+    /** Contact phone in E.164 format. */
+    phone: string;
+    street: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    /** Two-letter ISO country code. */
+    country: string;
+    website?: string;
+    /** Industry vertical. */
+    vertical: string;
+    stockSymbol?: string;
+    stockExchange?: string;
+}
+export interface TenDlcBrandUpdateRequest {
+    entityType?: TenDlcEntityType;
+    displayName?: string;
+    companyName?: string;
+    ein?: string;
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    street?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    website?: string;
+    vertical?: string;
+    stockSymbol?: string;
+    stockExchange?: string;
+}
+export interface TenDlcBrandResponse {
+    brand: TenDlcBrand;
+}
+/**
+ * Status of a 10DLC campaign registration.
+ *
+ * - `draft`: created, not yet submitted.
+ * - `pending`: submitted, awaiting the carriers. Re-read from the carrier every 30
+ *   minutes, so it moves on its own.
+ * - `approved`: SMS to +1 numbers can go out from numbers assigned to it. The
+ *   monthly fee is charged while it is approved.
+ * - `rejected`: refused by the carriers. The one-time registration fee is
+ *   refunded.
+ * - `failed`: the registration did not reach the carriers. The fee is refunded.
+ * - `expired`: was approved and has lapsed.
+ */
+export type TenDlcCampaignStatus = 'draft' | 'pending' | 'approved' | 'rejected' | 'expired' | 'failed';
+export interface TenDlcCampaign {
+    id: string;
+    /** ID of the brand this campaign belongs to. */
+    brandId: string;
+    name: string;
+    /** Campaign use case type. */
+    useCase: string;
+    subUseCases?: Array<string> | null;
+    /** Description of the messaging campaign. */
+    description: string;
+    /** Sample messages representative of campaign content. */
+    sampleMessages: Array<string>;
+    subscriberOptIn: boolean;
+    subscriberOptOut: boolean;
+    subscriberHelp: boolean;
+    numberPooling: boolean;
+    directLending: boolean;
+    embeddedLink: boolean;
+    embeddedPhone: boolean;
+    affiliateMarketing: boolean;
+    ageGated: boolean;
+    messageFlow?: string | null;
+    helpMessage?: string | null;
+    optInKeywords?: Array<string> | null;
+    optOutKeywords?: Array<string> | null;
+    status: TenDlcCampaignStatus;
+    /** Daily message limit based on brand trust score. */
+    dailyLimit?: number | null;
+    failureReason?: string | null;
+    /** One-time registration cost in cents. */
+    registrationCostCents?: number | null;
+    /** Recurring monthly fee in cents. */
+    monthlyFeeCents?: number | null;
+    submittedAt?: string | null;
+    approvedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TenDlcCampaignCreateRequest {
+    /** ID of the brand to create this campaign under. */
+    brandId: string;
+    name: string;
+    /** Campaign use case (e.g., ACCOUNT_NOTIFICATION, MARKETING, 2FA). */
+    useCase: string;
+    subUseCases?: Array<string>;
+    description: string;
+    sampleMessages: Array<string>;
+    subscriberOptIn: boolean;
+    subscriberOptOut: boolean;
+    subscriberHelp: boolean;
+    numberPooling: boolean;
+    directLending: boolean;
+    embeddedLink: boolean;
+    embeddedPhone: boolean;
+    affiliateMarketing: boolean;
+    ageGated: boolean;
+    messageFlow?: string;
+    helpMessage?: string;
+    optInKeywords?: Array<string>;
+    optOutKeywords?: Array<string>;
+}
+export interface TenDlcCampaignUpdateRequest {
+    name?: string;
+    description?: string;
+    sampleMessages?: Array<string>;
+    messageFlow?: string;
+    helpMessage?: string;
+    optInKeywords?: Array<string>;
+    optOutKeywords?: Array<string>;
+}
+export interface TenDlcCampaignResponse {
+    campaign: TenDlcCampaign;
+}
+export interface TenDlcPhoneNumberAssignment {
+    id: string;
+    campaignId: string;
+    phoneNumberId: string;
+    /**
+     * Assignment status. `pending`: sent to the carrier, not confirmed yet. `active`:
+     * the number is on the campaign and can send. `failed`: the carrier refused it;
+     * see `failureReason`. The number is free to be assigned again.
+     */
+    status: TenDlcPhoneNumberAssignmentStatus;
+    failureReason?: string | null;
+    assignedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export type TenDlcPhoneNumberAssignmentStatus = 'pending' | 'active' | 'failed';
+export interface TenDlcPhoneNumberAssignRequest {
+    /** ID of the phone number to assign. */
+    phoneNumberId: string;
+}
+export interface TenDlcAssignmentResponse {
+    assignment: TenDlcPhoneNumberAssignment;
+}
+/** Lifecycle status of a Zavu Function. */
+export type ZavuFunctionStatus = 'draft' | 'bundling' | 'deploying' | 'active' | 'failed' | 'disabled';
+/** Runtime the function is deployed on. */
+export type ZavuFunctionRuntime = 'nodejs24';
+/**
+ * A Zavu Function — user-supplied TypeScript that runs in Zavu Cloud and reacts
+ * to messaging events or HTTP requests.
+ */
+export interface ZavuFunction {
+    id: string;
+    /** URL-safe identifier, unique per project. */
+    slug: string;
+    name: string;
+    description?: string | null;
+    runtime: ZavuFunctionRuntime;
+    status: ZavuFunctionStatus;
+    /** Per-invocation timeout in seconds. */
+    timeoutSec: number;
+    /** Memory allocation in MB. */
+    memoryMb: number;
+    /** Whether the function can be invoked over HTTPS via its public URL. */
+    httpEnabled: boolean;
+    /**
+     * HTTPS endpoint, present only while httpEnabled is true. Null otherwise,
+     * including for a function that was previously exposed — the stored URL stops
+     * serving the moment HTTP is turned off, so it is never returned.
+     */
+    publicUrl?: string | null;
+    /**
+     * npm dependencies installed in the function bundle. Keys are package names,
+     * values are semver ranges.
+     */
+    dependencies: {
+        [key: string]: string;
+    };
+    /** ID of the deployment currently serving traffic. */
+    activeDeploymentId?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ZavuFunctionResponse {
+    function: ZavuFunction;
+}
+export interface FunctionCreateRequest {
+    /** URL-safe identifier (lowercase, digits, hyphens). Must be unique per project. */
+    slug: string;
+    name: string;
+    description?: string;
+    runtime?: ZavuFunctionRuntime;
+    /**
+     * Per-invocation timeout in seconds. Event and cron invocations are asynchronous,
+     * so a long timeout only bounds cost; a tool called during a live conversation
+     * holds up the reply, and a function exposed over HTTP is additionally bounded by
+     * the platform's HTTP response limit.
+     *
+     * @defaultValue `30`
+     */
+    timeoutSec?: number;
+    /** @defaultValue `256` */
+    memoryMb?: FunctionCreateRequestMemoryMb;
+    /**
+     * Whether to expose a public HTTPS URL for this function.
+     *
+     * @defaultValue `false`
+     */
+    httpEnabled?: boolean;
+    /**
+     * The project's source files, keyed by path relative to the project root (e.g.
+     * `index.ts`, `lib/orders.ts`). Imports between them are resolved when the
+     * function is built, so a function can be split across as many files as it needs.
+     *
+     * Paths must be relative and use forward slashes; `..`, `node_modules/` and
+     * `package.json` are rejected. npm packages are not uploaded here — declare them
+     * under `dependencies` and Zavu installs them. Limits: 200 files and 900,000 bytes
+     * for the whole tree.
+     */
+    files?: {
+        [key: string]: string;
+    };
+    /**
+     * Which file in `files` is the entry point. Defaults to `index.ts`.
+     *
+     * @defaultValue `"index.ts"`
+     */
+    entrypoint?: string;
+    /**
+     * Shortcut for a single-file function: exactly equivalent to sending `files` with
+     * one entry named after `entrypoint` (`index.ts` by default). Fully supported —
+     * use whichever fits. If both are sent, `files` wins.
+     */
+    sourceCode?: string;
+    /** npm dependencies. Keys are package names, values are semver ranges. */
+    dependencies?: {
+        [key: string]: string;
+    };
+}
+export type FunctionCreateRequestMemoryMb = 128 | 256 | 512 | 1024;
+/**
+ * Optional source/dependencies update applied before deploying. Omit every field
+ * to redeploy the current draft as-is.
+ */
+export interface FunctionDeployRequest {
+    /**
+     * The project's source files, keyed by path relative to the project root (e.g.
+     * `index.ts`, `lib/orders.ts`). Imports between them are resolved when the
+     * function is built, so a function can be split across as many files as it needs.
+     *
+     * Paths must be relative and use forward slashes; `..`, `node_modules/` and
+     * `package.json` are rejected. npm packages are not uploaded here — declare them
+     * under `dependencies` and Zavu installs them. Limits: 200 files and 900,000 bytes
+     * for the whole tree.
+     */
+    files?: {
+        [key: string]: string;
+    };
+    /**
+     * Which file in `files` is the entry point. Defaults to `index.ts`.
+     *
+     * @defaultValue `"index.ts"`
+     */
+    entrypoint?: string;
+    /**
+     * Shortcut for a single-file function: exactly equivalent to sending `files` with
+     * one entry named after `entrypoint` (`index.ts` by default). Fully supported —
+     * use whichever fits. If both are sent, `files` wins.
+     */
+    sourceCode?: string;
+    /** New dependency map (replaces existing dependencies). */
+    dependencies?: {
+        [key: string]: string;
+    };
+}
+/** Stage of a function deployment. */
+export type FunctionDeploymentStatus = 'pending' | 'bundling' | 'uploading' | 'publishing' | 'active' | 'failed' | 'superseded';
+export interface FunctionDeployment {
+    id: string;
+    functionId: string;
+    /** Monotonically increasing deployment version, starting at 1. */
+    version: number;
+    status: FunctionDeploymentStatus;
+    /** Total size of the deployed source tree in bytes. */
+    sourceCodeBytes?: number | null;
+    /** Size of the built bundle in bytes. Null until the build finishes. */
+    bundleBytes?: number | null;
+    /** Failure reason when status is 'failed'. */
+    errorMessage?: string | null;
+    /**
+     * What the build printed: dependency installation, the bundler's output, and the
+     * compiler's message when it failed. Returned when fetching a single deployment,
+     * omitted from the list. Read this first when a deploy fails — `errorMessage` is
+     * often the outer wrapper's summary, and the line that names the broken import or
+     * the syntax error is here.
+     */
+    buildLogs?: string | null;
+    deployedAt?: string | null;
+    createdAt: string;
+}
+export interface FunctionDeploymentResponse {
+    deployment: FunctionDeployment;
+}
+export interface FunctionLogEvent {
+    timestamp: string;
+    message: string;
+}
+export interface FunctionLogsResponse {
+    events: Array<FunctionLogEvent>;
+    /** Pass to the next request to fetch the following page of logs. */
+    nextToken?: string | null;
+}
+/**
+ * A GitHub repository bound to a function. A push to `branch` deploys the
+ * function. A function holds at most one link.
+ */
+export interface GitRepoLink {
+    id: string;
+    functionId: string;
+    provider: 'github';
+    owner: string;
+    repo: string;
+    /** Only pushes to this branch deploy. */
+    branch: string;
+    /**
+     * Subdirectory holding the project, for monorepos. Null when the project is at the
+     * repository root.
+     */
+    rootDir?: string | null;
+    /** When false the link is kept and pushes are ignored. */
+    autoDeploy: boolean;
+    /**
+     * How this link authenticates, decided by the server rather than by the caller.
+     * - `app`: the Zavu GitHub App is installed on the account. Pushes arrive on the
+     *   app's webhook and private repositories work. Nothing to configure in the
+     *   repository.
+     * - `manual`: no installation. The link carries its own secret and you add the
+     *   webhook to the repository yourself.
+     */
+    connection: GitRepoLinkConnection;
+    lastStatus?: GitRepoLinkLastStatus | null;
+    lastCommitSha?: string | null;
+    lastCommitMessage?: string | null;
+    /** Why the last deploy failed. Null otherwise. */
+    lastError?: string | null;
+    lastDeployAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export type GitRepoLinkConnection = 'app' | 'manual';
+export type GitRepoLinkLastStatus = 'deploying' | 'deployed' | 'failed';
+export interface GitRepoLinkResponse {
+    link: GitRepoLink;
+    /**
+     * Endpoint that receives GitHub's push deliveries. Only needed on a `manual` link,
+     * where you add it to the repository yourself.
+     */
+    webhookUrl: string;
+    /**
+     * Shared secret for the repository's webhook. **Returned only when creating a
+     * `manual` link, and only there** — every later read strips it, and re-linking
+     * mints a new one. Absent entirely on an `app` link, which needs no secret of its
+     * own.
+     */
+    webhookSecret?: string;
+}
+/**
+ * Voice Agent configuration on a sender's AI agent. Controls how the agent behaves
+ * on inbound and outbound phone calls through Zavu's managed voice pipeline
+ * (speech recognition, the agent's LLM, and speech synthesis, with real-time
+ * interruption handling).
+ */
+export interface AgentVoiceConfig {
+    /**
+     * Whether the agent handles voice calls. When false, the sender's number is not
+     * answered by the voice agent and outbound calls are rejected.
+     */
+    enabled: boolean;
+    /**
+     * Opening line the agent speaks when the call connects. If omitted, the agent
+     * waits for the caller to speak first.
+     */
+    greeting?: string;
+    /**
+     * Greeting per language, keyed by language code. Used when the caller's language
+     * differs from the one `greeting` is written in.
+     */
+    greetings?: {
+        [key: string]: string;
+    };
+    /**
+     * BCP-47 language code used for both speech recognition and speech synthesis (e.g.
+     * `en`, `es`, `pt-BR`). Auto-detected from the recipient when omitted.
+     */
+    language?: string;
+    /**
+     * Model that runs the conversation, co-located in the voice network for lowest
+     * latency. Independent of the model used for text messaging. Derived from the
+     * agent's text model when omitted.
+     */
+    model?: string;
+    /** Speech-recognition provider. Uses the default when omitted. */
+    sttProvider?: string;
+    /** Speech-recognition model. Uses the default when omitted. */
+    sttModel?: string;
+    /** Speech-synthesis provider. Uses the default when omitted. */
+    ttsProvider?: string;
+    /**
+     * Identifier of the synthesized voice that speaks. Choose from the voices
+     * available in the dashboard. Uses a neutral default when omitted.
+     */
+    ttsVoiceId?: string;
+    /**
+     * Speech rate. 1.0 is natural. Only honoured by voices that support rate control;
+     * ignored by the others.
+     *
+     * @defaultValue `1.0`
+     */
+    voiceSpeed?: number;
+    /**
+     * Whether the caller can interrupt the agent while it is speaking (barge-in). When
+     * true, the agent stops talking as soon as the caller starts.
+     *
+     * @defaultValue `true`
+     */
+    interruptible?: boolean;
+    /**
+     * Hard limit on call length in minutes. The call ends automatically when reached.
+     *
+     * @defaultValue `15`
+     */
+    maxCallDurationMinutes?: number;
+    /**
+     * How long the agent waits during silence before ending the call.
+     *
+     * @defaultValue `30`
+     */
+    maxIdleSeconds?: number;
+    /** Whether the call audio is recorded. */
+    recordCalls?: boolean;
+    /**
+     * What the agent does when an answering machine or voicemail is detected on an
+     * outbound call.
+     *
+     * @defaultValue `"hangup"`
+     */
+    voicemailAction?: AgentVoiceConfigVoicemailAction;
+    /**
+     * Message spoken when `voicemailAction` is `leave_message`. Falls back to
+     * `greeting` when omitted.
+     */
+    voicemailMessage?: string;
+    /**
+     * E.164 phone number the agent can transfer the call to. When set, the agent is
+     * given a transfer tool it can use to hand the call to a human.
+     */
+    transferPhoneNumber?: string;
+}
+export type AgentVoiceConfigVoicemailAction = 'hangup' | 'leave_message';
+export interface VoiceCall {
+    id: string;
+    direction: VoiceCallDirection;
+    /**
+     * Caller phone number in E.164 format. Your sender's number for outbound calls;
+     * the caller's number for inbound calls.
+     */
+    from: string;
+    /** Callee phone number in E.164 format. */
+    to: string;
+    status: VoiceCallStatus;
+    /**
+     * Why the call ended (e.g. `agent_ended`, `max_duration`, `transfer`, `hangup`).
+     * Present once the call is no longer active.
+     */
+    endReason?: string | null;
+    /** When the call was answered. */
+    answeredAt?: string | null;
+    /** When the call ended. */
+    endedAt?: string | null;
+    /** Billable talk time in seconds, measured from answer to hangup. */
+    durationSeconds?: number | null;
+    /** Number of conversation turns exchanged during the call. */
+    turnCount?: number | null;
+    /**
+     * Ordered transcript of the call. Included when retrieving a single call; omitted
+     * from list responses.
+     */
+    transcript?: Array<VoiceCallTurn>;
+    /**
+     * Total cost of the call in USD, combining the managed voice pipeline per-minute
+     * charge and telephony. Available once the call has ended.
+     */
+    cost?: number | null;
+    /** Arbitrary metadata you attached when creating the call. */
+    metadata?: {
+        [key: string]: string;
+    };
+    createdAt: string;
+    updatedAt?: string;
+}
+/**
+ * Request body to place an outbound voice call. The call is answered by the voice
+ * agent configured on the sender.
+ */
+export interface VoiceCallCreateRequest {
+    /** Recipient phone number in E.164 format. */
+    to: string;
+    /**
+     * Sender profile that places the call. Uses the project's default sender if
+     * omitted. The sender's agent must have voice enabled.
+     */
+    senderId?: string;
+    /** Overrides the agent's configured greeting for this call only. */
+    greeting?: string;
+    /**
+     * Language the agent speaks on this call only, as a BCP-47 tag (`en`, `es`,
+     * `es-ES`, `pt-BR`), or `auto` to detect the caller's language and follow it.
+     * Overrides the agent's configured language for speech recognition, the agent's
+     * replies, and the synthesized voice. If the agent uses a custom voice you
+     * supplied, that voice is kept and only the language changes. When omitted, the
+     * agent's configured language is used.
+     */
+    language?: string;
+    /** Overrides the agent's maximum call duration for this call only. */
+    maxDurationMinutes?: number;
+    /**
+     * Arbitrary metadata to associate with the call. Returned on the call object and
+     * included in voice webhooks.
+     */
+    metadata?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Whether the call was placed by Zavu (outbound) or received from a caller
+ * (inbound).
+ */
+export type VoiceCallDirection = 'inbound' | 'outbound';
+export interface VoiceCallResponse {
+    call: VoiceCall;
+}
+/**
+ * Lifecycle status of a voice call.
+ * - `queued`: outbound call created, not yet dialing.
+ * - `ringing`: dialing (outbound) or received and ringing (inbound).
+ * - `in_progress`: answered, the agent is connected.
+ * - `completed`: ended after a conversation.
+ * - `failed`: could not be completed.
+ * - `busy`: the line was busy.
+ * - `no_answer`: rang but was not answered.
+ * - `canceled`: canceled before it was answered.
+ */
+export type VoiceCallStatus = 'queued' | 'ringing' | 'in_progress' | 'completed' | 'failed' | 'busy' | 'no_answer' | 'canceled';
+/** A single turn in a voice call transcript. */
+export interface VoiceCallTurn {
+    /** Ordinal position of the turn within the call, starting at 0. */
+    seq: number;
+    /**
+     * Who produced the turn. `tool` records a tool call the agent made during the
+     * conversation.
+     */
+    role: VoiceCallTurnRole;
+    /**
+     * Transcribed speech for `user` and `assistant` turns, or a JSON summary of the
+     * tool call for `tool` turns.
+     */
+    text: string;
+    /** When the turn started. */
+    startedAt?: string | null;
+    /** When the turn ended. */
+    endedAt?: string | null;
+}
+export type VoiceCallTurnRole = 'user' | 'assistant' | 'tool';
+/**
+ * A fully rendered factory agent: the function files to scaffold plus the secrets
+ * it needs. Returned by GET /v1/agent-templates/{templateId} and consumed by `npx
+ * zavudev agents pull`.
+ */
+export interface AgentTemplate {
+    id: string;
+    name: string;
+    summary: string;
+    category: AgentTemplateCategory;
+    voice: boolean;
+    defaultSlug: string;
+    files: Array<AgentTemplateFile>;
+    /** npm dependencies for the scaffolded function. */
+    dependencies: {
+        [key: string]: string;
+    };
+    requiredSecrets: Array<AgentTemplateRequiredSecretsItem>;
+}
+export type AgentTemplateCategory = 'sales' | 'support' | 'frontDesk' | 'ops';
+export interface AgentTemplateRequiredSecretsItem {
+    key: string;
+    hint: string;
+}
+export interface AgentTemplateFile {
+    path: string;
+    /** File contents to write verbatim. */
+    content: string;
+}
+/** Compact catalog entry for a factory agent. */
+export interface AgentTemplateSummary {
+    id: string;
+    name: string;
+    summary: string;
+    category: AgentTemplateSummaryCategory;
+    /** Whether this agent answers phone calls. */
+    voice: boolean;
+    toolCount: number;
+}
+export type AgentTemplateSummaryCategory = 'sales' | 'support' | 'frontDesk' | 'ops';
+export interface EmailDomain {
+    id: string;
+    domain: string;
+    /** Overall verification status. */
+    status: string;
+    dkimStatus: string;
+    /**
+     * DNS records to publish. Present when fetching a single domain or after adding
+     * one.
+     */
+    dnsRecords?: Array<EmailDomainDnsRecord>;
+}
+export interface EmailDomainDnsRecord {
+    /** DNS record type. */
+    type: string;
+    /** Record host/name to create. */
+    name: string;
+    /** Record value. */
+    value: string;
+    /** Priority (MX records only). */
+    priority?: number;
+    /**
+     * What the record is for. `ownership` is a TXT at `_zavu-verification.<domain>`,
+     * returned only when another Zavu account also added this domain and neither has
+     * verified it: DKIM records are the same for everyone, so the domain verifies only
+     * once this account's own token is published.
+     */
+    purpose: EmailDomainDnsRecordPurpose;
+    /**
+     * Whether the record is required to verify + send (DKIM) or recommended for
+     * deliverability.
+     */
+    required: boolean;
+}
+export type EmailDomainDnsRecordPurpose = 'dkim' | 'spf' | 'dmarc' | 'mail_from' | 'ownership';
+/**
+ * Run the agent and return what it would say. Nothing is delivered to anyone and
+ * no execution is recorded.
+ *
+ * A run is **billed like a live reply**: on an agent with the `zavu` provider it
+ * is charged to your balance at the same price per token, and refused with `402
+ * insufficient_balance` at a balance of zero. On a bring-your-own-key agent it
+ * costs your provider, not Zavu. `cost` on the response is what this run charged.
+ */
+export interface AgentTestRequest {
+    /** What to say to the agent. */
+    message: string;
+    /**
+     * Prior turns, oldest first, to exercise multi-turn behaviour without persisting a
+     * thread. Trimmed to the agent's context window.
+     */
+    history?: Array<AgentTestRequestHistoryItem>;
+    /**
+     * Set false to skip retrieval and isolate prompt behaviour from the knowledge
+     * base.
+     *
+     * @defaultValue `true`
+     */
+    useKnowledgeBase?: boolean;
+    /**
+     * Run the tools the agent calls instead of reporting the choice and stopping.
+     *
+     * Off by default because a tool handler talks to the outside world: a rehearsal
+     * that charges a card is not a rehearsal. Turn it on to exercise the loop that
+     * actually matters — the model picks a tool, the handler answers, the model
+     * replies with the result — without sending a message to anyone. What ran comes
+     * back in `executedToolCalls`.
+     *
+     * @defaultValue `false`
+     */
+    executeTools?: boolean;
+}
+export interface AgentTestRequestHistoryItem {
+    role: AgentTestRequestHistoryItemRole;
+    content: string;
+}
+export type AgentTestRequestHistoryItemRole = 'user' | 'assistant';
+export interface AgentTestResponse {
+    success: boolean;
+    /** What the agent would reply. */
+    text: string | null;
+    error: string | null;
+    inputTokens: number;
+    outputTokens: number;
+    latencyMs: number;
+    /**
+     * Knowledge-base chunks retrieved for this message. Zero means the answer was not
+     * grounded in your documents.
+     */
+    knowledgeChunksUsed: number;
+    /**
+     * Tools that actually ran, in order, when the request set `executeTools`. Empty on
+     * a normal dry run, where nothing is executed. An entry with `ok: false` means the
+     * agent saw an error and answered around it, which is what a customer would have
+     * received.
+     */
+    executedToolCalls?: Array<AgentTestResponseExecutedToolCallsItem>;
+    /**
+     * Things that are true of this agent but that a dry run cannot prove. Surfaced so
+     * a passing dry run is never mistaken for proof that the agent works live.
+     *
+     * - The agent being disabled.
+     * - Enabled tools that were offered to the model but not run: if the agent picks
+     *   one, the reply stops at that choice (see `plannedToolCalls`). Pass
+     *   `executeTools` to run them.
+     * - Tools that ran for real, when `executeTools` was set, and any that failed.
+     * - An agent whose sender has none of the channels it triggers on, which answers
+     *   every dry run and no real message.
+     * - Contact metadata that exists on a real conversation but not here, and memory
+     *   tools (`remember`, `recall`, `save_record`), which have no contact to write
+     *   about on a test run.
+     */
+    warnings: Array<string>;
+    /**
+     * USD charged to your balance for this run. 0 on a bring-your-own-key agent. When
+     * the balance covers only part of a run, that part is charged and the next run is
+     * refused with `402`.
+     */
+    cost: number;
+    /**
+     * Tools the model chose to call, with the arguments it chose, on a run without
+     * `executeTools`. Nothing was executed: the reply stops at the choice. Empty when
+     * it answered without reaching for a tool, and on a run that executed tools (see
+     * `executedToolCalls`).
+     */
+    plannedToolCalls: Array<AgentTestResponsePlannedToolCallsItem>;
+}
+export interface AgentTestResponseExecutedToolCallsItem {
+    name: string;
+    ok: boolean;
+    error?: string | null;
+}
+export interface AgentTestResponsePlannedToolCallsItem {
+    name: string;
+    /** The arguments as a JSON string. */
+    arguments: string;
+}
+/**
+ * Create an agent that exists on its own. Connect senders afterwards; an agent
+ * answers on any number of them.
+ *
+ * **Sub-resources.** An agent's tools, flows and knowledge bases are reachable at
+ * `/v1/agents/{agentId}/tools`, `/v1/agents/{agentId}/flows` and
+ * `/v1/agents/{agentId}/knowledge-bases`, mirroring the sender-scoped routes
+ * documented under `/v1/senders/{senderId}/agent/...` exactly. Use the
+ * agent-scoped form while the agent has no sender: the sender-scoped one cannot
+ * address it.
+ */
+export interface AgentCreateStandaloneRequest {
+    name: string;
+    provider: AgentProvider;
+    model: string;
+    systemPrompt: string;
+    /**
+     * API key for the LLM provider. Required unless provider is 'zavu'. Stored
+     * encrypted and never returned.
+     */
+    apiKey?: string;
+    /** @defaultValue `10` */
+    contextWindowMessages?: number;
+    /** @defaultValue `true` */
+    includeContactMetadata?: boolean;
+    /** @defaultValue `["*"]` */
+    triggerOnChannels?: Array<string>;
+    /** @defaultValue `["text"]` */
+    triggerOnMessageTypes?: Array<string>;
+    maxTokens?: number;
+    temperature?: number;
+    voice?: AgentVoiceConfig;
+}
+/**
+ * Fields to update on an existing function. Provide at least one. `files` /
+ * `sourceCode` and `dependencies` edit the draft and take effect on the next
+ * deploy; `httpEnabled` applies immediately to the deployed function.
+ */
+export interface FunctionUpdateRequest {
+    /**
+     * The project's source files, keyed by path relative to the project root (e.g.
+     * `index.ts`, `lib/orders.ts`). Imports between them are resolved when the
+     * function is built, so a function can be split across as many files as it needs.
+     *
+     * Paths must be relative and use forward slashes; `..`, `node_modules/` and
+     * `package.json` are rejected. npm packages are not uploaded here — declare them
+     * under `dependencies` and Zavu installs them. Limits: 200 files and 900,000 bytes
+     * for the whole tree.
+     */
+    files?: {
+        [key: string]: string;
+    };
+    /**
+     * Which file in `files` is the entry point. Defaults to `index.ts`.
+     *
+     * @defaultValue `"index.ts"`
+     */
+    entrypoint?: string;
+    /**
+     * Shortcut for a single-file function: exactly equivalent to sending `files` with
+     * one entry named after `entrypoint` (`index.ts` by default). Fully supported —
+     * use whichever fits. If both are sent, `files` wins.
+     */
+    sourceCode?: string;
+    /** New dependency map (replaces existing dependencies). */
+    dependencies?: {
+        [key: string]: string;
+    };
+    /**
+     * Expose the function on its public HTTPS URL, or take it down. Applies to the
+     * already-deployed function without redeploying; the URL is returned as
+     * `publicUrl`.
+     */
+    httpEnabled?: boolean;
+}
+/**
+ * Which `X-Zavu-Signature` scheme this receiver is sent.
+ *
+ * - `v1`: `v1=HMAC_SHA256(secret, body)`. The scheme used before this was
+ *   configurable. Existing webhooks stay on it until you move them.
+ * - `v2`: `v2=HMAC_SHA256(secret, "{t}.{body}")`. The current scheme, and the
+ *   default for new senders. It signs the timestamp together with the body.
+ * - `v1+v2`: both signatures, sharing one `t`. The migration setting: a receiver
+ *   reading either one works, so you can deploy and confirm your new verifier
+ *   before switching over.
+ *
+ * Moving from `v1` straight to `v2` returns `400`. Set `v1+v2` first. See
+ * https://docs.zavu.dev/guides/receiving-messages/signature-migration
+ */
+export type WebhookSignatureVersion = 'v1' | 'v1+v2' | 'v2';
+/**
+ * The project-level webhook. It receives project events such as
+ * `invitation.status_changed` for this project only: a parent project does not
+ * receive its sub-accounts' events, so configure one per sub-account with that
+ * sub-account's API key.
+ */
+export interface ProjectWebhook {
+    url: string;
+    events: Array<ProjectWebhookEvent>;
+    /**
+     * Signing secret for `X-Zavu-Signature`. Returned only by `POST
+     * /v1/invitations/webhook`.
+     */
+    secret?: string;
+    active: boolean;
+}
+/**
+ * Events a project webhook can subscribe to. Any other value is refused with
+ * `400`.
+ */
+export type ProjectWebhookEvent = 'invitation.status_changed' | 'broadcast.status_changed' | 'domain.verified' | 'domain.failed';
+export interface ProjectWebhookCreateRequest {
+    url: string;
+    events: Array<ProjectWebhookEvent>;
+}
+/**
+ * Only valid on a webhook created with `POST /v1/invitations/webhook`; updating
+ * one that does not exist returns `400`.
+ */
+export interface ProjectWebhookUpdateRequest {
+    url?: string;
+    events?: Array<ProjectWebhookEvent>;
+    active?: boolean;
+}
+/**
+ * A channel whose connection has an on/off switch. `sms`, `sms_oneway` and `voice`
+ * are billed per message and per phone number, are always on, and have nothing to
+ * activate.
+ */
+export type ActivatableChannel = 'whatsapp' | 'telegram' | 'instagram' | 'messenger' | 'email';
+export interface SenderChannelActivationResponse {
+    /** The sender after the change. `channels` includes the channel once it is active. */
+    sender: Sender;
+    channel: ActivatableChannel;
+    /**
+     * True when this call switched the channel on. False when it was already active;
+     * nothing was charged.
+     */
+    activated: boolean;
+    /**
+     * Cents taken from the balance by this call. Zero when the channel was already
+     * active, its month is already paid, or the plan includes it.
+     */
+    chargedCents: number;
+    /**
+     * Cents this connection adds to each month while it stays active. Zero when the
+     * plan includes it.
+     */
+    monthlyCents: number;
+}
+export interface SenderChannelDeactivationResponse {
+    sender: Sender;
+    channel: ActivatableChannel;
+    /**
+     * True when this call switched the channel off. False when it was already
+     * inactive.
+     */
+    deactivated: boolean;
+}
+export interface CreateMemoryCollectionResponse {
+    collection: MemoryCollection;
+}
+export interface ListMemoryCollectionsResponse {
+    items: Array<MemoryCollection>;
+    nextCursor?: string | null;
+}
+export interface GetMemoryCollectionResponse {
+    collection: MemoryCollection;
+}
+export interface UpdateMemoryCollectionResponse {
+    collection: MemoryCollection;
+}
+export interface DeleteMemoryCollectionResponse {
+    status: string;
+}
+export interface ListMemoryItemsResponse {
+    items: Array<MemoryItem>;
+    nextCursor?: string | null;
+}
+export interface PutMemoryItemResponse {
+    item: MemoryItem;
+}
+export interface GetMemoryItemResponse {
+    item: MemoryItem;
+}
+export interface QueryMemoryItemsResponse {
+    items: Array<MemoryItem>;
+    nextCursor?: string | null;
+}
+export interface AddMemoryResponse {
+    memory: MemoryRecord;
+}
+export interface ListMemoriesResponse {
+    items: Array<Memory>;
+    nextCursor?: string | null;
+}
+export interface WipeMemoryScopeResponse {
+    status: string;
+}
+export interface SearchMemoriesResponse {
+    items: Array<Memory>;
+}
+export interface GetMemoryUsageResponse {
+    usage: MemoryUsage;
+}
+export interface GetMemoryResponse {
+    memory: Memory;
+}
+export interface ListFunctionEventTypesResponse {
+    events: Array<string>;
+}
+export interface ListFunctionTriggersResponse {
+    triggers: Array<FunctionTrigger>;
+}
+export interface CreateFunctionTriggersBody {
+    /** Event types to subscribe to. */
+    eventTypes: Array<string>;
+    /** Senders to scope the triggers to. Use null for all senders. */
+    senderIds: Array<string | null>;
+    /**
+     * Required when eventTypes includes `cron`: a 5-field cron expression (minute hour
+     * day-of-month month day-of-week), evaluated in UTC.
+     */
+    cron?: string;
+}
+export interface CreateFunctionTriggersResponse {
+    added: number;
+    /** Number of triggers that already existed. */
+    skipped: number;
+    triggers: Array<FunctionTrigger>;
+}
+export interface UpdateFunctionTriggerBody {
+    active: boolean;
+}
+export interface UpdateFunctionTriggerResponse {
+    ok: boolean;
+    active: boolean;
+}
+export interface ListFunctionDeploymentsResponse {
+    deployments: Array<ListFunctionDeploymentsResponseDeploymentsItem>;
+}
+export interface ListFunctionDeploymentsResponseDeploymentsItem {
+    id?: string;
+    version?: number;
+    status?: FunctionDeploymentStatus;
+    bundleSizeBytes?: number | null;
+    errorMessage?: string | null;
+    isActive?: boolean;
+    /**
+     * When the deployment went live. Null for a deployment that failed or is still
+     * building.
+     */
+    deployedAt?: string | null;
+    createdAt?: string;
+}
+export interface RollbackFunctionBody {
+    /** ID of the deployment to roll back to. */
+    deploymentId: string;
+}
+export interface RollbackFunctionResponse {
+    deployment: FunctionDeployment;
+    rolledBackToVersion?: number;
+    /** The draft that was replaced, so a UI can offer to restore it. */
+    previousDraft?: {
+        [key: string]: unknown;
+    } | null;
+}
+export interface EscalateUrlBody {
+    /** Why the URL should be reviewed manually. */
+    reason: string;
+}
+export interface EscalateUrlResponse {
+    url: VerifiedUrl;
+    message: string;
+}
+export interface SendMessageError429 {
+    code?: string;
+    message?: string;
+    details?: {
+        [key: string]: unknown;
+    };
+    error?: Error;
+}
+export type ListMessagesStatus = 'queued' | 'sending' | 'sent' | 'delivered' | 'failed' | 'received';
+export type ListMessagesChannel = 'sms' | 'sms_oneway' | 'whatsapp' | 'email' | 'telegram' | 'instagram' | 'messenger' | 'voice';
+export interface ListMessagesResponse {
+    items: Array<Message>;
+    nextCursor?: string | null;
+}
+export interface ShowTypingIndicatorResponse {
+    success: boolean;
+}
+export interface ListTemplatesResponse {
+    items: Array<Template>;
+    nextCursor?: string | null;
+}
+export interface SyncTemplatesBody {
+    /**
+     * Sync only the WhatsApp Business Account attached to this sender. If omitted,
+     * every WhatsApp sender in the project is synced.
+     */
+    senderId?: string;
+}
+export interface SyncTemplatesResponse {
+    /** WhatsApp Business Accounts reconciled in this call. */
+    accountsSynced: number;
+    /** Templates that existed on Meta and were created in Zavu by this call. */
+    imported: number;
+    /**
+     * Existing Zavu templates that were matched to a Meta template by name and bound
+     * to its Meta ID.
+     */
+    linked: number;
+    /**
+     * Templates brought back in line with Meta — approval status, category, or both.
+     * A template whose status and category both moved is counted once.
+     */
+    updated: number;
+    /**
+     * Meta templates left alone: already linked to a Zavu template, or
+     * rejected/disabled on Meta.
+     */
+    skipped: number;
+    /**
+     * Problems hit while syncing. Non-empty with a 200 means part of the sync did not
+     * complete — the rest still did.
+     */
+    errors: Array<string>;
+}
+export interface SubmitTemplateBody {
+    /** The sender ID with the WhatsApp Business Account to submit the template to. */
+    senderId: string;
+    /** Template category. If not provided, uses the category set on the template. */
+    category?: WhatsAppCategory;
+    /**
+     * Sample value for each body variable, sent to Meta as the example it reviews the
+     * template with. Key a named variable (`{{customer_name}}`) by its name, and a
+     * positional one (`{{1}}`, `{{2}}`) as `var1`, `var2`.
+     *
+     * Any variable left out gets a generic placeholder: a stock value for a few common
+     * names (`name`, `order_id`, `code`, ...) and `Sample <variable>` for the rest.
+     * Meta reviews those less favourably, so send a realistic value for every
+     * variable.
+     */
+    variableExamples?: {
+        [key: string]: string;
+    };
+}
+export interface ListSendersResponse {
+    items: Array<Sender>;
+    nextCursor?: string | null;
+}
+export interface UpdateSenderProfileResponse {
+    success: boolean;
+    profile: WhatsAppBusinessProfile;
+}
+export interface UploadSenderProfilePictureResponse {
+    success: boolean;
+    profile: WhatsAppBusinessProfile;
+}
+export interface ListContactsResponse {
+    items: Array<Contact>;
+    nextCursor?: string | null;
+}
+export type ListConversationsChannel = 'sms' | 'sms_oneway' | 'whatsapp' | 'email' | 'telegram' | 'instagram' | 'messenger' | 'voice';
+export interface ListConversationsResponse {
+    items: Array<Conversation>;
+    nextCursor?: string | null;
+}
+export interface ListConversationMessagesResponse {
+    items: Array<Message>;
+    nextCursor?: string | null;
+}
+export interface ListBroadcastsResponse {
+    items: Array<Broadcast>;
+    nextCursor?: string | null;
+}
+export interface ListBroadcastContactsResponse {
+    items: Array<BroadcastContact>;
+    nextCursor?: string | null;
+}
+export interface GetPhoneNumberRequirementsResponse {
+    items: Array<Requirement>;
+}
+export interface SearchAvailablePhoneNumbersResponse {
+    items: Array<AvailablePhoneNumber>;
+}
+export interface ListPhoneNumbersResponse {
+    items: Array<OwnedPhoneNumber>;
+    nextCursor?: string | null;
+}
+export interface ListInvitationsResponse {
+    items: Array<Invitation>;
+    nextCursor?: string | null;
+}
+export interface GetProjectWebhookResponse {
+    webhook: ProjectWebhook | null;
+}
+export interface ConfigureProjectWebhookResponse {
+    webhook: ProjectWebhook;
+}
+export interface UpdateProjectWebhookResponse {
+    webhook: ProjectWebhook;
+}
+export interface ListAddressesResponse {
+    items: Array<Address>;
+    nextCursor?: string | null;
+}
+export interface ListRegulatoryDocumentsResponse {
+    items: Array<RegulatoryDocument>;
+    nextCursor?: string | null;
+}
+export interface ListAgentExecutionsResponse {
+    items: Array<AgentExecution>;
+    nextCursor?: string | null;
+}
+export interface GetAgentExecutionResponse {
+    execution: AgentExecution;
+}
+export interface ListAgentFlowsResponse {
+    items: Array<AgentFlow>;
+    nextCursor?: string | null;
+}
+export interface ListAgentToolsResponse {
+    items: Array<AgentTool>;
+    nextCursor?: string | null;
+}
+export interface ListAgentToolTestRunsResponse {
+    items: Array<AgentToolTestRun>;
+}
+export interface ListAgentKnowledgeBasesResponse {
+    items: Array<AgentKnowledgeBase>;
+    nextCursor?: string | null;
+}
+export interface ListAgentDocumentsResponse {
+    items: Array<AgentDocument>;
+    nextCursor?: string | null;
+}
+export interface ListUrlsResponse {
+    items: Array<VerifiedUrl>;
+    nextCursor?: string | null;
+}
+export interface GetMeResponse {
+    project: GetMeResponseProject;
+    team: GetMeResponseTeam;
+    apiKey: GetMeResponseApiKey;
+    isTestMode: boolean;
+}
+export interface GetMeResponseProject {
+    id: string;
+    name: string | null;
+    isSubAccount: boolean;
+}
+export interface GetMeResponseTeam {
+    id: string;
+    name: string | null;
+}
+export interface GetMeResponseApiKey {
+    id: string;
+}
+export interface ListSubAccountsResponse {
+    items: Array<SubAccount>;
+    nextCursor?: string | null;
+}
+export interface DeactivateSubAccountResponse {
+    message: string;
+    /** Number of API keys revoked. */
+    keysRevoked: number;
+}
+export interface ListSubAccountApiKeysResponse {
+    items: Array<SubAccountApiKey>;
+}
+export interface CreateSubAccountApiKeyResponse {
+    apiKey: CreateSubAccountApiKeyResponseApiKey;
+}
+export interface CreateSubAccountApiKeyResponseApiKey {
+    id: string;
+    key: string;
+    name: string;
+    environment: CreateSubAccountApiKeyResponseApiKeyEnvironment;
+}
+export type CreateSubAccountApiKeyResponseApiKeyEnvironment = 'live' | 'test';
+export interface ListTenDlcBrandsResponse {
+    items: Array<TenDlcBrand>;
+    nextCursor?: string | null;
+}
+export interface ListTenDlcUseCasesResponse {
+    useCases: Array<ListTenDlcUseCasesResponseUseCasesItem>;
+}
+export interface ListTenDlcUseCasesResponseUseCasesItem {
+    /** Use case identifier. Pass it as `useCase` when creating a campaign. */
+    name?: string;
+    description?: string;
+}
+export interface ListTenDlcCampaignsResponse {
+    items: Array<TenDlcCampaign>;
+    nextCursor?: string | null;
+}
+export interface ListTenDlcCampaignPhoneNumbersResponse {
+    items: Array<TenDlcPhoneNumberAssignment>;
+    nextCursor?: string | null;
+}
+export interface DeleteFunctionResponse {
+    deleted: boolean;
+    name?: string;
+    slug?: string;
+}
+export interface ListFunctionSecretsResponse {
+    secrets: Array<ListFunctionSecretsResponseSecretsItem>;
+}
+export interface ListFunctionSecretsResponseSecretsItem {
+    id: string;
+    key: string;
+    valueLast4: string;
+    syncedToAws?: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface SetFunctionSecretBody {
+    value: string;
+}
+export interface CreateFunctionGitLinkBody {
+    owner: string;
+    repo: string;
+    /** @defaultValue `"main"` */
+    branch?: string;
+    /** Subdirectory holding the project, for monorepos. */
+    rootDir?: string;
+    /** @defaultValue `true` */
+    autoDeploy?: boolean;
+}
+export interface UpdateFunctionGitLinkBody {
+    branch?: string;
+    rootDir?: string | null;
+    autoDeploy?: boolean;
+}
+export interface DeployFunctionGitLinkResponse {
+    scheduled: boolean;
+}
+export interface ListCallsResponse {
+    items: Array<VoiceCall>;
+    nextCursor?: string | null;
+}
+export interface ListAgentTemplatesResponse {
+    items: Array<AgentTemplateSummary>;
+}
+export interface GetAgentTemplateResponse {
+    template: AgentTemplate;
+}
+export interface AddEmailDomainBody {
+    /** Bare domain, e.g. example.com. */
+    domain: string;
+}
+export interface AddEmailDomainResponse {
+    domain: EmailDomain;
+}
+export interface ListEmailDomainsResponse {
+    items: Array<EmailDomain>;
+}
+export interface GetEmailDomainResponse {
+    domain: EmailDomain;
+}
+export interface VerifyEmailDomainResponse {
+    domain: EmailDomain;
+}
+export interface ConnectSenderTelegramBody {
+    /** Bot token from @BotFather. */
+    botToken: string;
+}
+export interface ConnectSenderTelegramResponse {
+    telegram: ConnectSenderTelegramResponseTelegram;
+}
+export interface ConnectSenderTelegramResponseTelegram {
+    connected: boolean;
+    botUsername?: string;
+    botId?: string;
+}
+export interface ListAgentsResponse {
+    items: Array<Agent>;
+    nextCursor?: string | null;
+}
+export interface CreateStandaloneAgentResponse {
+    agent: Agent;
+}
+export interface GetAgentByIdResponse {
+    agent: Agent;
+}
+export interface UpdateAgentByIdResponse {
+    agent: Agent;
+}
+export interface AttachAgentSenderBody {
+    /** Sender to connect. */
+    senderId: string;
+}
+export interface AttachAgentSenderResponse {
+    agent: Agent;
+}
+export interface ListAgentVoicesResponse {
+    items: Array<ListAgentVoicesResponseItemsItem>;
+    /** Languages an agent can be pinned to. `auto` follows the caller. */
+    languages: Array<string>;
+    /** Voices in the catalog, before filtering. */
+    total?: number;
+}
+export interface ListAgentVoicesResponseItemsItem {
+    /** Value for `voice.ttsVoiceId`. */
+    id: string;
+    name: string;
+    language: string;
+}
+/** Params for `addresses.create`. */
+export interface AddressesCreateParams extends AddressCreateRequest {
+}
+/** Params for `addresses.list`. */
+export interface AddressesListParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `agents.create`. */
+export interface AgentsCreateParams extends AgentCreateStandaloneRequest {
+}
+/** Params for `agents.update`. */
+export interface AgentsUpdateParams extends AgentUpdateRequest {
+}
+/** Params for `agents.list`. */
+export interface AgentsListParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `agents.listVoices`. */
+export interface AgentsListVoicesParams {
+    /** BCP-47 tag (`en`, `es`, `pt-BR`). Omit, or pass `auto`, for every voice. */
+    language?: string;
+}
+/** Params for `agents.test`. */
+export interface AgentsTestParams extends AgentTestRequest {
+}
+/** Params for `agents.senders.connect`. */
+export interface AgentsSendersConnectParams extends AttachAgentSenderBody {
+}
+/** Params for `agents.senders.disconnect`. */
+export interface AgentsSendersDisconnectParams {
+    /** Agent ID. */
+    agentId: string;
+}
+/** Params for `broadcasts.create`. */
+export interface BroadcastsCreateParams extends BroadcastCreateRequest {
+}
+/** Params for `broadcasts.update`. */
+export interface BroadcastsUpdateParams extends BroadcastUpdateRequest {
+}
+/** Params for `broadcasts.list`. */
+export interface BroadcastsListParams {
+    status?: BroadcastStatus;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `broadcasts.reschedule`. */
+export interface BroadcastsRescheduleParams extends BroadcastRescheduleRequest {
+}
+/** Params for `broadcasts.send`. */
+export interface BroadcastsSendParams extends BroadcastSendRequest {
+}
+/** Params for `broadcasts.contacts.list`. */
+export interface BroadcastsContactsListParams {
+    status?: BroadcastContactStatus;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `broadcasts.contacts.add`. */
+export interface BroadcastsContactsAddParams extends BroadcastContactsAddRequest {
+}
+/** Params for `broadcasts.contacts.remove`. */
+export interface BroadcastsContactsRemoveParams {
+    broadcastId: string;
+}
+/** Params for `calls.create`. */
+export interface CallsCreateParams extends VoiceCallCreateRequest {
+}
+/** Params for `calls.list`. */
+export interface CallsListParams {
+    status?: VoiceCallStatus;
+    direction?: VoiceCallDirection;
+    /** Keep only calls placed or received by this sender. */
+    senderId?: string;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `contacts.create`. */
+export interface ContactsCreateParams extends ContactCreateRequest {
+}
+/** Params for `contacts.update`. */
+export interface ContactsUpdateParams extends ContactUpdateRequest {
+}
+/** Params for `contacts.list`. */
+export interface ContactsListParams {
+    /** Exact match on the contact's primary phone number, in E.164. */
+    phoneNumber?: string;
+    /**
+     * Free-text match over the contact's name (`displayName` and the WhatsApp profile
+     * name), phone numbers and email addresses. Case- and accent-insensitive. A phone
+     * number matches on a trailing fragment too, so `5551234` finds `+14155551234`.
+     *
+     * Contacts created automatically from an inbound message have no `displayName` —
+     * they are matched by their identifier until you set one with `PATCH
+     * /v1/contacts/{contactId}`.
+     *
+     * Results come back in relevance order rather than newest-first. `cursor` is
+     * opaque in both modes; pass back exactly what the previous response returned, and
+     * start a new pagination run when the search term changes.
+     */
+    search?: string;
+    /**
+     * Tag name. Repeatable: `?tag=vip&tag=chile` returns contacts carrying **every**
+     * tag given, not any of them — the same rule the dashboard filter applies.
+     *
+     * Tags are matched by name, case-insensitively. An unknown tag returns 400 rather
+     * than being ignored, because a typo that silently matched every contact would be
+     * a worse answer than an error.
+     */
+    tag?: Array<string>;
+    /** @defaultValue `50` */
+    limit?: number;
+    /** Opaque cursor from a previous response's `nextCursor`. Do not construct it. */
+    cursor?: string;
+}
+/** Params for `contacts.merge`. */
+export interface ContactsMergeParams extends MergeContactsRequest {
+}
+/** Params for `contacts.channels.update`. */
+export interface ContactsChannelsUpdateParams extends UpdateChannelRequest {
+    contactId: string;
+}
+/** Params for `contacts.channels.add`. */
+export interface ContactsChannelsAddParams extends AddChannelRequest {
+}
+/** Params for `contacts.channels.remove`. */
+export interface ContactsChannelsRemoveParams {
+    contactId: string;
+}
+/** Params for `contacts.channels.setPrimary`. */
+export interface ContactsChannelsSetPrimaryParams {
+    contactId: string;
+}
+/** Params for `conversations.list`. */
+export interface ConversationsListParams {
+    /** Keep only threads that have carried this channel. */
+    channel?: ListConversationsChannel;
+    /** Keep only threads last handled by this sender. */
+    senderId?: string;
+    /**
+     * Search threads by identity: phone number (any format — `+1 (555) 123-4567` and
+     * `15551234567` both match), email address (full or local part), WhatsApp
+     * username, or BSUID. Matching is by whole word, with prefix matching on the last
+     * term, so `mar` finds `maria@example.com` and `+1555` finds `+15551234567`; a
+     * fragment from the middle or end of a number (`4567`) does not match.
+     *
+     * It does **not** search message bodies — only who the thread is with.
+     *
+     * Results come back ranked by relevance rather than by recency, so the usual "most
+     * recently active first" ordering does not apply while `q` is set. `senderId` and
+     * `channel` still narrow the results, and `cursor` paginates them as usual. An
+     * empty or whitespace-only `q` returns no items rather than the full list.
+     */
+    search?: string;
+    /** @defaultValue `50` */
+    limit?: number;
+    /** Opaque cursor from a previous response's `nextCursor`. Do not construct it. */
+    cursor?: string;
+}
+/** Params for `conversations.listMessages`. */
+export interface ConversationsListMessagesParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    /** Opaque cursor from a previous response's `nextCursor`. */
+    cursor?: string;
+}
+/** Params for `emailDomains.create`. */
+export interface EmailDomainsCreateParams extends AddEmailDomainBody {
+}
+/** Params for `functions.create`. */
+export interface FunctionsCreateParams extends FunctionCreateRequest {
+}
+/** Params for `functions.update`. */
+export interface FunctionsUpdateParams extends FunctionUpdateRequest {
+}
+/** Params for `functions.deploy`. */
+export interface FunctionsDeployParams extends FunctionDeployRequest {
+}
+/** Params for `functions.listDeployments`. */
+export interface FunctionsListDeploymentsParams {
+    /** @defaultValue `50` */
+    limit?: number;
+}
+/** Params for `functions.rollbackDeployment`. */
+export interface FunctionsRollbackDeploymentParams extends RollbackFunctionBody {
+}
+/** Params for `functions.tailLogs`. */
+export interface FunctionsTailLogsParams {
+    /** @defaultValue `100` */
+    limit?: number;
+    nextToken?: string;
+    /** Start of the log window in Unix epoch milliseconds. */
+    startTime?: number;
+    /** End of the log window in Unix epoch milliseconds. */
+    endTime?: number;
+    filterPattern?: string;
+}
+/** Params for `functions.gitLink.update`. */
+export interface FunctionsGitLinkUpdateParams extends UpdateFunctionGitLinkBody {
+}
+/** Params for `functions.gitLink.link`. */
+export interface FunctionsGitLinkLinkParams extends CreateFunctionGitLinkBody {
+}
+/** Params for `functions.secrets.set`. */
+export interface FunctionsSecretsSetParams extends SetFunctionSecretBody {
+    /** Zavu Function ID. */
+    functionId: string;
+}
+/** Params for `functions.secrets.unset`. */
+export interface FunctionsSecretsUnsetParams {
+    /** Zavu Function ID. */
+    functionId: string;
+}
+/** Params for `functions.triggers.create`. */
+export interface FunctionsTriggersCreateParams extends CreateFunctionTriggersBody {
+}
+/** Params for `functions.triggers.update`. */
+export interface FunctionsTriggersUpdateParams extends UpdateFunctionTriggerBody {
+}
+/** Params for `introspect.validateEmail`. */
+export interface IntrospectValidateEmailParams extends EmailIntrospectionRequest {
+}
+/** Params for `introspect.validatePhone`. */
+export interface IntrospectValidatePhoneParams extends PhoneIntrospectionRequest {
+}
+/** Params for `invitations.create`. */
+export interface InvitationsCreateParams extends InvitationCreateRequest {
+}
+/** Params for `invitations.list`. */
+export interface InvitationsListParams {
+    status?: InvitationStatus;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `invitations.webhook.configure`. */
+export interface InvitationsWebhookConfigureParams extends ProjectWebhookCreateRequest {
+}
+/** Params for `invitations.webhook.update`. */
+export interface InvitationsWebhookUpdateParams extends ProjectWebhookUpdateRequest {
+}
+/** Params for `messages.list`. */
+export interface MessagesListParams {
+    /**
+     * Filter by status. Not all stored statuses are filterable. `received` returns
+     * inbound messages only (messages your contacts sent you). Inbound messages report
+     * `status: delivered`, so `delivered` returns them together with delivered
+     * outbound messages; use `received` to list inbound messages alone.
+     */
+    status?: ListMessagesStatus;
+    to?: string;
+    /** Filter by delivery channel. */
+    channel?: ListMessagesChannel;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `messages.react`. */
+export interface MessagesReactParams extends ReactionRequest {
+    /**
+     * Optional sender profile ID. If omitted, the project's default sender will be
+     * used.
+     */
+    'Zavu-Sender'?: string;
+}
+/** Params for `messages.send`. */
+export interface MessagesSendParams extends MessageRequest {
+    /**
+     * Optional sender profile ID. If omitted, the project's default sender will be
+     * used.
+     */
+    'Zavu-Sender'?: string;
+}
+/** Params for `messages.showTyping`. */
+export interface MessagesShowTypingParams {
+    /**
+     * Optional sender profile ID. If omitted, the project's default sender will be
+     * used.
+     */
+    'Zavu-Sender'?: string;
+}
+/** Params for `number10dlc.brands.create`. */
+export interface Number10dlcBrandsCreateParams extends TenDlcBrandCreateRequest {
+}
+/** Params for `number10dlc.brands.update`. */
+export interface Number10dlcBrandsUpdateParams extends TenDlcBrandUpdateRequest {
+}
+/** Params for `number10dlc.brands.list`. */
+export interface Number10dlcBrandsListParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `number10dlc.campaigns.create`. */
+export interface Number10dlcCampaignsCreateParams extends TenDlcCampaignCreateRequest {
+}
+/** Params for `number10dlc.campaigns.update`. */
+export interface Number10dlcCampaignsUpdateParams extends TenDlcCampaignUpdateRequest {
+}
+/** Params for `number10dlc.campaigns.list`. */
+export interface Number10dlcCampaignsListParams {
+    /** Filter campaigns by brand ID. */
+    brandId?: string;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `number10dlc.campaigns.phoneNumbers.list`. */
+export interface Number10dlcCampaignsPhoneNumbersListParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    /** Opaque cursor from a previous response's `nextCursor`. */
+    cursor?: string;
+}
+/** Params for `number10dlc.campaigns.phoneNumbers.assign`. */
+export interface Number10dlcCampaignsPhoneNumbersAssignParams extends TenDlcPhoneNumberAssignRequest {
+}
+/** Params for `number10dlc.campaigns.phoneNumbers.unassign`. */
+export interface Number10dlcCampaignsPhoneNumbersUnassignParams {
+    /** 10DLC campaign ID. */
+    campaignId: string;
+}
+/** Params for `phoneNumbers.update`. */
+export interface PhoneNumbersUpdateParams extends PhoneNumberUpdateRequest {
+}
+/** Params for `phoneNumbers.list`. */
+export interface PhoneNumbersListParams {
+    /** Filter by phone number status. */
+    status?: PhoneNumberStatus;
+    /** @defaultValue `50` */
+    limit?: number;
+    /** Pagination cursor. */
+    cursor?: string;
+}
+/** Params for `phoneNumbers.purchase`. */
+export interface PhoneNumbersPurchaseParams extends PhoneNumberPurchaseRequest {
+}
+/** Params for `phoneNumbers.requirements`. */
+export interface PhoneNumbersRequirementsParams {
+    /** Two-letter ISO country code. Required unless `phoneNumber` is given. */
+    countryCode?: string;
+    /**
+     * Type of phone number (local, national, mobile, tollFree). Defaults to `local`.
+     * With `phoneNumber`, used only when the number's own requirements cannot be
+     * resolved and the country list is returned.
+     */
+    type?: PhoneNumberType;
+    /**
+     * E.164 number from `GET /v1/phone-numbers/available`, with `+` encoded as `%2B`.
+     * Returns the requirements the purchase of that number checks. Takes precedence
+     * over `countryCode`.
+     */
+    phoneNumber?: string;
+}
+/** Params for `phoneNumbers.searchAvailable`. */
+export interface PhoneNumbersSearchAvailableParams {
+    /** Two-letter ISO country code. */
+    countryCode: string;
+    /** Type of phone number to search for. */
+    type?: PhoneNumberType;
+    /** Search for numbers containing this string. */
+    contains?: string;
+    /**
+     * Comma-separated capabilities the number must have: `sms`, `voice`, `mms`.
+     * Numbers missing any of them are dropped.
+     */
+    capabilities?: string;
+    /**
+     * Maximum number of results to return.
+     *
+     * @defaultValue `10`
+     */
+    limit?: number;
+}
+/** Params for `regulatoryDocuments.create`. */
+export interface RegulatoryDocumentsCreateParams extends RegulatoryDocumentCreateRequest {
+}
+/** Params for `regulatoryDocuments.list`. */
+export interface RegulatoryDocumentsListParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `senders.create`. */
+export interface SendersCreateParams extends SenderCreateRequest {
+}
+/** Params for `senders.update`. */
+export interface SendersUpdateParams extends SenderUpdateRequest {
+}
+/** Params for `senders.list`. */
+export interface SendersListParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `senders.updateProfile`. */
+export interface SendersUpdateProfileParams extends WhatsAppBusinessProfileUpdateRequest {
+}
+/** Params for `senders.uploadProfilePicture`. */
+export interface SendersUploadProfilePictureParams extends WhatsAppBusinessProfilePictureRequest {
+}
+/** Params for `senders.agent.create`. */
+export interface SendersAgentCreateParams extends AgentCreateRequest {
+}
+/** Params for `senders.agent.update`. */
+export interface SendersAgentUpdateParams extends AgentUpdateRequest {
+}
+/** Params for `senders.agent.executions.retrieve`. */
+export interface SendersAgentExecutionsRetrieveParams {
+    senderId: string;
+}
+/** Params for `senders.agent.executions.list`. */
+export interface SendersAgentExecutionsListParams {
+    status?: AgentExecutionStatus;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `senders.agent.flows.create`. */
+export interface SendersAgentFlowsCreateParams extends FlowCreateRequest {
+}
+/** Params for `senders.agent.flows.retrieve`. */
+export interface SendersAgentFlowsRetrieveParams {
+    senderId: string;
+}
+/** Params for `senders.agent.flows.update`. */
+export interface SendersAgentFlowsUpdateParams extends FlowUpdateRequest {
+    senderId: string;
+}
+/** Params for `senders.agent.flows.list`. */
+export interface SendersAgentFlowsListParams {
+    enabled?: boolean;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `senders.agent.flows.delete`. */
+export interface SendersAgentFlowsDeleteParams {
+    senderId: string;
+}
+/** Params for `senders.agent.flows.duplicate`. */
+export interface SendersAgentFlowsDuplicateParams extends FlowDuplicateRequest {
+    senderId: string;
+}
+/** Params for `senders.agent.knowledgeBases.create`. */
+export interface SendersAgentKnowledgeBasesCreateParams extends KnowledgeBaseCreateRequest {
+}
+/** Params for `senders.agent.knowledgeBases.retrieve`. */
+export interface SendersAgentKnowledgeBasesRetrieveParams {
+    senderId: string;
+}
+/** Params for `senders.agent.knowledgeBases.update`. */
+export interface SendersAgentKnowledgeBasesUpdateParams extends KnowledgeBaseUpdateRequest {
+    senderId: string;
+}
+/** Params for `senders.agent.knowledgeBases.list`. */
+export interface SendersAgentKnowledgeBasesListParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `senders.agent.knowledgeBases.delete`. */
+export interface SendersAgentKnowledgeBasesDeleteParams {
+    senderId: string;
+}
+/** Params for `senders.agent.knowledgeBases.documents.create`. */
+export interface SendersAgentKnowledgeBasesDocumentsCreateParams extends DocumentCreateRequest {
+    senderId: string;
+}
+/** Params for `senders.agent.knowledgeBases.documents.list`. */
+export interface SendersAgentKnowledgeBasesDocumentsListParams {
+    senderId: string;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `senders.agent.knowledgeBases.documents.delete`. */
+export interface SendersAgentKnowledgeBasesDocumentsDeleteParams {
+    senderId: string;
+    kbId: string;
+}
+/** Params for `senders.agent.knowledgeBases.documents.retrieveDocument`. */
+export interface SendersAgentKnowledgeBasesDocumentsRetrieveDocumentParams {
+    senderId: string;
+    kbId: string;
+}
+/** Params for `senders.agent.knowledgeBases.documents.updateDocument`. */
+export interface SendersAgentKnowledgeBasesDocumentsUpdateDocumentParams extends DocumentUpdateRequest {
+    senderId: string;
+    kbId: string;
+}
+/** Params for `senders.agent.tools.create`. */
+export interface SendersAgentToolsCreateParams extends ToolCreateRequest {
+}
+/** Params for `senders.agent.tools.retrieve`. */
+export interface SendersAgentToolsRetrieveParams {
+    senderId: string;
+}
+/** Params for `senders.agent.tools.update`. */
+export interface SendersAgentToolsUpdateParams extends ToolUpdateRequest {
+    senderId: string;
+}
+/** Params for `senders.agent.tools.list`. */
+export interface SendersAgentToolsListParams {
+    enabled?: boolean;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `senders.agent.tools.delete`. */
+export interface SendersAgentToolsDeleteParams {
+    senderId: string;
+}
+/** Params for `senders.agent.tools.listTestRuns`. */
+export interface SendersAgentToolsListTestRunsParams {
+    senderId: string;
+    /** @defaultValue `20` */
+    limit?: number;
+}
+/** Params for `senders.agent.tools.test`. */
+export interface SendersAgentToolsTestParams extends ToolTestRequest {
+    senderId: string;
+}
+/** Params for `senders.agent.tools.webhook.rotateSecret`. */
+export interface SendersAgentToolsWebhookRotateSecretParams {
+    senderId: string;
+}
+/** Params for `senders.telegram.connect`. */
+export interface SendersTelegramConnectParams extends ConnectSenderTelegramBody {
+}
+/** Params for `senders.channels.activate`. */
+export interface SendersChannelsActivateParams {
+    senderId: string;
+}
+/** Params for `senders.channels.deactivate`. */
+export interface SendersChannelsDeactivateParams {
+    senderId: string;
+}
+/** Params for `subAccounts.create`. */
+export interface SubAccountsCreateParams extends SubAccountCreateRequest {
+}
+/** Params for `subAccounts.update`. */
+export interface SubAccountsUpdateParams extends SubAccountUpdateRequest {
+}
+/** Params for `subAccounts.list`. */
+export interface SubAccountsListParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `subAccounts.apiKeys.create`. */
+export interface SubAccountsApiKeysCreateParams extends SubAccountApiKeyCreateRequest {
+}
+/** Params for `subAccounts.apiKeys.revoke`. */
+export interface SubAccountsApiKeysRevokeParams {
+    /** Sub-account ID. */
+    id: string;
+}
+/** Params for `templates.create`. */
+export interface TemplatesCreateParams extends TemplateCreateRequest {
+}
+/** Params for `templates.list`. */
+export interface TemplatesListParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `templates.submit`. */
+export interface TemplatesSubmitParams extends SubmitTemplateBody {
+}
+/** Params for `templates.sync`. */
+export interface TemplatesSyncParams extends SyncTemplatesBody {
+}
+/** Params for `urls.escalate`. */
+export interface UrlsEscalateParams extends EscalateUrlBody {
+}
+/** Params for `urls.listVerified`. */
+export interface UrlsListVerifiedParams {
+    /** Filter by verification status. */
+    status?: VerifiedUrlStatus;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `urls.submitForVerification`. */
+export interface UrlsSubmitForVerificationParams extends VerifiedUrlSubmitRequest {
+}
+/** Params for `memory.add`. */
+export interface MemoryAddParams extends MemoryAddRequest {
+}
+/** Params for `memory.list`. */
+export interface MemoryListParams {
+    /**
+     * Which scope to address: `contact:<contactId>`, `conversation:<conversationId>`,
+     * or omitted for the project scope.
+     *
+     * Note the asymmetry with `POST /v1/memory` and `POST /v1/memory/search`, which
+     * take the scope in the request BODY as `scope` plus `contactId`/`conversationId`.
+     * Every other Memory endpoint takes it here.
+     */
+    scope?: MemoryScopeQuery;
+    /** @defaultValue `50` */
+    limit?: number;
+    /** Opaque cursor from a previous response's `nextCursor`. Do not construct it. */
+    cursor?: string;
+}
+/** Params for `memory.wipe`. */
+export interface MemoryWipeParams {
+    /**
+     * Which scope to address: `contact:<contactId>`, `conversation:<conversationId>`,
+     * or omitted for the project scope.
+     *
+     * Note the asymmetry with `POST /v1/memory` and `POST /v1/memory/search`, which
+     * take the scope in the request BODY as `scope` plus `contactId`/`conversationId`.
+     * Every other Memory endpoint takes it here.
+     */
+    scope?: MemoryScopeQuery;
+}
+/** Params for `memory.search`. */
+export interface MemorySearchParams extends MemorySearchRequest {
+}
+/** Params for `memory.retrieve`. */
+export interface MemoryRetrieveParams {
+    /**
+     * Which scope to address: `contact:<contactId>`, `conversation:<conversationId>`,
+     * or omitted for the project scope.
+     *
+     * Note the asymmetry with `POST /v1/memory` and `POST /v1/memory/search`, which
+     * take the scope in the request BODY as `scope` plus `contactId`/`conversationId`.
+     * Every other Memory endpoint takes it here.
+     */
+    scope?: MemoryScopeQuery;
+}
+/** Params for `memory.delete`. */
+export interface MemoryDeleteParams {
+    /**
+     * Which scope to address: `contact:<contactId>`, `conversation:<conversationId>`,
+     * or omitted for the project scope.
+     *
+     * Note the asymmetry with `POST /v1/memory` and `POST /v1/memory/search`, which
+     * take the scope in the request BODY as `scope` plus `contactId`/`conversationId`.
+     * Every other Memory endpoint takes it here.
+     */
+    scope?: MemoryScopeQuery;
+}
+/** Params for `memory.collections.create`. */
+export interface MemoryCollectionsCreateParams extends MemoryCollectionCreateRequest {
+}
+/** Params for `memory.collections.list`. */
+export interface MemoryCollectionsListParams {
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `memory.collections.update`. */
+export interface MemoryCollectionsUpdateParams extends MemoryCollectionUpdateRequest {
+}
+/** Params for `memory.collections.items.list`. */
+export interface MemoryCollectionsItemsListParams {
+    /**
+     * Which scope to address: `contact:<contactId>`, `conversation:<conversationId>`,
+     * or omitted for the project scope.
+     *
+     * Note the asymmetry with `POST /v1/memory` and `POST /v1/memory/search`, which
+     * take the scope in the request BODY as `scope` plus `contactId`/`conversationId`.
+     * Every other Memory endpoint takes it here.
+     */
+    scope?: MemoryScopeQuery;
+    /** Only keys starting with this string. */
+    prefix?: string;
+    /** @defaultValue `50` */
+    limit?: number;
+    cursor?: string;
+}
+/** Params for `memory.collections.items.batch`. */
+export interface MemoryCollectionsItemsBatchParams extends MemoryItemBatchRequest {
+    /**
+     * Which scope to address: `contact:<contactId>`, `conversation:<conversationId>`,
+     * or omitted for the project scope.
+     *
+     * Note the asymmetry with `POST /v1/memory` and `POST /v1/memory/search`, which
+     * take the scope in the request BODY as `scope` plus `contactId`/`conversationId`.
+     * Every other Memory endpoint takes it here.
+     */
+    scope?: MemoryScopeQuery;
+}
+/** Params for `memory.collections.items.put`. */
+export interface MemoryCollectionsItemsPutParams extends MemoryItemPutRequest {
+    /** Collection name. */
+    collection: string;
+    /**
+     * Make the write conditional on the item's current revision, as returned by a
+     * previous read or write (plain `3` or ETag-quoted `"3"`). The write is refused
+     * with `409 revision_conflict` if the item moved on in between. Without it, the
+     * write always wins and silently overwrites a concurrent one.
+     */
+    'If-Match'?: string;
+    /**
+     * Which scope to address: `contact:<contactId>`, `conversation:<conversationId>`,
+     * or omitted for the project scope.
+     *
+     * Note the asymmetry with `POST /v1/memory` and `POST /v1/memory/search`, which
+     * take the scope in the request BODY as `scope` plus `contactId`/`conversationId`.
+     * Every other Memory endpoint takes it here.
+     */
+    scope?: MemoryScopeQuery;
+}
+/** Params for `memory.collections.items.retrieve`. */
+export interface MemoryCollectionsItemsRetrieveParams {
+    /** Collection name. */
+    collection: string;
+    /**
+     * Which scope to address: `contact:<contactId>`, `conversation:<conversationId>`,
+     * or omitted for the project scope.
+     *
+     * Note the asymmetry with `POST /v1/memory` and `POST /v1/memory/search`, which
+     * take the scope in the request BODY as `scope` plus `contactId`/`conversationId`.
+     * Every other Memory endpoint takes it here.
+     */
+    scope?: MemoryScopeQuery;
+}
+/** Params for `memory.collections.items.delete`. */
+export interface MemoryCollectionsItemsDeleteParams {
+    /** Collection name. */
+    collection: string;
+    /**
+     * Make the write conditional on the item's current revision, as returned by a
+     * previous read or write (plain `3` or ETag-quoted `"3"`). The write is refused
+     * with `409 revision_conflict` if the item moved on in between. Without it, the
+     * write always wins and silently overwrites a concurrent one.
+     */
+    'If-Match'?: string;
+    /**
+     * Which scope to address: `contact:<contactId>`, `conversation:<conversationId>`,
+     * or omitted for the project scope.
+     *
+     * Note the asymmetry with `POST /v1/memory` and `POST /v1/memory/search`, which
+     * take the scope in the request BODY as `scope` plus `contactId`/`conversationId`.
+     * Every other Memory endpoint takes it here.
+     */
+    scope?: MemoryScopeQuery;
+}
+/** Params for `memory.collections.items.query`. */
+export interface MemoryCollectionsItemsQueryParams extends MemoryItemQueryRequest {
+    /**
+     * Which scope to address: `contact:<contactId>`, `conversation:<conversationId>`,
+     * or omitted for the project scope.
+     *
+     * Note the asymmetry with `POST /v1/memory` and `POST /v1/memory/search`, which
+     * take the scope in the request BODY as `scope` plus `contactId`/`conversationId`.
+     * Every other Memory endpoint takes it here.
+     */
+    scope?: MemoryScopeQuery;
+}
+//# sourceMappingURL=types.d.mts.map