@messagebird/sdk 0.5.0 → 0.6.0

package/README.md

@@ -64,6 +64,21 @@ for await (const message of bird.email.list()) {
 }
 ```
 
+## WhatsApp
+
+```ts
+await bird.whatsapp.send({ to, template }); // resolves when accepted (202); Bird picks the sender from the template's category
+await bird.whatsapp.get(messageId); // delivery status + failure detail
+
+// `await` yields the first page; `for await` walks every message across pages.
+for await (const message of bird.whatsapp.list()) {
+  console.log(message.id);
+}
+
+const { data } = await bird.whatsapp.listEvents(messageId); // full lifecycle timeline, not paginated
+const { data: templates } = await bird.whatsappTemplates.list(); // the workspace's Meta-approved templates
+```
+
 ## Webhooks
 
 `unwrap` verifies a delivery's Standard Webhooks signature and returns a typed, discriminated event. **Pass the raw request body** — never the parsed JSON. Set the signing secret once via `webhooks: { secret }` on the client (or pass `{ secret }` per call).

package/dist/index.d.mts

@@ -619,22 +619,7 @@ type EventEmailMailboxMessageSent = {
   data: EventEmailMailboxMessageSentData;
 };
 /**
- * An email was received into a mailbox and stored with disposition unauthenticated — sender authentication could not be verified. Opt-in. Non-inbox dispositions fire only this mailbox variant, never email.received — existing email.received automations never start processing unauthenticated mail because a mailbox was attached. The payload carries identifiers, threading, authentication results, and the extracted text.
- */
-type EventEmailMailboxMessageReceivedUnauthenticated = {
-  /**
-   * Event type.
-   */
-  type: "email_mailbox.message_received_unauthenticated";
-  /**
-   * When the event occurred.
-   */
-  timestamp: string;
-  data: EventEmailMailboxMessageReceivedData;
-};
-type InboundEmailMessageId = string;
-/**
- * Payload shared by the email_mailbox.message_received event family. Carries identifiers, threading, disposition, authentication results, and the extracted text — enough for an agent to act without a fetch. Fetch original source (while within its 30-day window) via the thread-member endpoints.
+ * Payload for the email_mailbox.message_received event. Carries identifiers, threading, authentication results, and the extracted text — enough for an agent to act without a fetch. Fetch original source (while within its 30-day window) via the thread-member endpoints.
  */
 type EventEmailMailboxMessageReceivedData = {
   /**
@@ -665,10 +650,6 @@ type EventEmailMailboxMessageReceivedData = {
    * Subject line as received, or null when the message had no subject.
    */
   subject: string | null;
-  /**
-   * Where the message landed after receive policy, rules, and scanning were applied.
-   */
-  disposition: "inbox" | "blocked" | "unauthenticated";
   /**
    * Plain-text body with quoted history stripped, capped at 64 KB (see truncated_text). Null when extraction produced nothing. This copy is what the mailbox durably retains.
    */
@@ -694,22 +675,9 @@ type EventEmailMailboxMessageReceivedData = {
    */
   dmarc_pass?: boolean | null;
 };
+type InboundEmailMessageId = string;
 /**
- * An email was received into a mailbox and stored with disposition blocked — it failed the mailbox receive policy or a block rule. Opt-in. Non-inbox dispositions fire only this mailbox variant, never email.received — existing email.received automations never start processing blocked mail because a mailbox was attached. The payload carries identifiers, threading, authentication results, and the extracted text.
- */
-type EventEmailMailboxMessageReceivedBlocked = {
-  /**
-   * Event type.
-   */
-  type: "email_mailbox.message_received_blocked";
-  /**
-   * When the event occurred.
-   */
-  timestamp: string;
-  data: EventEmailMailboxMessageReceivedData;
-};
-/**
- * An email was received into a mailbox, threaded, and stored with disposition inbox. The payload carries identifiers, threading, authentication results, and the extracted text — enough for an agent to act without a fetch. Dual-fire rule: mailbox-owned inbound with disposition inbox ALSO fires the unchanged email.received event; the streams are unordered relative to each other, so pick one family per automation and dedupe by message_id.
+ * An email arrived in a mailbox and was filed to its inbox, threaded and stored. The payload carries identifiers, threading, authentication results, and the extracted text — enough for an agent to act without a fetch. Dual-fire rule: the same message ALSO fires the unchanged email.received event; the streams are unordered relative to each other, so pick one family per automation and dedupe by message_id.
  */
 type EventEmailMailboxMessageReceived = {
   /**
@@ -1353,10 +1321,6 @@ type WebhookEvent = ({
 } & EventEmailMailboxMessageFailed) | ({
   type: "email_mailbox.message_received";
 } & EventEmailMailboxMessageReceived) | ({
-  type: "email_mailbox.message_received_blocked";
-} & EventEmailMailboxMessageReceivedBlocked) | ({
-  type: "email_mailbox.message_received_unauthenticated";
-} & EventEmailMailboxMessageReceivedUnauthenticated) | ({
   type: "email_mailbox.message_sent";
 } & EventEmailMailboxMessageSent) | ({
   type: "email_mailbox.suspended";
@@ -1384,58 +1348,82 @@ type Timestamps = {
   readonly updated_at: string;
 };
 /**
- * File attached to an email send. The attachment bytes are passed as base64-encoded `content` directly in the request body (required). The `path` field (provide a URL and Bird fetches the attachment for you) is a preview feature and currently unavailable. Requests are rejected with 422 if `content` is missing — `path` alone does not satisfy the schema. When `path` becomes generally available, the schema will be relaxed so that exactly one of `content` or `path` is required.
- * Inline images for `<img src="cid:..."/>` references in the HTML body use the `content_id` field together with `content`.
- * Bird enforces a **20 MB estimated generated message size** cap. The estimate is the HTML and text body plus all attachments and inline images measured after base64 encoding. This is not a raw file-size cap. As a rule of thumb, keep total raw attachment content at or below **15 MB** so the generated message has enough room after encoding and MIME wrapping.
- * Recipient-side delivery reality: downstream limits vary by product and tenant/server policy. Gmail personal and Outlook.com document 25 MB attachment limits. Exchange Online defaults to 35 MB send / 36 MB receive, but admins can configure limits; on-prem Exchange Server organizational defaults are 10 MB. Sends close to Bird's 20 MB generated-message cap may be accepted by Bird but bounce at the recipient's mail server.
- * Batch sends can include attachments on individual message objects. Each message still has the 20 MB estimated generated-size cap, and the serialized JSON request body for the whole batch has a hard 20 MB cap. Certain executable / script content types are rejected at validation time.
- *
+ * An email address with an optional display name.
  */
-type EmailAttachment = {
+type EmailAddress = {
   /**
-   * Filename shown to the recipient. Required.
+   * Email address.
    */
-  filename: string;
+  email: string;
   /**
-   * Base64-encoded attachment bytes. Required. Counts toward the 20 MB estimated generated message-size cap after encoding and MIME wrapping.
-   *
+   * Display name shown alongside the address in mail clients.
    */
-  content: string;
+  name?: string;
+};
+type WhatsAppTemplateList = {
   /**
-   * Preview feature — provide a URL and Bird fetches the attachment for you. Currently unavailable. Use `content` instead. The schema currently requires `content`, so a request with only `path` is rejected with 422 for missing `content`; a request supplying both `content` and `path` is rejected with 422 `unsupported_feature` until this preview ships. When generally available: HTTPS-only, single redirect followed and re-validated, private IP ranges blocked, request timeout enforced, fetched content counts toward the 20 MB estimated generated message-size cap after encoding and MIME wrapping.
-   *
+   * The templates available to your workspace.
    */
-  path?: string;
+  data: Array<WhatsAppTemplate>;
+};
+type WhatsAppTemplateButton = {
   /**
-   * MIME type. Inferred from `filename` extension when omitted. Used to enforce the blocklist of disallowed executable / script types.
-   *
+   * The button's behavior type.
    */
-  content_type?: string;
+  readonly type: string;
   /**
-   * RFC 2392 Content-ID. When set, the attachment is rendered inline and can be referenced from the HTML body as `<img src="cid:{content_id}"/>`. When omitted, the attachment is rendered as a regular file attachment.
-   *
+   * The button's label text.
    */
-  content_id?: string;
+  readonly text: string;
+  /**
+   * The URL the button opens, with any variable placeholder shown inline. Present on link buttons.
+   */
+  readonly url?: string;
+  /**
+   * Example values for this button's variables, in placeholder order. Present when the button URL has variables.
+   */
+  readonly example_parameters?: Array<WhatsAppTemplateExampleParameter>;
 };
 /**
- * An email address with an optional display name.
+ * The type of a template parameter.
  */
-type EmailAddress = {
+type WhatsAppTemplateParameterType = string;
+type WhatsAppTemplateExampleParameter = {
   /**
-   * Email address.
+   * The kind of value this parameter accepts.
    */
-  email: string;
+  readonly type: WhatsAppTemplateParameterType;
   /**
-   * Display name shown alongside the address in mail clients.
+   * An example value for a text parameter. Present when `type` is `text`.
    */
-  name?: string;
+  readonly text?: string;
+};
+type WhatsAppTemplateComponent = {
+  /**
+   * The content block's type within the template.
+   */
+  readonly type: string;
+  /**
+   * The block's text content, with any variable placeholders shown inline. Present when the block carries text.
+   */
+  readonly text?: string;
+  /**
+   * Example values for this block's variables, in placeholder order — one per `{{n}}`. Use them to see what a filled message looks like. Present when the block has variables.
+   */
+  readonly example_parameters?: Array<WhatsAppTemplateExampleParameter>;
+  /**
+   * The buttons attached to this block. Present when the block carries buttons.
+   */
+  readonly buttons?: Array<WhatsAppTemplateButton>;
 };
 /**
- * A sender or recipient address. Accepts a plain email string (`jane@example.com`), an RFC 5322 mailbox string with an embedded display name (`Jane Doe <jane@example.com>`), or an object carrying the address and an optional display name. All forms can be mixed freely within one request; responses always return the object form.
- *
+ * A message template's review and health status. `approved`, `pending`, and `rejected` are review outcomes; `paused`, `disabled`, `in_appeal`, `pending_deletion`, and `limit_exceeded` reflect a template's ongoing health after approval.
  */
-type EmailAddressInput = string | EmailAddress;
-type ContactId = string;
+type WhatsAppTemplateStatus = string;
+/**
+ * WhatsApp template category — Meta's content classification for a template. Open enum — Meta may add new categories over time, so treat any unrecognized value as a future category rather than an error. The values below are the categories known at this version.
+ */
+type WhatsAppTemplateCategory = string;
 /**
  * Whether the template is a built-in Bird template (`system`) or one your workspace authored (`workspace`).
  */
@@ -1445,6 +1433,213 @@ type TemplateScope = "system" | "workspace";
  *
  */
 type TemplateName = string;
+type WhatsAppTemplate = {
+  /**
+   * The template's stable handle. Pass it as the template reference when sending.
+   */
+  readonly name: TemplateName;
+  scope: TemplateScope;
+  /**
+   * The language code of this template variant (for example `en` or `pt_BR`).
+   */
+  readonly language: string;
+  /**
+   * Content classification applied to messages sent from this template.
+   */
+  readonly category: WhatsAppTemplateCategory;
+  /**
+   * The template's review and health status.
+   */
+  readonly status: WhatsAppTemplateStatus;
+  /**
+   * The content blocks that make up the template, in display order.
+   */
+  readonly components: Array<WhatsAppTemplateComponent>;
+};
+type WhatsAppEventList = {
+  /**
+   * Timeline events for this WhatsApp message, in chronological order. The timeline is bounded and returned in full — this list is not paginated.
+   */
+  data: Array<WhatsAppEvent>;
+};
+/**
+ * Bird-stable failure reason, uniform whether the failure happened internally or was reported by the WhatsApp network. `insufficient_balance` — the workspace could not afford the send. `price_not_found` — no price was configured for this destination/template combination. `internal_error` — an unexpected Bird-side failure. `undeliverable` — the recipient could not be reached (e.g. not on WhatsApp, number invalid). `service_window_expired` — the 24-hour customer care window has closed and a free-form message cannot be sent; send a template instead. `rate_limited` — the send was throttled.
+ *
+ */
+type WhatsAppErrorCode = string;
+/**
+ * Failure detail for a message that could not be delivered. Null when there is no failure.
+ */
+type WhatsAppError = {
+  code: WhatsAppErrorCode;
+  /**
+   * Human-readable explanation of the failure.
+   */
+  readonly description: string;
+  /**
+   * When the failure occurred.
+   */
+  readonly occurred_at: string;
+} | null;
+type WhatsAppEventId = string;
+type WhatsAppEvent = {
+  /**
+   * Event ID.
+   */
+  readonly id: WhatsAppEventId;
+  /**
+   * Lifecycle event type. `whatsapp.accepted` — Bird accepted the request. `whatsapp.sent` — handed to the WhatsApp network. `whatsapp.delivered` — delivery confirmed to the recipient's device. `whatsapp.read` — the recipient opened the message (this does not change the message `status`, which never becomes `read`). `whatsapp.failed` — terminal permanent failure. Open enum — new event types may be added over time, so treat any unrecognized value as a future event rather than an error.
+   *
+   */
+  readonly type: string;
+  /**
+   * When this event occurred.
+   */
+  readonly occurred_at: string;
+  /**
+   * Failure detail. Present on `whatsapp.failed` events; null otherwise.
+   */
+  error: WhatsAppError;
+};
+type SendWhatsAppMessageRequest = {
+  /**
+   * The message recipient's phone number in E.164 format (for example `+31612345678`).
+   */
+  to: string;
+  /**
+   * The template to send. Bird selects the sender number from the template's category, so there is no sender field on this request. Templates are currently the only supported content type, so every send must include one; free-text content will be added in a future release.
+   *
+   */
+  template?: SendWhatsAppMessageTemplate;
+};
+type WhatsAppMessageTemplateComponentParameter = {
+  /**
+   * Parameter type.
+   */
+  type: WhatsAppTemplateParameterType;
+  /**
+   * Parameter value.
+   */
+  text: string;
+};
+type WhatsAppMessageTemplateComponent = {
+  /**
+   * Which part of the template this fills in.
+   */
+  type: string;
+  /**
+   * The values that fill this part's placeholders, in order.
+   */
+  parameters?: Array<WhatsAppMessageTemplateComponentParameter>;
+};
+type SendWhatsAppMessageTemplate = {
+  /**
+   * The template to send, by its name (for example `bird_otp`).
+   */
+  name: TemplateName;
+  /**
+   * Language code of the template variant to send (for example `en` or `pt_BR`). May be omitted when the template has a single language.
+   *
+   */
+  language?: string;
+  /**
+   * The values that fill the template's placeholders.
+   */
+  components?: Array<WhatsAppMessageTemplateComponent>;
+};
+/**
+ * Delivery status. `scheduled` means the message is queued to send at a future time and has not been dispatched yet. `accepted` means Bird accepted the request and it is queued for sending. `sent` means it was handed to the WhatsApp network. `delivered` is confirmed delivery to the recipient's device. `failed` is a terminal permanent failure. `canceled` means a scheduled message was canceled before it was sent. `received` is the status of an inbound message (`direction: inbound`) sent to you by a contact. There is no `read` status — a read receipt is reported as `read_at` and a `whatsapp.read` event, not a status value.
+ *
+ */
+type WhatsAppMessageStatus = "scheduled" | "accepted" | "sent" | "delivered" | "failed" | "canceled" | "received";
+/**
+ * The template a message was sent from. On reads `name`, `language`, `category`, and `components` are always present — `components` is an empty array for an authentication template (the filled-in values, e.g. a verification code, are never returned).
+ *
+ */
+type WhatsAppMessageTemplate = {
+  /**
+   * The template's stable handle (for example `bird_otp`).
+   */
+  readonly name: TemplateName;
+  /**
+   * Content classification applied to messages sent from this template.
+   */
+  readonly category: WhatsAppTemplateCategory;
+  /**
+   * The language code of the template variant that was sent (for example `en`).
+   */
+  readonly language: string;
+  /**
+   * The values that filled the template's placeholders. Empty for an authentication template, whose content is never returned.
+   *
+   */
+  readonly components: Array<WhatsAppMessageTemplateComponent>;
+};
+/**
+ * Contact on the other end of the message. Fields are omitted when not available; at least one is always present.
+ */
+type WhatsAppMessageContact = {
+  /**
+   * Contact's phone number in E.164 format, when known.
+   */
+  readonly phone_number?: string;
+  /**
+   * Business-scoped user ID (Meta's WhatsApp identifier for this contact within the business account), when available.
+   */
+  readonly bsuid?: string;
+};
+/**
+ * The business identity that sent the message. `phone_number` is always present; `phone_number_id` is included only for account-owned numbers.
+ *
+ */
+type WhatsAppMessageBusiness = {
+  /**
+   * E.164 phone number of the WhatsApp business account that sent the message.
+   */
+  readonly phone_number?: string;
+  /**
+   * The WhatsApp phone number identifier. Present only for account-owned numbers.
+   */
+  readonly phone_number_id?: string;
+};
+type WhatsAppMessageId = string;
+type WhatsAppMessage = {
+  /**
+   * Message ID.
+   */
+  readonly id: WhatsAppMessageId;
+  /**
+   * Whether the message was sent by the business (`outbound`) or received from the contact (`inbound`).
+   */
+  readonly direction: "outbound" | "inbound";
+  readonly business: WhatsAppMessageBusiness;
+  readonly contact: WhatsAppMessageContact;
+  /**
+   * The template the message was sent from. For authentication templates the filled-in values are not returned.
+   */
+  readonly template?: WhatsAppMessageTemplate;
+  readonly status: WhatsAppMessageStatus;
+  /**
+   * Failure detail for a message that did not reach the recipient. Null when there is no failure.
+   */
+  last_error?: WhatsAppError;
+  /**
+   * When the message was accepted for delivery.
+   */
+  readonly created_at: string;
+  /**
+   * When the message was handed to the WhatsApp network. Null until then.
+   */
+  readonly sent_at?: string | null;
+  /**
+   * When delivery was confirmed. Null until then.
+   */
+  readonly delivered_at?: string | null;
+  /**
+   * When the message was read by the recipient. Null until then.
+   */
+  readonly read_at?: string | null;
+};
 type SmsTemplateList = {
   /**
    * The templates available to your workspace. The catalogue is small and returned in full — this list is not paginated.
@@ -1815,6 +2010,7 @@ type AudienceContactsRemoveRequest = {
    */
   contact_ids: Array<ContactId>;
 };
+type ContactId = string;
 type AudienceContactsAddRequest = {
   /**
    * Contacts to add to the audience. Adding a contact that is already a member has no effect. If any ID does not exist, the whole request fails and no contacts are added.
@@ -2069,6 +2265,40 @@ type EmailMessageBatchItem = {
  *
  */
 type EmailMessageBatchRequest = Array<EmailMessageSendRequest>;
+/**
+ * File attached to an email send. The attachment bytes are passed as base64-encoded `content` directly in the request body (required). The `path` field (provide a URL and Bird fetches the attachment for you) is a preview feature and currently unavailable. Requests are rejected with 422 if `content` is missing — `path` alone does not satisfy the schema. When `path` becomes generally available, the schema will be relaxed so that exactly one of `content` or `path` is required.
+ * Inline images for `<img src="cid:..."/>` references in the HTML body use the `content_id` field together with `content`.
+ * Bird enforces a **20 MB estimated generated message size** cap. The estimate is the HTML and text body plus all attachments and inline images measured after base64 encoding. This is not a raw file-size cap. As a rule of thumb, keep total raw attachment content at or below **15 MB** so the generated message has enough room after encoding and MIME wrapping.
+ * Recipient-side delivery reality: downstream limits vary by product and tenant/server policy. Gmail personal and Outlook.com document 25 MB attachment limits. Exchange Online defaults to 35 MB send / 36 MB receive, but admins can configure limits; on-prem Exchange Server organizational defaults are 10 MB. Sends close to Bird's 20 MB generated-message cap may be accepted by Bird but bounce at the recipient's mail server.
+ * Batch sends can include attachments on individual message objects. Each message still has the 20 MB estimated generated-size cap, and the serialized JSON request body for the whole batch has a hard 20 MB cap. Certain executable / script content types are rejected at validation time.
+ *
+ */
+type EmailAttachment = {
+  /**
+   * Filename shown to the recipient. Required.
+   */
+  filename: string;
+  /**
+   * Base64-encoded attachment bytes. Required. Counts toward the 20 MB estimated generated message-size cap after encoding and MIME wrapping.
+   *
+   */
+  content: string;
+  /**
+   * Preview feature — provide a URL and Bird fetches the attachment for you. Currently unavailable. Use `content` instead. The schema currently requires `content`, so a request with only `path` is rejected with 422 for missing `content`; a request supplying both `content` and `path` is rejected with 422 `unsupported_feature` until this preview ships. When generally available: HTTPS-only, single redirect followed and re-validated, private IP ranges blocked, request timeout enforced, fetched content counts toward the 20 MB estimated generated message-size cap after encoding and MIME wrapping.
+   *
+   */
+  path?: string;
+  /**
+   * MIME type. Inferred from `filename` extension when omitted. Used to enforce the blocklist of disallowed executable / script types.
+   *
+   */
+  content_type?: string;
+  /**
+   * RFC 2392 Content-ID. When set, the attachment is rendered inline and can be referenced from the HTML body as `<img src="cid:{content_id}"/>`. When omitted, the attachment is rendered as a regular file attachment.
+   *
+   */
+  content_id?: string;
+};
 type EmailTemplateId = string;
 type EmailTemplateSend = unknown & {
   /**
@@ -2087,6 +2317,11 @@ type EmailTemplateSend = unknown & {
     [key: string]: unknown;
   };
 };
+/**
+ * A sender or recipient address. Accepts a plain email string (`jane@example.com`), an RFC 5322 mailbox string with an embedded display name (`Jane Doe <jane@example.com>`), or an object carrying the address and an optional display name. All forms can be mixed freely within one request; responses always return the object form.
+ *
+ */
+type EmailAddressInput = string | EmailAddress;
 type EmailMessageSendRequest = {
   /**
    * Sender address, as a plain email string, an RFC 5322 mailbox string (`Jane <jane@example.com>`), or an object with an optional display name. Must be from a verified domain in this workspace.
@@ -2589,6 +2824,61 @@ type ListSmsTemplatesData = {
   };
   url: "/v1/sms/templates";
 };
+type ListWhatsAppMessagesData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * Maximum number of items to return per page.
+     */
+    limit?: number;
+    /**
+     * Cursor from the `next_cursor` field of a previous list response. Returns items immediately after the cursor position in the current sort order.
+     */
+    starting_after?: string;
+    /**
+     * Cursor from the `prev_cursor` field of a previous list response. Returns items immediately before the cursor position in the current sort order.
+     */
+    ending_before?: string;
+    /**
+     * Return only resources created strictly after this timestamp. RFC 3339 / ISO 8601 with timezone.
+     */
+    created_after?: string;
+    /**
+     * Return only resources created strictly before this timestamp. RFC 3339 / ISO 8601 with timezone.
+     */
+    created_before?: string;
+    /**
+     * Filter by status. Repeat the parameter to match any of several statuses.
+     */
+    status?: Array<WhatsAppMessageStatus>;
+    /**
+     * Filter by contact phone number (E.164 exact match).
+     */
+    phone_number?: string;
+    /**
+     * Filter by business-scoped user ID (Meta identifier).
+     */
+    bsuid?: string;
+  };
+  url: "/v1/whatsapp/messages";
+};
+type ListWhatsAppMessageEventsData = {
+  body?: never;
+  path: {
+    /**
+     * Message ID.
+     */
+    message_id: WhatsAppMessageId;
+  };
+  query?: {
+    /**
+     * Filter by event type (e.g. `whatsapp.delivered`, `whatsapp.failed`).
+     */
+    type?: string;
+  };
+  url: "/v1/whatsapp/messages/{message_id}/events";
+};
 //#endregion
 //#region src/generated/core/auth.gen.d.ts
 type AuthToken = string | undefined;
@@ -3371,6 +3661,79 @@ declare class SmsTemplatesResource extends Resource {
   get(templateRef: string, options?: RequestOptions): APIPromise<SmsTemplate>;
 }
 //#endregion
+//#region src/resources/whatsapp.d.ts
+/** Body for `bird.whatsapp.send` — a template send; Bird picks the sender from the template's category. */
+type WhatsappSendParams = SendWhatsAppMessageRequest;
+/** Filters and cursor params for `bird.whatsapp.list`. */
+type WhatsappListQuery = NonNullable<ListWhatsAppMessagesData["query"]>;
+/** Filter for `bird.whatsapp.listEvents`. */
+type WhatsappListEventsQuery = NonNullable<ListWhatsAppMessageEventsData["query"]>;
+declare class WhatsappResource extends Resource {
+  /**
+   * Send a template message. Bird selects the sender number from the
+   * template's category, so there is no sender field on the request. The
+   * result is `accepted`, not yet delivered — read it back with `get` to
+   * confirm.
+   *
+   * @example
+   * const msg = await bird.whatsapp.send({
+   *   to: "+15551234567",
+   *   template: {
+   *     name: "bird_otp",
+   *     components: [
+   *       { type: "body", parameters: [{ type: "text", text: "123456" }] },
+   *     ],
+   *   },
+   * });
+   * console.log(msg.id, msg.status);
+   */
+  send(params: WhatsappSendParams, options?: RequestOptions): APIPromise<WhatsAppMessage>;
+  /**
+   * Fetch a single WhatsApp message: its current delivery status and failure
+   * detail if it failed.
+   *
+   * @example
+   * const msg = await bird.whatsapp.get("wa_abc123");
+   * msg.status; // "accepted" | "delivered" | …
+   */
+  get(messageId: string, options?: RequestOptions): APIPromise<WhatsAppMessage>;
+  /**
+   * List WhatsApp messages, newest first. `await` resolves the first page;
+   * `for await` walks every message across all pages. Filter by status,
+   * recipient phone number, or business-scoped user ID.
+   *
+   * @example
+   * for await (const msg of bird.whatsapp.list({ status: ["delivered"] })) {
+   *   console.log(msg.id, msg.status);
+   * }
+   */
+  list(query?: WhatsappListQuery, options?: RequestOptions): PaginatedPromise<WhatsAppMessage>;
+  /**
+   * List a WhatsApp message's lifecycle event timeline, in chronological
+   * order. The timeline is bounded and returned in full — this list is not
+   * paginated.
+   *
+   * @example
+   * const { data } = await bird.whatsapp.listEvents("wa_abc123");
+   * for (const event of data) console.log(event.type, event.occurred_at);
+   */
+  listEvents(messageId: string, query?: WhatsappListEventsQuery, options?: RequestOptions): APIPromise<WhatsAppEventList>;
+}
+//#endregion
+//#region src/resources/whatsappTemplates.d.ts
+declare class WhatsappTemplatesResource extends Resource {
+  /**
+   * List the WhatsApp message templates available to the workspace — Meta's
+   * approved templates for this business account. The catalogue is small and
+   * returned in full (`.data`); this list is not paginated.
+   *
+   * @example
+   * const { data } = await bird.whatsappTemplates.list();
+   * for (const tpl of data) console.log(tpl.name, tpl.status);
+   */
+  list(options?: RequestOptions): APIPromise<WhatsAppTemplateList>;
+}
+//#endregion
 //#region src/resources/webhooks.d.ts
 /** A verified webhook event — discriminated on `type` (ADR-0028 wire contract). */
 type BirdWebhookEvent = WebhookEvent;
@@ -3504,6 +3867,10 @@ declare class BirdClient<const O extends BirdClientOptions = BirdClientOptions>
   readonly sms: SmsResource;
   /** SMS templates — `bird.smsTemplates.list(...)`, `.get(...)`. */
   readonly smsTemplates: SmsTemplatesResource;
+  /** The WhatsApp channel — `bird.whatsapp.send(...)`, `.get(...)`, `.list(...)`, `.listEvents(...)`. */
+  readonly whatsapp: WhatsappResource;
+  /** WhatsApp templates — `bird.whatsappTemplates.list(...)`. */
+  readonly whatsappTemplates: WhatsappTemplatesResource;
   /** Contacts — `bird.contacts.create(...)`, `.list(...)`, `.get(...)`, `.batch(...)`, … */
   readonly contacts: ContactsResource;
   /** Audiences — `bird.audiences.create(...)`, `.list(...)`, `.addContacts(...)`, … */
@@ -3554,8 +3921,6 @@ declare const WebhookEventType: {
   readonly EmailMailboxMessageDelivered: "email_mailbox.message_delivered";
   readonly EmailMailboxMessageFailed: "email_mailbox.message_failed";
   readonly EmailMailboxMessageReceived: "email_mailbox.message_received";
-  readonly EmailMailboxMessageReceivedBlocked: "email_mailbox.message_received_blocked";
-  readonly EmailMailboxMessageReceivedUnauthenticated: "email_mailbox.message_received_unauthenticated";
   readonly EmailMailboxMessageSent: "email_mailbox.message_sent";
   readonly EmailMailboxSuspended: "email_mailbox.suspended";
   readonly EmailMailboxThreadCreated: "email_mailbox.thread_created";
@@ -3578,5 +3943,5 @@ declare const WebhookEventType: {
 /** A known webhook event type value. */
 type WebhookEventTypeValue = (typeof WebhookEventType)[keyof typeof WebhookEventType];
 //#endregion
-export { type APIPromise, type Audience, type AudienceAddContactsParams, type AudienceContactsQuery, type AudienceCreateParams, type AudienceListQuery, type AudienceMember, type AudienceRemoveContactsParams, type AudienceUpdateParams, BirdAPIError, BirdAuthError, BirdBadRequestError, BirdBillingError, BirdClient, type BirdClientOptions, BirdConflictError, BirdConnectionError, BirdError, BirdInternalError, BirdMisdirectedError, BirdNotFoundError, BirdNotImplementedError, BirdPayloadTooLargeError, BirdPermissionError, BirdPreconditionError, BirdRateLimitError, type BirdRequest, type BirdResponse, BirdServiceUnavailableError, BirdTimeoutError, BirdValidationError, type BirdWebhookEvent, BirdWebhookVerificationError, type Contact, type ContactBatchParams, type ContactCreateParams, type ContactListQuery, type ContactProperty, type ContactPropertyCreateParams, type ContactPropertyListQuery, type ContactPropertyUpdateParams, type ContactUpdateParams, type ContactUpsertResult, type CursorPage, type EmailChannelDefaults, type EmailListQuery, type EmailMessage, type EmailSendBatchParams, type EmailSendBatchResult, type EmailSendParams, type ErrorDetail, type ErrorNextAction, type PaginatedPromise, type RequestOptions, type SafeResult, type SmsListQuery, type SmsMessage, type SmsSendBatchParams, type SmsSendBatchResult, type SmsSendParams, type SmsTemplate, type SmsTemplateList, type SmsTemplateListQuery, type UnmetGate, WebhookEventType, type WebhookEventTypeValue, type WebhookHeaders, type WebhookOptions, baseUrlForRegion, regionFromApiKey };
+export { type APIPromise, type Audience, type AudienceAddContactsParams, type AudienceContactsQuery, type AudienceCreateParams, type AudienceListQuery, type AudienceMember, type AudienceRemoveContactsParams, type AudienceUpdateParams, BirdAPIError, BirdAuthError, BirdBadRequestError, BirdBillingError, BirdClient, type BirdClientOptions, BirdConflictError, BirdConnectionError, BirdError, BirdInternalError, BirdMisdirectedError, BirdNotFoundError, BirdNotImplementedError, BirdPayloadTooLargeError, BirdPermissionError, BirdPreconditionError, BirdRateLimitError, type BirdRequest, type BirdResponse, BirdServiceUnavailableError, BirdTimeoutError, BirdValidationError, type BirdWebhookEvent, BirdWebhookVerificationError, type Contact, type ContactBatchParams, type ContactCreateParams, type ContactListQuery, type ContactProperty, type ContactPropertyCreateParams, type ContactPropertyListQuery, type ContactPropertyUpdateParams, type ContactUpdateParams, type ContactUpsertResult, type CursorPage, type EmailChannelDefaults, type EmailListQuery, type EmailMessage, type EmailSendBatchParams, type EmailSendBatchResult, type EmailSendParams, type ErrorDetail, type ErrorNextAction, type PaginatedPromise, type RequestOptions, type SafeResult, type SmsListQuery, type SmsMessage, type SmsSendBatchParams, type SmsSendBatchResult, type SmsSendParams, type SmsTemplate, type SmsTemplateList, type SmsTemplateListQuery, type UnmetGate, WebhookEventType, type WebhookEventTypeValue, type WebhookHeaders, type WebhookOptions, type WhatsAppEventList, type WhatsAppMessage, type WhatsAppTemplate, type WhatsAppTemplateList, type WhatsappListEventsQuery, type WhatsappListQuery, type WhatsappSendParams, baseUrlForRegion, regionFromApiKey };
 //# sourceMappingURL=index.d.mts.map