@wassist/sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1626 @@
+/**
+ * Common building-block types reused across every resource.
+ */
+/** A UUID string. */
+type UUID = string;
+/** An ISO-8601 datetime string (`YYYY-MM-DDTHH:mm:ss.sssZ`). */
+type ISODateTime = string;
+/** A WhatsApp E.164-format phone number (e.g. `+447424845871`). */
+type PhoneNumberString = string;
+/**
+ * Standard offset/limit pagination parameters accepted by every list endpoint.
+ *
+ * @see https://docs.wassist.app/api-reference/introduction
+ */
+interface PageParams {
+    /** Number of results to return per page. */
+    limit?: number;
+    /** Initial index from which to return results. */
+    offset?: number;
+}
+/**
+ * Raw paginated response envelope returned by the Wassist API.
+ *
+ * Most callers will never see this directly — list methods return a
+ * higher-level {@link AutoPaginatedList} that wraps it.
+ */
+interface PaginatedResponse<T> {
+    count: number;
+    next: string | null;
+    previous: string | null;
+    results: T[];
+}
+/**
+ * Per-request options accepted by every method on the SDK.
+ */
+interface RequestOptions {
+    /**
+     * If supplied, sent as the `Idempotency-Key` header so retried `POST`s
+     * do not double-charge or double-fire side effects.
+     *
+     * Generate a random UUID per logical operation and reuse it for retries.
+     */
+    idempotencyKey?: string;
+    /**
+     * Per-request timeout in milliseconds. Overrides the client default.
+     */
+    timeout?: number;
+    /**
+     * Per-request retry override. Overrides the client default.
+     */
+    maxRetries?: number;
+    /**
+     * Per-request abort signal. Aborting throws a {@link WassistConnectionError}.
+     */
+    signal?: AbortSignal;
+    /**
+     * Extra headers merged into the request.
+     */
+    headers?: Record<string, string>;
+}
+
+/**
+ * Low-level HTTP transport used by every resource module.
+ *
+ * Wraps `fetch` with:
+ *   - `X-API-Key` authentication
+ *   - `/api/v1/` path prefix handling
+ *   - Per-request timeout (cancels via `AbortController`)
+ *   - Exponential-backoff retries on `429` and `5xx` (honors `Retry-After`)
+ *   - `Idempotency-Key` opt-in for safe `POST` retries
+ *   - Typed error mapping via {@link errorFromResponse}
+ *   - `requestId` extraction from the `X-Request-Id` response header
+ */
+
+/**
+ * The minimal `fetch` signature this SDK depends on. Any spec-compliant
+ * implementation will satisfy it — Node 18+, edge runtimes, browsers, Bun.
+ */
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+/**
+ * Configuration for {@link Wassist}.
+ */
+interface WassistClientConfig {
+    /**
+     * Your Wassist API key. Find it at
+     * https://wassist.app/settings → API Keys.
+     */
+    apiKey: string;
+    /**
+     * Base URL of the Wassist API.
+     *
+     * @default 'https://backend.wassist.app'
+     */
+    baseUrl?: string;
+    /**
+     * Default request timeout in milliseconds. Individual calls can override
+     * via the per-call `timeout` option.
+     *
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Maximum number of retry attempts on `429` / `5xx` / network errors.
+     * The total number of requests is `maxRetries + 1`.
+     *
+     * @default 2
+     */
+    maxRetries?: number;
+    /**
+     * Custom `fetch` implementation. Useful for tests, mocking, or runtimes
+     * that don't expose `globalThis.fetch`.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: FetchLike;
+}
+interface RequestArgs {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    query?: object;
+    body?: unknown;
+    options?: RequestOptions;
+}
+/**
+ * @internal
+ */
+declare class HttpClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    private readonly fetchImpl;
+    constructor(config: WassistClientConfig);
+    get<T>(path: string, args?: Omit<RequestArgs, 'method' | 'path' | 'body'>): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    delete<T>(path: string, options?: RequestOptions): Promise<T>;
+    private request;
+    private buildUrl;
+    private buildHeaders;
+    private doFetch;
+}
+
+/**
+ * The shape of a single fetched page, returned by {@link AutoPaginatedList.firstPage}.
+ */
+interface Page<T> {
+    /** The items on this page. */
+    data: T[];
+    /** Total number of items across all pages. */
+    totalCount: number;
+    /** Whether there is at least one more page after this one. */
+    hasMore: boolean;
+    /** Offset to pass to the next call to continue from this page. */
+    nextOffset: number;
+}
+/**
+ * Lazy auto-paginating wrapper around any Wassist list endpoint.
+ *
+ * Iteration is lazy — pages are fetched on demand as you consume them, so
+ * `for await` over a million-item list never has the whole result set in
+ * memory.
+ *
+ * @example Iterate every item
+ * ```ts
+ * for await (const conv of wassist.conversations.list({ limit: 100 })) {
+ *   console.log(conv.id);
+ * }
+ * ```
+ *
+ * @example Just the first page
+ * ```ts
+ * const { data, hasMore } = await wassist.conversations.list().firstPage();
+ * ```
+ *
+ * @example Collect everything into an array (small lists only)
+ * ```ts
+ * const all = await wassist.agents.list().all();
+ * ```
+ */
+declare class AutoPaginatedList<T> implements AsyncIterable<T> {
+    private readonly fetchPage;
+    private readonly params;
+    private readonly options;
+    /** @internal */
+    constructor(fetchPage: (params: PageParams) => Promise<PaginatedResponse<T>>, params?: PageParams, options?: RequestOptions);
+    /**
+     * Async iterator over every item across every page, fetched lazily.
+     */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    /**
+     * Fetch the first page only and return it as a {@link Page}.
+     */
+    firstPage(): Promise<Page<T>>;
+    /**
+     * Walk every page and collect every item into a single array.
+     *
+     * Convenient for small lists; for large ones prefer `for await`.
+     */
+    all(): Promise<T[]>;
+}
+
+/**
+ * A reference to a file uploaded into Wassist (used for agent documents
+ * and profile pictures).
+ */
+interface FileInfo {
+    name: string;
+    path: string;
+    size: number;
+    url: string;
+}
+/** A reference to an image stored on Wassist. */
+interface ImageInfo extends FileInfo {
+    width: number;
+    height: number;
+}
+/** Minimal user descriptor returned on agent owner/sharings fields. */
+interface PublicUser {
+    phoneNumber: string;
+    whatsappName: string | null;
+}
+interface AgentTool {
+    id: UUID;
+    name: string;
+    description: string;
+    apiSchema: Record<string, unknown>;
+    active: boolean;
+    creditCost: number;
+}
+interface AgentDocument {
+    id: UUID;
+    name: string;
+    file: FileInfo;
+    status: 'pending' | 'processing' | 'ready' | 'error';
+}
+interface AgentMemoryKey {
+    id: UUID;
+    key: string;
+    type: 'string' | 'number' | 'boolean' | 'json';
+    initialValue: string;
+    whenToUpdate: string;
+}
+interface AgentWakeUpConfig {
+    id: UUID;
+    description: string;
+    enabled: boolean;
+    forceMessage: boolean;
+}
+interface AgentOutboundTrigger {
+    id: UUID;
+    url: string;
+    secret: string;
+    enabled: boolean;
+    templateId: string;
+    templateName: string;
+}
+interface AgentWebsiteTool {
+    id: UUID;
+    url: string;
+    prompt: string;
+    active: boolean;
+}
+interface AgentImageGenerateTool {
+    id: UUID;
+    name: string;
+    description: string;
+    prompt: string;
+    active: boolean;
+    creditCost: number;
+}
+interface AgentHandoffTool {
+    id: UUID;
+    parentAgentId: UUID;
+    childAgentId: UUID;
+    childAgentName: string;
+    description: string;
+    active: boolean;
+}
+interface AgentMcpConfig {
+    id: UUID;
+    connectorId: UUID;
+    connectorName: string;
+    toolWhitelist: string[];
+}
+interface AgentPaywallConfig {
+    id: UUID;
+    messageLimit: number | null;
+    paywallAction: 'none' | 'purchase_link' | 'subscribe' | 'terminal';
+    paywallUrl: string | null;
+    ctaButtonText: string;
+    terminalStateMessage: string;
+    subscriptionPricePerMonth: number | null;
+}
+interface AgentCreditSettings {
+    id: UUID;
+    initialCredits: number;
+    creditGrantPassword: string | null;
+    creditGrantAmount: number;
+}
+interface AgentWhatsAppPhoneNumber {
+    /** Meta's phone number ID — pass to the WhatsApp Business API. */
+    whatsappPhoneNumberId: string;
+    /** Meta's WABA ID, or `null` for sandbox numbers. */
+    whatsappBusinessAccountId: string | null;
+    /** Wassist's internal WABA UUID. */
+    wabaId: UUID | null;
+    /** Display number (E.164 without leading `+`). */
+    phoneNumber: string;
+}
+/**
+ * A fully-hydrated Wassist agent, as returned by `GET /agents/{id}/`.
+ */
+interface Agent {
+    id: UUID;
+    name: string;
+    description: string;
+    systemPrompt: string;
+    firstMessage: string;
+    profilePicture: ImageInfo | null;
+    icebreakers: string[];
+    llmModel: string | null;
+    tools: AgentTool[];
+    documents: AgentDocument[];
+    memoryKeys: AgentMemoryKey[];
+    wakeUpConfigs: AgentWakeUpConfig[];
+    outboundTriggers: AgentOutboundTrigger[];
+    websiteTools: AgentWebsiteTool[];
+    imageGenerateTools: AgentImageGenerateTool[];
+    handoffTools: AgentHandoffTool[];
+    mcpConfigs: AgentMcpConfig[];
+    paywallConfig: AgentPaywallConfig | null;
+    creditSettings: AgentCreditSettings | null;
+    owner: PublicUser | null;
+    sharings: PublicUser[];
+    phoneNumbers: AgentWhatsAppPhoneNumber[];
+    totalMessages: number;
+    totalSessions: number;
+    /** Shareable URL that connects this agent to a new contact via WhatsApp. */
+    connectUrl: string;
+    ownerActive: boolean;
+    createdAt: ISODateTime;
+}
+/** Input for `POST /agents/`. */
+interface CreateAgentInput {
+    /** Display name for the agent (max 255 characters). */
+    name: string;
+}
+/** Input for `POST /agents/byoa/` (Bring Your Own Agent). */
+interface CreateBYOAAgentInput {
+    /** The webhook URL Wassist will forward inbound messages to. */
+    webhookUrl: string;
+}
+/**
+ * Input for `PATCH /agents/{id}/`.
+ *
+ * Every field is optional; only the fields you include are updated. Nested
+ * sub-resource arrays are fully replaced when supplied (Wassist diffs them
+ * server-side by `id`).
+ */
+interface UpdateAgentInput {
+    name?: string;
+    description?: string;
+    systemPrompt?: string;
+    firstMessage?: string;
+    icebreakers?: string[];
+    llmModel?: string | null;
+    tools?: AgentToolInput[];
+    memoryKeys?: AgentMemoryKeyInput[];
+    wakeUpConfigs?: AgentWakeUpConfigInput[];
+    outboundTriggers?: AgentOutboundTriggerInput[];
+    websiteTools?: AgentWebsiteToolInput[];
+    imageGenerateTools?: AgentImageGenerateToolInput[];
+    handoffTools?: AgentHandoffToolInput[];
+    mcpConfigs?: AgentMcpConfigInput[];
+    paywallConfig?: AgentPaywallConfigInput | null;
+    creditSettings?: AgentCreditSettingsInput | null;
+}
+interface AgentToolInput {
+    id?: UUID;
+    name: string;
+    description: string;
+    apiSchema: Record<string, unknown>;
+    active?: boolean;
+    creditCost?: number;
+}
+interface AgentMemoryKeyInput {
+    id?: UUID;
+    key: string;
+    type: 'string' | 'number' | 'boolean' | 'json';
+    initialValue: string;
+    whenToUpdate: string;
+}
+interface AgentWakeUpConfigInput {
+    id?: UUID;
+    description: string;
+    enabled?: boolean;
+    forceMessage?: boolean;
+}
+interface AgentOutboundTriggerInput {
+    id?: UUID;
+    enabled?: boolean;
+    templateId: string;
+    templateName: string;
+}
+interface AgentWebsiteToolInput {
+    id?: UUID;
+    url: string;
+    prompt: string;
+    active?: boolean;
+}
+interface AgentImageGenerateToolInput {
+    id?: UUID;
+    name: string;
+    description: string;
+    prompt: string;
+    active?: boolean;
+    creditCost?: number;
+}
+interface AgentHandoffToolInput {
+    id?: UUID;
+    childAgentId: UUID;
+    description: string;
+    active?: boolean;
+}
+interface AgentMcpConfigInput {
+    id?: UUID;
+    connectorId: UUID;
+    toolWhitelist?: string[];
+}
+interface AgentPaywallConfigInput {
+    messageLimit?: number | null;
+    paywallAction?: 'none' | 'purchase_link' | 'subscribe' | 'terminal';
+    paywallUrl?: string | null;
+    ctaButtonText?: string;
+    terminalStateMessage?: string;
+    subscriptionPricePerMonth?: number | null;
+}
+interface AgentCreditSettingsInput {
+    initialCredits?: number;
+    creditGrantPassword?: string | null;
+    creditGrantAmount?: number;
+}
+
+/**
+ * Methods for managing agents — the AI personas you connect to WhatsApp.
+ *
+ * Documented at https://docs.wassist.app/api-reference/agents/list.
+ */
+declare class AgentsResource {
+    private readonly http;
+    /** @internal */
+    constructor(http: HttpClient);
+    /**
+     * List every agent on your account.
+     *
+     * Returns a lazily-fetched paginated list. Use `for await` to walk all
+     * pages, or `.firstPage()` for just the first.
+     *
+     * `GET /agents/`
+     *
+     * @example
+     * ```ts
+     * for await (const agent of wassist.agents.list()) {
+     *   console.log(agent.id, agent.name);
+     * }
+     * ```
+     */
+    list(params?: PageParams, options?: RequestOptions): AutoPaginatedList<Agent>;
+    /**
+     * Retrieve a single agent by ID.
+     *
+     * `GET /agents/{id}/`
+     */
+    get(id: UUID, options?: RequestOptions): Promise<Agent>;
+    /**
+     * Create a new agent with the given display name. Configure it further
+     * with {@link AgentsResource.update}.
+     *
+     * `POST /agents/`
+     */
+    create(input: CreateAgentInput, options?: RequestOptions): Promise<Agent>;
+    /**
+     * Create a Bring-Your-Own-Agent (BYOA) — Wassist forwards inbound
+     * messages to your webhook and posts back replies you author yourself.
+     *
+     * `POST /agents/byoa/`
+     */
+    createBYOA(input: CreateBYOAAgentInput, options?: RequestOptions): Promise<Agent>;
+    /**
+     * Partially update an agent. Only the fields you pass are modified.
+     *
+     * Nested sub-resource arrays (tools, memory keys, etc.) are diffed
+     * server-side by `id`: include an `id` to update an existing entry,
+     * omit it to create one.
+     *
+     * `PATCH /agents/{id}/`
+     */
+    update(id: UUID, input: UpdateAgentInput, options?: RequestOptions): Promise<Agent>;
+    /**
+     * Soft-delete an agent. The agent stops responding immediately;
+     * conversation history is retained.
+     *
+     * `DELETE /agents/{id}/`
+     */
+    delete(id: UUID, options?: RequestOptions): Promise<void>;
+}
+
+type MessageRole = 'user' | 'assistant' | 'system';
+type MessageType = 'text' | 'image' | 'cta_button' | 'list_selection' | 'template' | 'unified' | 'quick_reply';
+type MessageStatus = 'sent' | 'delivered' | 'read' | 'failed';
+interface TextMessage {
+    id: UUID;
+    body: string;
+}
+interface ImageMessage {
+    id: UUID;
+    image: ImageInfo | null;
+    caption: string | null;
+}
+interface CTAButtonMessage {
+    id: UUID;
+    text: string;
+    url: string | null;
+    buttonText: string;
+    image: ImageInfo | null;
+    clicks: {
+        id: UUID;
+        createdAt: ISODateTime;
+    }[];
+}
+interface ListSelectionMessage {
+    id: UUID;
+    text: string;
+    buttonText: string;
+    sections: Record<string, unknown>[];
+}
+interface TemplateMessage {
+    id: UUID;
+    templateName: string;
+    variables: Record<string, unknown>;
+    components: Record<string, unknown>[];
+}
+type UnifiedMessageButtonType = 'url' | 'quick_reply';
+interface UnifiedMessageButton {
+    type: UnifiedMessageButtonType;
+    text: string;
+    url?: string;
+    quickReplyId?: string;
+}
+interface UnifiedMessageMedia {
+    url: string;
+    mimeType: string;
+}
+interface UnifiedMessage {
+    body: string | null;
+    footer: string | null;
+    buttons: UnifiedMessageButton[];
+    media: UnifiedMessageMedia[];
+}
+interface QuickReplyMessage {
+    text: string;
+    quickReplyId: string;
+}
+/**
+ * A single message in a conversation. Exactly one of `text`, `image`,
+ * `ctaButton`, `listSelection`, `template`, `unified`, or `quickReply` will
+ * be populated based on `type`.
+ */
+interface Message {
+    id: UUID;
+    role: MessageRole;
+    type: MessageType;
+    status: MessageStatus | null;
+    createdAt: ISODateTime;
+    replyTo: UUID | null;
+    text: TextMessage | null;
+    image: ImageMessage | null;
+    cta: CTAButtonMessage | null;
+    listSelection: ListSelectionMessage | null;
+    template: TemplateMessage | null;
+    unified: UnifiedMessage | null;
+    quickReply: QuickReplyMessage | null;
+}
+/** Template name + variables, used both for `messages.send` and `conversations.create`. */
+interface SendMessageTemplateInput {
+    /** Approved WhatsApp template name. */
+    name: string;
+    /**
+     * Variable values, keyed by component. Each list is positional and
+     * matches the placeholder order in the approved template.
+     */
+    variables?: {
+        body?: string[];
+        header?: string[];
+        buttons?: string[];
+    };
+}
+interface SendMessageTextInput {
+    /** Plain-text body (max 1024 characters). */
+    body: string;
+}
+interface SendMessageCtaImageInput {
+    url: string;
+}
+interface SendMessageCtaInput {
+    /** Message body text (max 1024 characters). */
+    body: string;
+    /** Button label (max 20 characters). */
+    buttonText: string;
+    /** URL to open when the button is tapped. */
+    url: string;
+    image?: SendMessageCtaImageInput;
+}
+interface SendUnifiedMessageButtonInput {
+    type: UnifiedMessageButtonType;
+    text: string;
+    url?: string;
+    quickReplyId?: string;
+}
+interface SendUnifiedMessageMediaInput {
+    url: string;
+}
+interface SendUnifiedMessageInput {
+    text?: string;
+    /** Footer text (max 60 characters). */
+    footer?: string;
+    media?: SendUnifiedMessageMediaInput;
+    /** Up to 3 buttons of a single type. */
+    buttons?: SendUnifiedMessageButtonInput[];
+}
+/**
+ * Discriminated union input for `POST /conversations/{id}/messages/`.
+ *
+ * Set `type` and populate the corresponding sibling field.
+ */
+type SendMessageInput = {
+    type: 'text';
+    text: SendMessageTextInput;
+} | {
+    type: 'template';
+    template: SendMessageTemplateInput;
+} | {
+    type: 'cta';
+    cta: SendMessageCtaInput;
+} | {
+    type: 'unified';
+    unified: SendUnifiedMessageInput;
+};
+/** Input for `POST /conversations/{id}/prompt/`. */
+interface PromptAgentInput {
+    /** Free-form instruction sent to the active agent. */
+    prompt: string;
+}
+
+/**
+ * Active routing modes for a phone number or conversation.
+ *
+ * "No routing" is represented as `null`, not the string `"none"`.
+ */
+type PhoneNumberRoutingMode = 'agent' | 'webhook' | 'sandbox';
+/**
+ * A WhatsApp phone number connected to your Wassist account.
+ *
+ * The `number` field is the resource identifier in the URL — pass it as the
+ * `number` argument to every `phoneNumbers.*` method.
+ */
+interface PhoneNumber {
+    /** Wassist's internal UUID for this number. */
+    id: UUID;
+    /** The number itself, in E.164 without the leading `+`. Used in URLs. */
+    number: string;
+    /** Meta's phone number ID — pass to the WhatsApp Business API. */
+    whatsappPhoneNumberId: string;
+    whatsappBusinessAccount: {
+        id: UUID;
+        name: string | null;
+        waId: string;
+    } | null;
+    activeAgent: {
+        id: UUID;
+        name: string;
+        icebreakers: string[];
+    } | null;
+    /**
+     * How inbound messages on this number are handled by default.
+     *
+     * - `'agent'` / `'webhook'` — run the corresponding pipeline.
+     * - `'sandbox'` — system-managed; not user-settable.
+     * - `null` — no routing. Messages are stored but nothing else happens.
+     */
+    defaultRouting: PhoneNumberRoutingMode | null;
+    /** Webhook used when `defaultRouting === 'webhook'`. */
+    defaultWebhook: {
+        id: UUID;
+        name: string;
+        url: string;
+    } | null;
+    /** `true` for shared sandbox numbers (no WhatsApp Business Account). */
+    isSandbox: boolean;
+}
+/**
+ * The WhatsApp Business Profile for a number, returned by
+ * `GET /phone-numbers/{number}/business-profile/`.
+ */
+interface PhoneNumberBusinessProfile {
+    about?: string;
+    description?: string;
+    address?: string;
+    email?: string;
+    profilePictureUrl?: string;
+    websites?: string[];
+    vertical?: string;
+    /** `true` when the profile is still using Wassist's default branding. */
+    isStarterBranded: boolean;
+}
+/**
+ * Input for `POST /phone-numbers/{number}/subscribe/`.
+ *
+ * Routes the number to the given webhook (sets `defaultRouting='webhook'`,
+ * `defaultWebhook=W`). Any agent previously connected to the number is
+ * dropped.
+ */
+interface SubscribePhoneNumberInput {
+    /** Webhook to route inbound messages to. */
+    webhookId: UUID;
+    /**
+     * When `true` (default), every existing conversation on this number is
+     * updated so the new routing takes effect for in-flight chats:
+     * `activeAgent` is cleared and any open session is dropped.
+     *
+     * Phone-number routing changes do **not** fire `subscription.activated`
+     * / `.revoked` webhook events — those are reserved for per-conversation
+     * subscribe/unsubscribe.
+     */
+    applyToExisting?: boolean;
+}
+/**
+ * Input for `POST /phone-numbers/{number}/connect-agent/`.
+ *
+ * Sets `defaultRouting='agent'` and assigns the given agent. Any webhook
+ * subscribed to the number is dropped. The agent must already be owned by
+ * or shared with the caller.
+ */
+interface ConnectAgentInput {
+    /** Agent to connect to this number. */
+    agentId: UUID;
+    /** See {@link SubscribePhoneNumberInput.applyToExisting}. */
+    applyToExisting?: boolean;
+}
+/**
+ * Input for `POST /phone-numbers/{number}/unsubscribe/`.
+ *
+ * Clears default routing entirely (sets `defaultRouting=null`) and drops
+ * both the agent and the default webhook.
+ */
+interface UnsubscribePhoneNumberInput {
+    applyToExisting?: boolean;
+}
+
+interface ConversationContact {
+    phoneNumber: string;
+    name: string | null;
+}
+interface ConversationLastMessage {
+    body: string;
+    createdAt: ISODateTime;
+    role: MessageRole;
+}
+/**
+ * A Wassist conversation between one of your phone numbers and a contact.
+ */
+interface Conversation {
+    id: UUID;
+    contact: ConversationContact;
+    activeAgent: {
+        id: UUID;
+        name: string;
+    } | null;
+    whatsappNumber: {
+        id: UUID;
+        number: string;
+        /** `true` for shared sandbox numbers (no WhatsApp Business Account). */
+        isSandbox: boolean;
+    } | null;
+    /** Seconds left in the WhatsApp 24-hour reply window. */
+    chatWindowRemainingTime: number;
+    lastMessage: ConversationLastMessage | null;
+    isHumanTakeover: boolean;
+    active: boolean;
+    /**
+     * Resolved routing mode. Inherits from the phone number's default when
+     * no per-conversation override is set. `sandbox` for any conversation on
+     * a sandbox number. `null` = message is stored but nothing else happens.
+     */
+    routing: PhoneNumberRoutingMode | null;
+    /** Webhook currently subscribed to this conversation, or `null`. */
+    webhookId: UUID | null;
+    /**
+     * `true` when this conversation has a per-conversation routing override
+     * rather than inheriting from the phone number's default routing.
+     */
+    routingOverride: boolean;
+}
+/**
+ * Filters and ordering for `GET /conversations/`.
+ */
+interface ListConversationsParams {
+    /** Filter by agent ID. */
+    agent?: UUID;
+    /** Filter by your WhatsApp number (substring match on `number`). */
+    whatsappNumber?: string;
+    /** Filter by contact phone number. */
+    contact?: string;
+    /** `active` = had inbound message in last 24h, `closed` = otherwise. */
+    status?: 'active' | 'closed';
+    /** Only return conversations with unread inbound messages. */
+    hasUnread?: boolean;
+    /** ISO datetime — only return conversations with messages after this time. */
+    lastMessageAfter?: ISODateTime;
+    /** ISO datetime — only return conversations with messages before this time. */
+    lastMessageBefore?: ISODateTime;
+    ordering?: 'last_message_time' | '-last_message_time' | 'created_at' | '-created_at' | 'updated_at' | '-updated_at';
+    /** Pagination. */
+    limit?: number;
+    offset?: number;
+}
+/** Optional first-template message included with `POST /conversations/`. */
+interface CreateConversationMessageInput {
+    type: 'template';
+    template?: SendMessageTemplateInput;
+}
+/** Input for `POST /conversations/`. */
+interface CreateConversationInput {
+    /** The recipient's WhatsApp number in E.164 format (e.g. `+447700900100`). */
+    toNumber: string;
+    /**
+     * Your sending number. Optional — when omitted, the agent's primary number
+     * is used.
+     */
+    fromNumber?: string;
+    /** Agent to start the conversation with. */
+    agentId?: UUID;
+    /**
+     * Optional first message to send. Required if the WhatsApp 24-hour
+     * reply window is closed.
+     */
+    message?: CreateConversationMessageInput;
+}
+/** Input for `POST /conversations/{id}/subscribe/`. */
+interface SubscribeConversationInput {
+    /** Webhook to route this conversation to. */
+    webhookId: UUID;
+}
+
+/**
+ * Messages within a conversation. Reached via `wassist.conversations.messages`.
+ *
+ * Documented at https://docs.wassist.app/api-reference/conversations/messages/list
+ * and https://docs.wassist.app/api-reference/conversations/messages/send.
+ */
+declare class MessagesResource {
+    private readonly http;
+    /** @internal */
+    constructor(http: HttpClient);
+    /**
+     * List messages in a conversation, newest first.
+     *
+     * `GET /conversations/{id}/messages/`
+     */
+    list(conversationId: UUID, params?: PageParams, options?: RequestOptions): AutoPaginatedList<Message>;
+    /**
+     * Send a message in a conversation.
+     *
+     * The input is a discriminated union — set `type` and populate the
+     * matching field (`text`, `template`, `cta`, or `unified`).
+     *
+     * `POST /conversations/{id}/messages/`
+     *
+     * @example Plain text
+     * ```ts
+     * await wassist.conversations.messages.send(conv.id, {
+     *   type: 'text',
+     *   text: { body: 'Hello!' },
+     * });
+     * ```
+     *
+     * @example Approved template
+     * ```ts
+     * await wassist.conversations.messages.send(conv.id, {
+     *   type: 'template',
+     *   template: { name: 'order_update', variables: { body: ['Alex', '#1234'] } },
+     * });
+     * ```
+     */
+    send(conversationId: UUID, input: SendMessageInput, options?: RequestOptions): Promise<Message>;
+}
+
+/**
+ * Methods for managing conversations — ongoing WhatsApp chats between
+ * your numbers and a contact.
+ *
+ * Nested namespace: `wassist.conversations.messages` (see {@link MessagesResource}).
+ */
+declare class ConversationsResource {
+    private readonly http;
+    /** Send and list messages within a conversation. */
+    readonly messages: MessagesResource;
+    /** @internal */
+    constructor(http: HttpClient);
+    /**
+     * List conversations on your account with rich filtering.
+     *
+     * `GET /conversations/`
+     *
+     * @example
+     * ```ts
+     * const recent = await wassist.conversations
+     *   .list({ ordering: '-last_message_time', limit: 20 })
+     *   .firstPage();
+     * ```
+     */
+    list(params?: ListConversationsParams, options?: RequestOptions): AutoPaginatedList<Conversation>;
+    /**
+     * Retrieve a single conversation by ID.
+     *
+     * `GET /conversations/{id}/`
+     */
+    get(id: UUID, options?: RequestOptions): Promise<Conversation>;
+    /**
+     * Create a new conversation with a contact.
+     *
+     * If the WhatsApp 24-hour reply window is closed for this contact, you
+     * must include a `template` message to open it.
+     *
+     * `POST /conversations/`
+     */
+    create(input: CreateConversationInput, options?: RequestOptions): Promise<Conversation>;
+    /**
+     * Prompt the agent in this conversation with a custom instruction.
+     * Equivalent to "wake the agent up and have it say this" — useful for
+     * outbound triggers and follow-ups.
+     *
+     * `POST /conversations/{id}/prompt/`
+     */
+    prompt(id: UUID, input: PromptAgentInput, options?: RequestOptions): Promise<void>;
+    /**
+     * Send a WhatsApp read receipt for the most recent inbound message.
+     *
+     * `POST /conversations/{id}/read/`
+     */
+    read(id: UUID, options?: RequestOptions): Promise<Conversation>;
+    /**
+     * Display the WhatsApp typing indicator on the contact's device.
+     *
+     * Note: WhatsApp also marks the most recent inbound message as read as
+     * a side effect — this is a platform limitation.
+     *
+     * `POST /conversations/{id}/typing/`
+     */
+    typing(id: UUID, options?: RequestOptions): Promise<Conversation>;
+    /**
+     * Route this conversation to a webhook. The agent pipeline is skipped
+     * while the override is active.
+     *
+     * Fires a `subscription.activated` event on the target webhook.
+     *
+     * `POST /conversations/{id}/subscribe/`
+     */
+    subscribe(id: UUID, input: SubscribeConversationInput, options?: RequestOptions): Promise<Conversation>;
+    /**
+     * Clear the per-conversation routing override and fall back to the
+     * phone number's default routing.
+     *
+     * Fires a `subscription.revoked` event on the previously-subscribed
+     * webhook (if any).
+     *
+     * `POST /conversations/{id}/unsubscribe/`
+     */
+    unsubscribe(id: UUID, options?: RequestOptions): Promise<Conversation>;
+}
+
+/**
+ * Methods for managing your connected WhatsApp phone numbers and their
+ * default routing.
+ *
+ * The `number` argument throughout is the E.164-format number without a
+ * leading `+` (matches the {@link PhoneNumber.number} field).
+ */
+declare class PhoneNumbersResource {
+    private readonly http;
+    /** @internal */
+    constructor(http: HttpClient);
+    /**
+     * List every WhatsApp number on your account.
+     *
+     * `GET /phone-numbers/`
+     */
+    list(params?: PageParams, options?: RequestOptions): AutoPaginatedList<PhoneNumber>;
+    /**
+     * View the WhatsApp Business Profile (about, address, websites, etc.)
+     * attached to this number.
+     *
+     * `GET /phone-numbers/{number}/business-profile/`
+     */
+    getBusinessProfile(number: string, options?: RequestOptions): Promise<PhoneNumberBusinessProfile>;
+    /**
+     * Route inbound messages on this number to a webhook by default. Drops
+     * any agent previously connected to the number.
+     *
+     * Phone-number routing changes do **not** fire
+     * `subscription.activated` / `.revoked` webhook events — those are
+     * reserved for per-conversation
+     * {@link ConversationsResource.subscribe} /
+     * {@link ConversationsResource.unsubscribe}.
+     *
+     * `POST /phone-numbers/{number}/subscribe/`
+     */
+    subscribe(number: string, input: SubscribePhoneNumberInput, options?: RequestOptions): Promise<PhoneNumber>;
+    /**
+     * Assign an agent as the default for this number. Drops any subscribed
+     * webhook.
+     *
+     * The agent must already be owned by or shared with the authenticated
+     * user.
+     *
+     * `POST /phone-numbers/{number}/connect-agent/`
+     */
+    connectAgent(number: string, input: ConnectAgentInput, options?: RequestOptions): Promise<PhoneNumber>;
+    /**
+     * Clear default routing on this number entirely. Drops both the agent
+     * and the webhook.
+     *
+     * `POST /phone-numbers/{number}/unsubscribe/`
+     */
+    unsubscribe(number: string, input?: UnsubscribePhoneNumberInput, options?: RequestOptions): Promise<PhoneNumber>;
+}
+
+/**
+ * A WhatsApp Business Account (WABA) linked to your Wassist account.
+ */
+interface WhatsAppAccount {
+    id: UUID;
+    name: string | null;
+    /** Meta's WABA ID. */
+    waId: string;
+    phoneNumbers: WhatsAppAccountPhoneNumber[];
+    /** URL to the WhatsApp Business Manager templates page for this WABA. */
+    templatesUrl: string;
+}
+interface WhatsAppAccountPhoneNumber {
+    id: UUID;
+    number: string;
+    bot: {
+        id: UUID;
+        name: string;
+    } | null;
+    waba: {
+        id: UUID;
+        name: string | null;
+    } | null;
+}
+/**
+ * Input for `POST /whatsapp-accounts/{id}/add-number/`.
+ *
+ * Adds a pre-verified phone number (purchased via Meta's embedded signup
+ * flow) to an existing WhatsApp Business Account.
+ */
+interface AddNumberInput {
+    /** The pre-verified Twilio phone number ID. */
+    id: string;
+    /** Verified business name to display to WhatsApp recipients. */
+    name: string;
+}
+/**
+ * A single available phone number returned by `GET /available-numbers/`.
+ */
+interface AvailableNumber {
+    id: string;
+    phone_number: string;
+}
+/**
+ * Response shape of `GET /available-numbers/`.
+ */
+interface AvailableNumbersResponse {
+    available_numbers: AvailableNumber[];
+}
+
+/**
+ * Methods for managing WhatsApp Business Accounts (WABAs) connected to
+ * your Wassist account.
+ */
+declare class WhatsAppAccountsResource {
+    private readonly http;
+    /** @internal */
+    constructor(http: HttpClient);
+    /**
+     * List every WhatsApp Business Account on your Wassist account.
+     *
+     * `GET /whatsapp-accounts/`
+     */
+    list(params?: PageParams, options?: RequestOptions): AutoPaginatedList<WhatsAppAccount>;
+    /**
+     * Retrieve a single WhatsApp Business Account by ID.
+     *
+     * `GET /whatsapp-accounts/{id}/`
+     */
+    get(id: UUID, options?: RequestOptions): Promise<WhatsAppAccount>;
+    /**
+     * Add a pre-verified phone number (purchased via Meta's embedded
+     * signup flow) to a WhatsApp Business Account.
+     *
+     * `POST /whatsapp-accounts/{id}/add-number/`
+     */
+    addNumber(id: UUID, input: AddNumberInput, options?: RequestOptions): Promise<WhatsAppAccount>;
+    /**
+     * List Twilio phone numbers available for purchase + verification.
+     *
+     * `GET /available-numbers/`
+     */
+    availableNumbers(options?: RequestOptions): Promise<AvailableNumbersResponse>;
+}
+
+type WhatsAppLinkSessionStatus = 'PENDING' | 'EXPIRED' | 'SUCCESS' | 'FAILED';
+/**
+ * A WhatsApp account-linking session — used to embed Meta's signup flow
+ * for a customer into your own product.
+ */
+interface WhatsAppLinkSession {
+    id: UUID;
+    successUrl: string;
+    returnUrl: string;
+    status: WhatsAppLinkSessionStatus;
+    /** Hosted URL to direct the user to start linking their WhatsApp account. */
+    linkUrl: string;
+}
+/** Input for `POST /whatsapp-link-sessions/`. */
+interface CreateWhatsAppLinkSessionInput {
+    /** Where to redirect the user after a successful link. */
+    successUrl: string;
+    /** Where to redirect the user if they cancel or fail. */
+    returnUrl: string;
+}
+
+/**
+ * Methods for managing WhatsApp account-linking sessions — the hosted
+ * flow that lets your customers connect their own WABA to your platform.
+ */
+declare class WhatsAppLinkSessionsResource {
+    private readonly http;
+    /** @internal */
+    constructor(http: HttpClient);
+    /**
+     * List every link session you've created.
+     *
+     * `GET /whatsapp-link-sessions/`
+     */
+    list(params?: PageParams, options?: RequestOptions): AutoPaginatedList<WhatsAppLinkSession>;
+    /**
+     * Retrieve a single link session by ID.
+     *
+     * `GET /whatsapp-link-sessions/{id}/`
+     */
+    get(id: UUID, options?: RequestOptions): Promise<WhatsAppLinkSession>;
+    /**
+     * Create a new link session. Direct the user to the returned `linkUrl`.
+     *
+     * `POST /whatsapp-link-sessions/`
+     */
+    create(input: CreateWhatsAppLinkSessionInput, options?: RequestOptions): Promise<WhatsAppLinkSession>;
+    /**
+     * Expire a pending link session early. Useful for invalidating stale
+     * URLs you've handed out to customers.
+     *
+     * `POST /whatsapp-link-sessions/{id}/expire/`
+     */
+    expire(id: UUID, options?: RequestOptions): Promise<WhatsAppLinkSession>;
+}
+
+type WhatsAppTemplateCategory = 'UTILITY' | 'MARKETING' | 'AUTHENTICATION';
+type WhatsAppTemplateStatus = 'DRAFT' | 'PENDING' | 'APPROVED' | 'REJECTED' | 'PAUSED';
+type WhatsAppTemplateQuality = 'GREEN' | 'YELLOW' | 'RED' | 'UNKNOWN';
+type WhatsAppTemplateParameterFormat = 'POSITIONAL' | 'NAMED';
+type WhatsAppTemplateButtonType = 'QUICK_REPLY' | 'URL' | 'PHONE_NUMBER' | 'COPY_CODE' | 'FLOW' | 'OTP';
+interface WhatsAppTemplateButton {
+    type: WhatsAppTemplateButtonType;
+    text: string;
+    url?: string;
+    phone_number?: string;
+    example?: string[];
+}
+interface WhatsAppTemplateNamedParam {
+    param_name: string;
+    example: string;
+}
+interface WhatsAppTemplateComponentExample {
+    body_text?: string[][];
+    header_text?: string[];
+    body_text_named_params?: WhatsAppTemplateNamedParam[];
+    header_text_named_params?: WhatsAppTemplateNamedParam[];
+    header_handle?: string[];
+    header_url?: string[];
+}
+interface WhatsAppTemplateComponent {
+    type: 'HEADER' | 'BODY' | 'FOOTER' | 'BUTTONS';
+    format?: 'TEXT' | 'IMAGE' | 'VIDEO' | 'DOCUMENT';
+    text?: string;
+    example?: WhatsAppTemplateComponentExample;
+    buttons?: WhatsAppTemplateButton[];
+}
+/**
+ * The result of publishing a template to a WABA — one entry per account.
+ */
+interface WhatsAppTemplateAccountLink {
+    accountId: UUID;
+    accountName: string | null;
+    wabaId: string;
+    metaTemplateId: string | null;
+    status: WhatsAppTemplateStatus;
+    qualityScore: WhatsAppTemplateQuality;
+    rejectionReason: string | null;
+}
+/**
+ * A Wassist-managed WhatsApp template, returned by every endpoint under
+ * `/whatsapp-templates/`.
+ */
+interface WhatsAppTemplate {
+    id: UUID;
+    name: string;
+    category: WhatsAppTemplateCategory;
+    language: string;
+    parameterFormat: WhatsAppTemplateParameterFormat;
+    components: WhatsAppTemplateComponent[];
+    /** One entry per WABA this template has been published to. */
+    accountLinks: WhatsAppTemplateAccountLink[];
+    createdAt: ISODateTime;
+    updatedAt: ISODateTime;
+}
+/** Input for `POST /whatsapp-templates/`. */
+interface CreateWhatsAppTemplateInput {
+    name: string;
+    category: WhatsAppTemplateCategory;
+    language?: string;
+    parameterFormat?: WhatsAppTemplateParameterFormat;
+    components?: WhatsAppTemplateComponent[];
+}
+/** Input for `PATCH /whatsapp-templates/{id}/`. */
+interface UpdateWhatsAppTemplateInput {
+    name?: string;
+    category?: WhatsAppTemplateCategory;
+    language?: string;
+    parameterFormat?: WhatsAppTemplateParameterFormat;
+    components?: WhatsAppTemplateComponent[];
+}
+/** Input for `POST /whatsapp-templates/{id}/publish/`. */
+interface PublishWhatsAppTemplateInput {
+    /** WABA IDs to publish this template to (must be at least one). */
+    accountIds: UUID[];
+}
+/** Input for `POST /whatsapp-templates/{id}/unpublish/`. */
+interface UnpublishWhatsAppTemplateInput {
+    /** WABA IDs to unpublish this template from (must be at least one). */
+    accountIds: UUID[];
+}
+interface WhatsAppTemplatePublishResult {
+    accountId: UUID;
+    metaTemplateId?: string;
+    status?: string;
+    error?: string;
+}
+interface WhatsAppTemplateUnpublishResult {
+    accountId: UUID;
+    unpublished: boolean;
+}
+/**
+ * Extended response from publish/unpublish endpoints — same shape as a
+ * regular `WhatsAppTemplate` plus the per-account result arrays.
+ */
+interface WhatsAppTemplateWithPublishResults extends WhatsAppTemplate {
+    publishResults?: WhatsAppTemplatePublishResult[];
+    publishErrors?: WhatsAppTemplatePublishResult[];
+    unpublishResults?: WhatsAppTemplateUnpublishResult[];
+    unpublishErrors?: WhatsAppTemplatePublishResult[];
+}
+
+/**
+ * Methods for managing Wassist-side WhatsApp templates and publishing them
+ * to your connected WABAs.
+ */
+declare class WhatsAppTemplatesResource {
+    private readonly http;
+    /** @internal */
+    constructor(http: HttpClient);
+    /**
+     * List every template you've created in Wassist.
+     *
+     * `GET /whatsapp-templates/`
+     */
+    list(params?: PageParams, options?: RequestOptions): AutoPaginatedList<WhatsAppTemplate>;
+    /**
+     * Retrieve a single template by ID.
+     *
+     * `GET /whatsapp-templates/{id}/`
+     */
+    get(id: UUID, options?: RequestOptions): Promise<WhatsAppTemplate>;
+    /**
+     * Create a new template. Published per-WABA separately via {@link publish}.
+     *
+     * `POST /whatsapp-templates/`
+     */
+    create(input: CreateWhatsAppTemplateInput, options?: RequestOptions): Promise<WhatsAppTemplate>;
+    /**
+     * Update an existing template's metadata and components.
+     *
+     * `PATCH /whatsapp-templates/{id}/`
+     */
+    update(id: UUID, input: UpdateWhatsAppTemplateInput, options?: RequestOptions): Promise<WhatsAppTemplate>;
+    /**
+     * Delete a template (and unpublish from every WABA it was published to).
+     *
+     * `DELETE /whatsapp-templates/{id}/`
+     */
+    delete(id: UUID, options?: RequestOptions): Promise<void>;
+    /**
+     * Submit this template to one or more WABAs for approval.
+     *
+     * Returns the updated template, plus per-account `publishResults` /
+     * `publishErrors`.
+     *
+     * `POST /whatsapp-templates/{id}/publish/`
+     */
+    publish(id: UUID, input: PublishWhatsAppTemplateInput, options?: RequestOptions): Promise<WhatsAppTemplateWithPublishResults>;
+    /**
+     * Remove this template from one or more WABAs.
+     *
+     * `POST /whatsapp-templates/{id}/unpublish/`
+     */
+    unpublish(id: UUID, input: UnpublishWhatsAppTemplateInput, options?: RequestOptions): Promise<WhatsAppTemplateWithPublishResults>;
+}
+
+/**
+ * The base shape every webhook event shares.
+ */
+interface WassistEventBase<TEvent extends string = string> {
+    /** The event name (e.g. `"message.received"`). */
+    event: TEvent;
+    /** Server-side timestamp the event was emitted (ISO-8601 UTC). */
+    timestamp: ISODateTime;
+}
+interface MessageReceivedMessage {
+    id: UUID;
+    /** Meta's `wamid.` ID for the inbound WhatsApp message. */
+    waId: string;
+    body: string;
+    media: {
+        url: string;
+        mimeType: string;
+    }[];
+    buttons: {
+        type: 'url' | 'quick_reply';
+        text: string;
+        url?: string;
+        quickReplyId?: string;
+    }[];
+}
+interface MessageReceivedEvent extends WassistEventBase<'message.received'> {
+    /** Your phone number that received the message. */
+    phoneNumber: PhoneNumberString;
+    /** The contact's phone number. */
+    from: PhoneNumberString;
+    contact: {
+        name: string | null;
+        phoneNumber: PhoneNumberString;
+    };
+    message: MessageReceivedMessage;
+    conversationId: UUID;
+}
+interface SubscriptionActivatedEvent extends WassistEventBase<'subscription.activated'> {
+    webhookId: UUID;
+    conversationId: UUID;
+    phoneNumber: PhoneNumberString;
+    contact: {
+        name: string | null;
+        phoneNumber: PhoneNumberString;
+    };
+}
+interface SubscriptionRevokedEvent extends WassistEventBase<'subscription.revoked'> {
+    webhookId: UUID;
+    conversationId: UUID;
+    phoneNumber: PhoneNumberString;
+    contact: {
+        name: string | null;
+        phoneNumber: PhoneNumberString;
+    };
+}
+interface TestPingEvent extends WassistEventBase<'test.ping'> {
+    /** Stub payload — used by the dashboard "Send test event" button. */
+    message: string;
+}
+/**
+ * Discriminated union of every documented Wassist webhook event.
+ *
+ * Unknown future events are still typed (as the `unknown` fallback) so a
+ * runtime call to {@link Wassist.webhooks.constructEvent} never throws on
+ * an unrecognized `event` name.
+ */
+type WassistEvent = MessageReceivedEvent | SubscriptionActivatedEvent | SubscriptionRevokedEvent | TestPingEvent | (WassistEventBase<string> & Record<string, unknown>);
+
+/**
+ * Webhook signature verification.
+ *
+ * Implements the Stripe-style `t=<unix>,v1=<hex hmac sha256>` scheme
+ * documented at https://docs.wassist.app/concepts/webhooks. Compute the HMAC of
+ * `<timestamp>.<raw body>` with   your webhook's signing secret and compare
+ * it (in constant time) to the `v1` component of `X-Wassist-Signature`.
+ *
+ * This module exposes two helpers:
+ *
+ *  - {@link Webhooks.constructEvent} — synchronous, uses `node:crypto` when
+ *    available (Node 18+).
+ *  - {@link Webhooks.constructEventAsync} — uses Web Crypto (`crypto.subtle`)
+ *    for runtimes that lack `node:crypto` (Cloudflare Workers, Deno, the
+ *    browser).
+ */
+
+interface VerifyOptions {
+    /**
+     * Maximum allowed difference between the server timestamp and `now`, in
+     * seconds. Pass `0` to disable replay protection (not recommended).
+     *
+     * @default 300
+     */
+    tolerance?: number;
+    /**
+     * Override `now` for testing — defaults to `Date.now() / 1000`.
+     * @internal
+     */
+    currentTimestamp?: number;
+}
+/**
+ * Stripe-style webhook helpers.
+ *
+ * Use via the SDK class:
+ *
+ * ```ts
+ * import { Wassist } from '@wassist/sdk';
+ *
+ * const wassist = new Wassist({ apiKey: process.env.WASSIST_API_KEY! });
+ * const event = wassist.webhooks.constructEvent(rawBody, sigHeader, secret);
+ * ```
+ *
+ * Or statically — no instance required for verification:
+ *
+ * ```ts
+ * import { Wassist } from '@wassist/sdk';
+ * const event = Wassist.webhooks.constructEvent(rawBody, sigHeader, secret);
+ * ```
+ */
+declare class Webhooks {
+    /**
+     * Verify the signature on a webhook delivery, parse the body, and return
+     * the typed event.
+     *
+     * @param payload      The raw request body, exactly as received — `string`,
+     *                     `Buffer`, or `Uint8Array`. **Do not parse it first;**
+     *                     even whitespace differences will break verification.
+     * @param header       The `X-Wassist-Signature` header value.
+     * @param secret       Your webhook signing secret. Find it in the
+     *                     [Wassist dashboard](https://wassist.app/developers/webhooks).
+     * @param options.tolerance  Replay-protection window in seconds (default 300).
+     * @throws {WassistSignatureVerificationError} When the header is malformed,
+     *  the HMAC doesn't match, or the timestamp is outside the tolerance window.
+     */
+    constructEvent(payload: string | Uint8Array, header: string | null | undefined, secret: string, options?: VerifyOptions): WassistEvent;
+    /**
+     * Async variant of {@link constructEvent} that uses Web Crypto, for
+     * runtimes that don't expose `node:crypto` (Cloudflare Workers, Deno,
+     * the browser).
+     */
+    constructEventAsync(payload: string | Uint8Array, header: string | null | undefined, secret: string, options?: VerifyOptions): Promise<WassistEvent>;
+    /**
+     * Compute the v1 signature for a `t.<body>` payload — exported as a
+     * convenience for testing.
+     */
+    signSync(signedPayload: string, secret: string): string;
+    /**
+     * Web Crypto variant of {@link signSync}.
+     */
+    signAsync(signedPayload: string, secret: string): Promise<string>;
+    private prepare;
+    private assertValid;
+    private parseEvent;
+}
+
+/**
+ * The Wassist API client.
+ *
+ * @example
+ * ```ts
+ * import { Wassist } from '@wassist/sdk';
+ *
+ * const wassist = new Wassist({ apiKey: process.env.WASSIST_API_KEY! });
+ *
+ * const agent = await wassist.agents.create({ name: 'Sales Assistant' });
+ *
+ * for await (const conv of wassist.conversations.list()) {
+ *   console.log(conv.id);
+ * }
+ * ```
+ */
+declare class Wassist {
+    /** Create and manage AI agents. */
+    readonly agents: AgentsResource;
+    /** Send messages and manage conversations (with nested `messages` resource). */
+    readonly conversations: ConversationsResource;
+    /** Manage your connected WhatsApp phone numbers and their routing. */
+    readonly phoneNumbers: PhoneNumbersResource;
+    /** Manage WhatsApp Business Accounts. */
+    readonly whatsappAccounts: WhatsAppAccountsResource;
+    /** Manage hosted WhatsApp account-linking sessions. */
+    readonly whatsappLinkSessions: WhatsAppLinkSessionsResource;
+    /** Manage WhatsApp message templates. */
+    readonly whatsappTemplates: WhatsAppTemplatesResource;
+    /** Verify inbound webhook signatures. */
+    readonly webhooks: Webhooks;
+    /**
+     * Webhook helpers — usable without instantiating a client.
+     *
+     * @example
+     * ```ts
+     * const event = Wassist.webhooks.constructEvent(body, header, secret);
+     * ```
+     */
+    static readonly webhooks: Webhooks;
+    constructor(config: WassistClientConfig);
+}
+
+/**
+ * Error hierarchy for the Wassist SDK.
+ *
+ * Every network response and webhook signature failure surfaces as a subclass
+ * of {@link WassistError}, so consumers can branch on `instanceof` (Stripe
+ * convention) and read `statusCode`, `code`, `requestId`, and the raw body.
+ */
+interface WassistErrorOptions {
+    message: string;
+    statusCode?: number;
+    code?: string;
+    requestId?: string;
+    raw?: unknown;
+    cause?: unknown;
+}
+declare class WassistError extends Error {
+    /** HTTP status code if this error originated from an API response. */
+    readonly statusCode?: number;
+    /** Machine-readable error code (e.g. `not_found`) when the API provides one. */
+    readonly code?: string;
+    /**
+     * Request ID surfaced by the Wassist API in the `X-Request-Id` response
+     * header. Include this when filing support tickets.
+     */
+    readonly requestId?: string;
+    /** Raw response body, parsed as JSON when possible. */
+    readonly raw?: unknown;
+    constructor(opts: WassistErrorOptions);
+}
+/** 401 Unauthorized — the API key was missing, malformed, or revoked. */
+declare class WassistAuthenticationError extends WassistError {
+}
+/** 403 Forbidden — the API key lacks permission for this resource. */
+declare class WassistPermissionError extends WassistError {
+}
+/** 400 / 422 — the request body or parameters were invalid. */
+declare class WassistInvalidRequestError extends WassistError {
+}
+/** 404 Not Found — the requested resource does not exist. */
+declare class WassistNotFoundError extends WassistError {
+}
+/** 409 Conflict — the request conflicts with the current state. */
+declare class WassistConflictError extends WassistError {
+}
+/** 429 Too Many Requests — slow down or wait `retryAfter` seconds. */
+declare class WassistRateLimitError extends WassistError {
+    /** Suggested wait in seconds, from the `Retry-After` response header. */
+    readonly retryAfter?: number;
+    constructor(opts: WassistErrorOptions & {
+        retryAfter?: number;
+    });
+}
+/** 5xx — something is wrong on Wassist's side. The SDK retries these automatically. */
+declare class WassistAPIError extends WassistError {
+}
+/** A network-level failure (DNS, TCP, TLS, abort, etc.) — never made it to the server. */
+declare class WassistConnectionError extends WassistError {
+}
+/** The request exceeded the configured `timeout`. */
+declare class WassistTimeoutError extends WassistError {
+}
+/**
+ * Webhook signature could not be verified.
+ *
+ * Thrown by {@link Wassist.webhooks.constructEvent} when the header is
+ * malformed, the HMAC doesn't match, or the timestamp falls outside the
+ * tolerance window.
+ */
+declare class WassistSignatureVerificationError extends WassistError {
+    /** The raw `X-Wassist-Signature` header value as received. */
+    readonly header?: string;
+    /** The payload that was verified, as the SDK saw it. */
+    readonly payload?: string;
+    constructor(opts: WassistErrorOptions & {
+        header?: string;
+        payload?: string;
+    });
+}
+
+/**
+ * The package version, embedded into the `User-Agent` header on every
+ * outbound request so Wassist can correlate API traffic with SDK versions.
+ *
+ * Updated in lockstep with `package.json`'s `version` field.
+ */
+declare const SDK_VERSION = "0.1.0";
+
+export { type AddNumberInput, type Agent, type AgentCreditSettings, type AgentCreditSettingsInput, type AgentDocument, type AgentHandoffTool, type AgentHandoffToolInput, type AgentImageGenerateTool, type AgentImageGenerateToolInput, type AgentMcpConfig, type AgentMcpConfigInput, type AgentMemoryKey, type AgentMemoryKeyInput, type AgentOutboundTrigger, type AgentOutboundTriggerInput, type AgentPaywallConfig, type AgentPaywallConfigInput, type AgentTool, type AgentToolInput, type AgentWakeUpConfig, type AgentWakeUpConfigInput, type AgentWebsiteTool, type AgentWebsiteToolInput, type AgentWhatsAppPhoneNumber, AgentsResource, AutoPaginatedList, type AvailableNumber, type AvailableNumbersResponse, type CTAButtonMessage, type ConnectAgentInput, type Conversation, type ConversationContact, type ConversationLastMessage, ConversationsResource, type CreateAgentInput, type CreateBYOAAgentInput, type CreateConversationInput, type CreateConversationMessageInput, type CreateWhatsAppLinkSessionInput, type CreateWhatsAppTemplateInput, type FetchLike, type FileInfo, type ISODateTime, type ImageInfo, type ImageMessage, type ListConversationsParams, type ListSelectionMessage, type Message, type MessageReceivedEvent, type MessageReceivedMessage, type MessageRole, type MessageStatus, type MessageType, MessagesResource, type Page, type PageParams, type PaginatedResponse, type PhoneNumber, type PhoneNumberBusinessProfile, type PhoneNumberRoutingMode, type PhoneNumberString, PhoneNumbersResource, type PromptAgentInput, type PublicUser, type PublishWhatsAppTemplateInput, type QuickReplyMessage, type RequestOptions, SDK_VERSION, type SendMessageCtaImageInput, type SendMessageCtaInput, type SendMessageInput, type SendMessageTemplateInput, type SendMessageTextInput, type SendUnifiedMessageButtonInput, type SendUnifiedMessageInput, type SendUnifiedMessageMediaInput, type SubscribeConversationInput, type SubscribePhoneNumberInput, type SubscriptionActivatedEvent, type SubscriptionRevokedEvent, type TemplateMessage, type TestPingEvent, type TextMessage, type UUID, type UnifiedMessage, type UnifiedMessageButton, type UnifiedMessageButtonType, type UnifiedMessageMedia, type UnpublishWhatsAppTemplateInput, type UnsubscribePhoneNumberInput, type UpdateAgentInput, type UpdateWhatsAppTemplateInput, Wassist, WassistAPIError, WassistAuthenticationError, type WassistClientConfig, WassistConflictError, WassistConnectionError, WassistError, type WassistErrorOptions, type WassistEvent, type WassistEventBase, WassistInvalidRequestError, WassistNotFoundError, WassistPermissionError, WassistRateLimitError, WassistSignatureVerificationError, WassistTimeoutError, Webhooks, type WhatsAppAccount, type WhatsAppAccountPhoneNumber, WhatsAppAccountsResource, type WhatsAppLinkSession, type WhatsAppLinkSessionStatus, WhatsAppLinkSessionsResource, type WhatsAppTemplate, type WhatsAppTemplateAccountLink, type WhatsAppTemplateButton, type WhatsAppTemplateButtonType, type WhatsAppTemplateCategory, type WhatsAppTemplateComponent, type WhatsAppTemplateComponentExample, type WhatsAppTemplateNamedParam, type WhatsAppTemplateParameterFormat, type WhatsAppTemplatePublishResult, type WhatsAppTemplateQuality, type WhatsAppTemplateStatus, type WhatsAppTemplateUnpublishResult, type WhatsAppTemplateWithPublishResults, WhatsAppTemplatesResource };