@messagebird/sdk 0.5.0 → 0.7.0

package/dist/index.d.mts

@@ -503,8 +503,30 @@ type EventSmsAccepted = {
   timestamp: string;
   data: EventSmsAcceptedData;
 };
+type SuppressionId = string;
 /**
- * An email address was added to the workspace's suppression list (manually, via complaint, or via hard bounce). Payload schema not yet finalized.
+ * Payload of the email_suppression.created event.
+ */
+type EventEmailSuppressionCreatedData = {
+  /**
+   * The suppression entry that was created.
+   */
+  suppression_id: SuppressionId;
+  /**
+   * The recipient address that was added to the suppression list.
+   */
+  email: string;
+  /**
+   * Why the address was suppressed.
+   */
+  reason: "hard_bounce" | "complaint" | "unsubscribe" | "manual";
+  /**
+   * The workspace the suppression belongs to.
+   */
+  workspace_id: WorkspaceId;
+};
+/**
+ * An email address was added to the workspace's suppression list (manually, via complaint, or via hard bounce).
  */
 type EventEmailSuppressionCreated = {
   /**
@@ -515,12 +537,7 @@ type EventEmailSuppressionCreated = {
    * When the event occurred.
    */
   timestamp: string;
-  /**
-   * Event payload. The fields for this event are not yet finalized.
-   */
-  data: {
-    [key: string]: never;
-  };
+  data: EventEmailSuppressionCreatedData;
 };
 /**
  * Payload of the email_mailbox.thread_created event.
@@ -619,22 +636,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 +667,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 +692,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 = {
   /**
@@ -1269,7 +1254,25 @@ type EventEmailAccepted = {
   data: EventEmailAcceptedData;
 };
 /**
- * A sending domain completed DNS verification successfully. Payload schema not yet finalized.
+ * Payload of the domain.verified event.
+ */
+type EventDomainVerifiedData = {
+  /**
+   * The sending domain resource that verified.
+   */
+  domain_id: DomainId;
+  /**
+   * The sending domain hostname.
+   */
+  domain: string;
+  /**
+   * The workspace the domain is assigned to.
+   */
+  workspace_id: WorkspaceId;
+};
+type DomainId = string;
+/**
+ * A sending domain completed DNS verification successfully.
  */
 type EventDomainVerified = {
   /**
@@ -1280,15 +1283,31 @@ type EventDomainVerified = {
    * When the event occurred.
    */
   timestamp: string;
+  data: EventDomainVerifiedData;
+};
+/**
+ * Payload of the domain.failed event.
+ */
+type EventDomainFailedData = {
   /**
-   * Event payload. The fields for this event are not yet finalized.
+   * The sending domain resource whose verification failed.
    */
-  data: {
-    [key: string]: never;
-  };
+  domain_id: DomainId;
+  /**
+   * The sending domain hostname.
+   */
+  domain: string;
+  /**
+   * The workspace the domain is assigned to.
+   */
+  workspace_id: WorkspaceId;
+  /**
+   * Why verification failed, when a specific reason is available (for example, the DKIM record was not found at the expected selector).
+   */
+  failure_reason?: string | null;
 };
 /**
- * A sending domain failed DNS verification. Payload schema not yet finalized.
+ * A sending domain failed DNS verification.
  */
 type EventDomainFailed = {
   /**
@@ -1299,12 +1318,7 @@ type EventDomainFailed = {
    * When the event occurred.
    */
   timestamp: string;
-  /**
-   * Event payload. The fields for this event are not yet finalized.
-   */
-  data: {
-    [key: string]: never;
-  };
+  data: EventDomainFailedData;
 };
 /**
  * Discriminated union of every webhook event the Bird platform emits.
@@ -1353,10 +1367,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,67 +1394,420 @@ 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 EmailAddress = {
+  /**
+   * Email address.
+   */
+  email: string;
+  /**
+   * Display name shown alongside the address in mail clients.
+   */
+  name?: string;
+};
+type WhatsAppTemplateList = {
+  /**
+   * The templates available to your workspace.
+   */
+  data: Array<WhatsAppTemplate>;
+};
+type WhatsAppTemplateButton = {
+  /**
+   * The button's behavior type.
+   */
+  readonly type: string;
+  /**
+   * The button's label text.
+   */
+  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>;
+};
+/**
+ * The type of a template parameter.
+ */
+type WhatsAppTemplateParameterType = string;
+type WhatsAppTemplateExampleParameter = {
+  /**
+   * The kind of value this parameter accepts.
+   */
+  readonly type: WhatsAppTemplateParameterType;
+  /**
+   * An example value for a text parameter. Present when `type` is `text`.
+   */
+  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 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 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`).
+ */
+type TemplateScope = "system" | "workspace";
+/**
+ * A template's send-by handle — the stable reference used in place of the template id when sending. Lowercase letters, numbers, hyphens, and underscores; starts and ends with a letter or number.
  *
  */
-type EmailAttachment = {
+type TemplateName = string;
+type WhatsAppTemplate = {
   /**
-   * Filename shown to the recipient. Required.
+   * The template's stable handle. Pass it as the template reference when sending.
    */
-  filename: string;
+  readonly name: TemplateName;
+  scope: TemplateScope;
   /**
-   * Base64-encoded attachment bytes. Required. Counts toward the 20 MB estimated generated message-size cap after encoding and MIME wrapping.
+   * 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.
    *
    */
-  content: string;
+  readonly type: 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.
+   * 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.
    *
    */
-  path?: string;
+  template?: SendWhatsAppMessageTemplate;
   /**
-   * MIME type. Inferred from `filename` extension when omitted. Used to enforce the blocklist of disallowed executable / script types.
+   * Structured `{name, value}` labels for filtering. Tags become first-class query dimensions: filter the list endpoint by tag name. Maximum 20 tags per send. Use tags for low-cardinality dimensions (`category`, `experiment_variant`). For arbitrary structured context you do not need as a filter dimension, use `metadata` instead.
    *
    */
-  content_type?: string;
+  tags?: Array<Tag>;
   /**
-   * 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.
+   * Arbitrary JSON object stored on the message and returned on API reads. Maximum 2 KB serialized. Use metadata for per-send context like internal IDs and foreign keys. For low-cardinality filterable labels, use `tags` instead.
    *
    */
-  content_id?: string;
+  metadata?: {
+    [key: string]: unknown;
+  };
+};
+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>;
 };
 /**
- * An email address with an optional display name.
+ * 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 EmailAddress = {
+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 = {
   /**
-   * Email address.
+   * The template's stable handle (for example `bird_otp`).
    */
-  email: string;
+  readonly name: TemplateName;
   /**
-   * Display name shown alongside the address in mail clients.
+   * Content classification applied to messages sent from this template.
    */
-  name?: string;
+  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>;
 };
 /**
- * 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.
+ * 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 EmailAddressInput = string | EmailAddress;
-type ContactId = string;
+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;
+  /**
+   * Structured `{name, value}` filter labels applied to this message.
+   */
+  tags?: Array<Tag>;
+  /**
+   * Arbitrary JSON metadata stored on the message.
+   */
+  metadata?: {
+    [key: string]: unknown;
+  };
+};
+type VerificationCheckResult = {
+  /**
+   * Whether the submitted passcode verified this verification. true means the passcode was correct and the verification is now complete; false means it was not verified — see reason. A verification that has already reached a final state is no longer checkable and returns 404.
+   */
+  readonly success: boolean;
+  /**
+   * Why the check did not succeed, or null when success is true. incorrect_code means the passcode was wrong and attempts remain; expired means the time window elapsed; attempts_exhausted means too many incorrect attempts. Open enum — treat any unrecognized value as a future reason.
+   */
+  readonly reason?: string | null;
+  verification: Verification;
+  /**
+   * The number of check attempts left, or null once the verification is complete.
+   */
+  readonly attempts_remaining?: number | null;
+};
 /**
- * Whether the template is a built-in Bird template (`system`) or one your workspace authored (`workspace`).
+ * The channel a passcode is delivered over. Open enum — new channels may be added over time, so treat any unrecognized value as a future channel rather than an error.
  */
-type TemplateScope = "system" | "workspace";
+type VerificationChannel = string;
+type VerificationChannelEntry = {
+  channel: VerificationChannel;
+};
 /**
- * A template's send-by handle — the stable reference used in place of the template id when sending. Lowercase letters, numbers, hyphens, and underscores; starts and ends with a letter or number.
- *
+ * The recipient to verify. Provide an email_address, a phone_number, or both; at least one is required.
  */
-type TemplateName = string;
+type VerificationTo = {
+  /**
+   * The recipient's email address.
+   */
+  email_address?: string;
+  /**
+   * The recipient's phone number in E.164 format.
+   */
+  phone_number?: string;
+};
+type VerificationId = string;
+type Verification = {
+  readonly id: VerificationId;
+  /**
+   * The verification's current state: pending (awaiting a valid passcode), verified, failed (too many incorrect attempts), or expired (the time window elapsed before a correct passcode).
+   */
+  readonly status: "pending" | "verified" | "failed" | "expired" | "canceled" | "blocked";
+  /**
+   * Why the verification reached its final state, or null while pending or once verified. Open enum — treat any unrecognized value as a future reason.
+   */
+  readonly reason?: string | null;
+  readonly to: VerificationTo;
+  /**
+   * The ordered channels this verification uses to deliver the passcode. An email recipient is verified over email; a phone recipient is verified over SMS.
+   */
+  readonly channels: Array<VerificationChannelEntry>;
+  /**
+   * The channel the most recent passcode was sent on, or null before the first send. Open enum — new channels may be added over time, so treat any unrecognized value as a future channel rather than an error.
+   */
+  readonly last_channel?: string | null;
+  /**
+   * The key/value pairs attached when the verification was created.
+   */
+  readonly metadata?: {
+    [key: string]: unknown;
+  };
+  /**
+   * When the verification expires if no correct passcode is submitted.
+   */
+  readonly expires_at: string;
+  /**
+   * When the verification was completed, or null if it is not yet verified.
+   */
+  readonly verified_at?: string | null;
+} & Timestamps;
+type VerificationCheckRequest = {
+  to: VerificationTo;
+  /**
+   * The passcode the recipient received.
+   */
+  code: string;
+};
+type VerificationCreateRequest = {
+  to: VerificationTo;
+  options?: VerificationOptions;
+  /**
+   * Optional key/value pairs to attach to the verification, for example a correlation id. Returned on the verification.
+   */
+  metadata?: {
+    [key: string]: unknown;
+  };
+};
+/**
+ * Per-request overrides applied to this verification only.
+ */
+type VerificationOptions = {
+  /**
+   * Passcode length for this verification, overriding the configured length.
+   */
+  code_length?: number;
+  /**
+   * Reorder or narrow the delivery channels for this request. List channel names in the order to try them; a channel you omit is not used for this request, and a channel not already enabled for the recipient is ignored. Omit the field to use the configured order.
+   */
+  channels?: Array<VerificationChannel>;
+};
 type SmsTemplateList = {
   /**
    * The templates available to your workspace. The catalogue is small and returned in full — this list is not paginated.
@@ -1815,6 +2178,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 +2433,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 & {
   /**
@@ -2076,7 +2474,7 @@ type EmailTemplateSend = unknown & {
    */
   id?: EmailTemplateId;
   /**
-   * The template to send, by its name handle (for example `welcome-email`).
+   * The template to send, by its name handle — a workspace template (for example `welcome-email`) or a built-in `system` template (for example `bird_welcome`).
    */
   name?: TemplateName;
   /**
@@ -2087,6 +2485,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.
@@ -2394,7 +2797,7 @@ type ListEmailMessagesData = {
      */
     status?: "scheduled" | "accepted" | "processed" | "deferred" | "delivered" | "partial_failure" | "bounced" | "complained" | "rejected" | "canceled";
     /**
-     * Filter by tag. Accepts `name` to match any send carrying that tag name, or `name:value` to match a specific tag pair (e.g. `category:welcome`). Repeat the parameter to AND-combine several tag filters.
+     * Filter by tag. Accepts `name` to match any message carrying that tag name, or `name:value` to match a specific tag pair (e.g. `category:welcome`). Repeat the parameter to AND-combine several tag filters.
      *
      */
     tag?: Array<string>;
@@ -2563,7 +2966,7 @@ type ListSmsMessagesData = {
      */
     from?: string;
     /**
-     * Filter by tag. Accepts `name` to match any message carrying that tag name, or `name:value` to match a specific tag pair. Repeat the parameter to AND-combine several tag filters.
+     * Filter by tag. Accepts `name` to match any message carrying that tag name, or `name:value` to match a specific tag pair (e.g. `category:welcome`). Repeat the parameter to AND-combine several tag filters.
      *
      */
     tag?: Array<string>;
@@ -2589,6 +2992,66 @@ 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;
+    /**
+     * Filter by tag. Accepts `name` to match any message carrying that tag name, or `name:value` to match a specific tag pair (e.g. `category:welcome`). Repeat the parameter to AND-combine several tag filters.
+     *
+     */
+    tag?: Array<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 +3834,119 @@ 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/verify.d.ts
+/** Body for `bird.verify.verifications.create` — a recipient in `to`, plus optional `options`/`metadata`. */
+type VerificationCreateParams = VerificationCreateRequest;
+/** Body for `bird.verify.verifications.check` — the recipient in `to` and the submitted `code`. */
+type VerificationCheckParams = VerificationCheckRequest;
+declare class VerificationsResource extends Resource {
+  /**
+   * Start a verification and send a one-time passcode to the recipient in `to`
+   * (a `phone_number` over SMS, an `email_address` over email, or both). Calling
+   * again for the same recipient re-sends the code after the cooldown rather than
+   * starting a second verification. The passcode is never returned — submit the
+   * recipient's entry with `check`.
+   *
+   * @example Start over SMS
+   * const verification = await bird.verify.verifications.create({
+   *   to: { phone_number: "+15551234567" },
+   * });
+   * console.log(verification.id, verification.status);
+   */
+  create(params: VerificationCreateParams, options?: RequestOptions): APIPromise<Verification>;
+  /**
+   * Check a passcode the recipient submitted. Identify the verification by the same
+   * `to` recipient used to start it — no id needed. A wrong, expired, or already-used
+   * code resolves with `success: false` and a `reason`, not an error.
+   *
+   * @example
+   * const result = await bird.verify.verifications.check({
+   *   to: { phone_number: "+15551234567" },
+   *   code: "123456",
+   * });
+   * console.log(result.success);
+   */
+  check(params: VerificationCheckParams, options?: RequestOptions): APIPromise<VerificationCheckResult>;
+}
+/** The Verify product namespace — holds the `verifications` collection. */
+declare class VerifyResource {
+  readonly verifications: VerificationsResource;
+  constructor(...args: ConstructorParameters<typeof Resource>);
+}
+//#endregion
 //#region src/resources/webhooks.d.ts
 /** A verified webhook event — discriminated on `type` (ADR-0028 wire contract). */
 type BirdWebhookEvent = WebhookEvent;
@@ -3504,6 +4080,12 @@ 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;
+  /** The Verify product — `bird.verify.verifications.create(...)`, `.check(...)`. */
+  readonly verify: VerifyResource;
   /** Contacts — `bird.contacts.create(...)`, `.list(...)`, `.get(...)`, `.batch(...)`, … */
   readonly contacts: ContactsResource;
   /** Audiences — `bird.audiences.create(...)`, `.list(...)`, `.addContacts(...)`, … */
@@ -3554,8 +4136,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 +4158,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, type Verification, type VerificationCheckParams, type VerificationCheckResult, type VerificationCreateParams, 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