@messagebird/sdk 0.4.2 → 0.6.0

package/dist/index.d.mts

@@ -89,6 +89,17 @@ interface ErrorNextAction {
   /** Permission scope the recovery operation requires, when it is scoped. */
   scope?: string;
 }
+/** One verification requirement blocking the action, with the flow that resolves it. */
+interface UnmetGate {
+  /** Stable identifier for the verification requirement. */
+  slug: string;
+  /** Human-readable name of the verification requirement. */
+  name: string;
+  /** The requirement's current state. */
+  status: string;
+  /** How to resolve this requirement. */
+  remediation_kind: string;
+}
 /** Constructor fields shared by every API error, mapped from the wire body. */
 interface BirdAPIErrorFields {
   statusCode: number;
@@ -111,6 +122,8 @@ interface BirdAPIErrorFields {
   remediation?: string;
   /** Operations that resolve this error, in the order to try them (ADR-0073). */
   next?: ErrorNextAction[];
+  /** Verification requirements blocking this action, when it is blocked pending verification. */
+  unmetGates?: UnmetGate[];
 }
 /** The server returned an error body. Base for every `type`-specific class. */
 declare class BirdAPIError extends BirdError {
@@ -124,6 +137,7 @@ declare class BirdAPIError extends BirdError {
   readonly vendorCode?: string;
   readonly remediation?: string;
   readonly next?: ErrorNextAction[];
+  readonly unmetGates?: UnmetGate[];
   constructor(fields: BirdAPIErrorFields);
 }
 /** 401 — authentication failed or missing. */
@@ -265,10 +279,10 @@ type EventSmsUndeliveredData = EventSmsBase & {
   error: SmsError;
 };
 /**
- * Bird-stable failure reason. `invalid_destination` — the number is not assigned, ported out, or malformed. `unreachable` — handset off or out of coverage. `blocked_by_carrier` — the carrier filtered the message. `blocked_by_recipient` — the recipient device blocked the sender. `landline_unreachable` — the destination is a landline that does not accept SMS. `content_rejected` — the carrier rejected the content. `sender_unregistered` — the sender is not registered for the destination. `recipient_opted_out` — the recipient is on a suppression list. `provider_unavailable` — an upstream failure after retries. `unknown` — an unmapped failure.
+ * Bird-stable failure reason. `invalid_destination` — the number is not assigned, ported out, or malformed. `unreachable` — handset off or out of coverage. `blocked_by_carrier` — the carrier filtered the message. `blocked_by_recipient` — the recipient device blocked the sender. `landline_unreachable` — the destination is a landline that does not accept SMS. `content_rejected` — the carrier rejected the content. `sender_unregistered` — the sender is not registered for the destination. `recipient_opted_out` — the recipient is on a suppression list. `provider_unavailable` — an upstream failure after retries. `insufficient_balance` — the workspace wallet had insufficient balance to send the message. `unknown` — an unmapped failure.
  *
  */
-type SmsErrorCode = "invalid_destination" | "unreachable" | "blocked_by_carrier" | "blocked_by_recipient" | "landline_unreachable" | "content_rejected" | "sender_unregistered" | "recipient_opted_out" | "provider_unavailable" | "unknown";
+type SmsErrorCode = "invalid_destination" | "unreachable" | "blocked_by_carrier" | "blocked_by_recipient" | "landline_unreachable" | "content_rejected" | "sender_unregistered" | "recipient_opted_out" | "provider_unavailable" | "insufficient_balance" | "unknown";
 /**
  * Failure detail for a message that could not be delivered or was rejected. Null when there is no failure.
  */
@@ -605,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 = {
   /**
@@ -651,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.
    */
@@ -680,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 = {
   /**
@@ -1339,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";
@@ -1369,40 +1347,6 @@ type Timestamps = {
   readonly created_at: string;
   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.
- *
- */
-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;
-};
 /**
  * An email address with an optional display name.
  */
@@ -1416,260 +1360,285 @@ type EmailAddress = {
    */
   name?: string;
 };
-/**
- * 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 ContactId = string;
-type EmailTemplateVersionList = {
+type WhatsAppTemplateList = {
   /**
-   * All versions of the template, newest first.
+   * The templates available to your workspace.
    */
-  data: Array<EmailTemplateVersion>;
+  data: Array<WhatsAppTemplate>;
 };
-/**
- * A single variable slot a template fills in from the values supplied when sending. Shared across channels (SMS, email) so template introspection reads the same everywhere.
- *
- */
-type TemplateVariable = {
-  /**
-   * The parameters key this slot is filled with.
-   */
-  readonly key: string;
+type WhatsAppTemplateButton = {
   /**
-   * The value type this slot accepts. Open enum — treat any unrecognized value as a future type rather than an error. SMS templates use the typed slots (`code`, `amount`, …); email templates use `text`.
-   *
+   * The button's behavior type.
    */
   readonly type: string;
   /**
-   * Whether the slot must be supplied when sending. Advisory for email templates, where a missing value renders as empty rather than rejecting the send.
-   *
-   */
-  readonly required: boolean;
-  /**
-   * A human-readable description of the accepted values.
+   * The button's label text.
    */
-  readonly constraint: string;
-};
-type EmailTemplateId = string;
-type EmailTemplateVersionId = string;
-type EmailTemplateVersion = {
+  readonly text: string;
   /**
-   * Template version ID.
+   * The URL the button opens, with any variable placeholder shown inline. Present on link buttons.
    */
-  readonly id: EmailTemplateVersionId;
+  readonly url?: string;
   /**
-   * The template this version belongs to.
+   * Example values for this button's variables, in placeholder order. Present when the button URL has variables.
    */
-  readonly template_id: EmailTemplateId;
+  readonly example_parameters?: Array<WhatsAppTemplateExampleParameter>;
+};
+/**
+ * The type of a template parameter.
+ */
+type WhatsAppTemplateParameterType = string;
+type WhatsAppTemplateExampleParameter = {
   /**
-   * Sequential published-version number (1, 2, 3…). Null while the version is a draft.
+   * The kind of value this parameter accepts.
    */
-  readonly version_number?: number | null;
+  readonly type: WhatsAppTemplateParameterType;
   /**
-   * Lifecycle status of this version.
+   * An example value for a text parameter. Present when `type` is `text`.
    */
-  readonly status: "draft" | "published";
+  readonly text?: string;
+};
+type WhatsAppTemplateComponent = {
   /**
-   * The version's revision counter.
+   * The content block's type within the template.
    */
-  readonly revision: number;
+  readonly type: string;
   /**
-   * The variable slots this version's content fills in from the values you supply when sending.
+   * The block's text content, with any variable placeholders shown inline. Present when the block carries text.
    */
-  readonly variables: Array<TemplateVariable>;
+  readonly text?: string;
   /**
-   * When this version was created.
+   * 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 created_at: string;
+  readonly example_parameters?: Array<WhatsAppTemplateExampleParameter>;
   /**
-   * When this version was published, or null if it has not been published.
+   * The buttons attached to this block. Present when the block carries buttons.
    */
-  readonly published_at?: string | null;
+  readonly buttons?: Array<WhatsAppTemplateButton>;
 };
 /**
- * Partial update of a template's metadata and its draft content. Only the fields you send are changed; the rest are left as-is. Include the draft `revision` you last read so concurrent edits are detected.
+ * 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 EmailTemplateUpdate = {
+type TemplateName = string;
+type WhatsAppTemplate = {
   /**
-   * The draft revision you last read (from the template's `revision` field). A stale value returns a conflict so you can reload and retry.
-   *
+   * The template's stable handle. Pass it as the template reference when sending.
    */
-  revision: number;
+  readonly name: TemplateName;
+  scope: TemplateScope;
   /**
-   * New workspace-unique slug handle. Must stay unique within the workspace. Lowercase letters, numbers, and hyphens.
-   *
+   * The language code of this template variant (for example `en` or `pt_BR`).
    */
-  name?: string;
+  readonly language: string;
   /**
-   * New description of the template's purpose. Send null to clear it.
+   * Content classification applied to messages sent from this template.
    */
-  description?: string | null;
+  readonly category: WhatsAppTemplateCategory;
   /**
-   * New email subject line for the draft. Send null to clear it.
+   * The template's review and health status.
    */
-  subject?: string | null;
+  readonly status: WhatsAppTemplateStatus;
   /**
-   * New HTML body — the source markup for the template's format.
+   * The content blocks that make up the template, in display order.
    */
-  html?: string;
+  readonly components: Array<WhatsAppTemplateComponent>;
+};
+type WhatsAppEventList = {
   /**
-   * New plain-text body for the draft. Send null to clear it.
+   * Timeline events for this WhatsApp message, in chronological order. The timeline is bounded and returned in full — this list is not paginated.
    */
-  text?: string | null;
+  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;
   /**
-   * Brand kit to apply to the draft.
+   * Human-readable explanation of the failure.
    */
-  brand_kit_id?: BrandKitId;
-};
-type BrandKitId = string;
-type EmailTemplate = {
+  readonly description: string;
   /**
-   * Template ID.
+   * When the failure occurred.
    */
-  readonly id: EmailTemplateId;
+  readonly occurred_at: string;
+} | null;
+type WhatsAppEventId = string;
+type WhatsAppEvent = {
   /**
-   * Workspace that owns the template.
+   * Event ID.
    */
-  readonly workspace_id: WorkspaceId;
+  readonly id: WhatsAppEventId;
   /**
-   * The template's workspace-unique slug handle. Pass it (or the id) as the template reference when sending.
+   * 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.
+   *
    */
-  name: string;
+  readonly type: string;
   /**
-   * Optional description of the template's purpose. Null when unset.
+   * When this event occurred.
    */
-  description?: string | null;
-  scope: TemplateScope;
-  category: EmailTemplateCategory;
-  source: EmailTemplateSource;
+  readonly occurred_at: string;
   /**
-   * The variable slots this template's current draft fills in from the values you supply when sending.
+   * Failure detail. Present on `whatsapp.failed` events; null otherwise.
    */
-  readonly variables: Array<TemplateVariable>;
+  error: WhatsAppError;
+};
+type SendWhatsAppMessageRequest = {
   /**
-   * The current editable draft version.
+   * The message recipient's phone number in E.164 format (for example `+31612345678`).
    */
-  readonly draft_version_id: EmailTemplateVersionId;
+  to: string;
   /**
-   * The currently published version, or null if the template has never been published.
+   * 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.
+   *
    */
-  readonly published_version_id?: EmailTemplateVersionId | null;
+  template?: SendWhatsAppMessageTemplate;
+};
+type WhatsAppMessageTemplateComponentParameter = {
   /**
-   * The draft's revision counter. Send it back on the next update to detect concurrent edits.
+   * Parameter type.
    */
-  readonly revision: number;
+  type: WhatsAppTemplateParameterType;
   /**
-   * The draft's email subject line. Null when unset.
+   * Parameter value.
    */
-  subject?: string | null;
+  text: string;
+};
+type WhatsAppMessageTemplateComponent = {
   /**
-   * The draft's HTML body. Null when unset.
+   * Which part of the template this fills in.
    */
-  html?: string | null;
+  type: string;
   /**
-   * The draft's plain-text body. Null when unset.
+   * The values that fill this part's placeholders, in order.
    */
-  text?: string | null;
+  parameters?: Array<WhatsAppMessageTemplateComponentParameter>;
+};
+type SendWhatsAppMessageTemplate = {
   /**
-   * The brand kit applied to the draft, or null if none.
+   * The template to send, by its name (for example `bird_otp`).
    */
-  readonly brand_kit_id?: BrandKitId | null;
+  name: TemplateName;
   /**
-   * When the template was created.
+   * Language code of the template variant to send (for example `en` or `pt_BR`). May be omitted when the template has a single language.
+   *
    */
-  readonly created_at: string;
+  language?: string;
   /**
-   * When the template was last modified.
+   * The values that fill the template's placeholders.
    */
-  readonly updated_at: string;
+  components?: Array<WhatsAppMessageTemplateComponent>;
 };
 /**
- * The authoring format the template is written in. Fixed at creation.
- */
-type EmailTemplateSource = "liquid" | "handlebars" | "html";
-/**
- * Whether the template is transactional or marketing email.
- */
-type EmailTemplateCategory = "transactional" | "marketing";
-/**
- * Whether the template is a built-in Bird template (`system`) or one your workspace authored (`workspace`).
+ * 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 TemplateScope = "system" | "workspace";
+type WhatsAppMessageStatus = "scheduled" | "accepted" | "sent" | "delivered" | "failed" | "canceled" | "received";
 /**
- * Parameters for creating an email template and its initial draft.
+ * 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 EmailTemplateCreate = {
+type WhatsAppMessageTemplate = {
   /**
-   * The template's workspace-unique slug handle — a stable alternative to the template ID when sending by template. Lowercase letters, numbers, and hyphens.
-   *
+   * The template's stable handle (for example `bird_otp`).
    */
-  name: string;
+  readonly name: TemplateName;
   /**
-   * Optional description of the template's purpose.
+   * Content classification applied to messages sent from this template.
    */
-  description?: string;
-  category: EmailTemplateCategory;
+  readonly category: WhatsAppTemplateCategory;
+  /**
+   * The language code of the template variant that was sent (for example `en`).
+   */
+  readonly language: string;
   /**
-   * The authoring format the template is written in, fixed at creation. `liquid` currently supports variable substitution only (e.g. `{{ first_name }}`); filters, tags, and control flow are not yet supported — fuller Liquid support is coming soon.
+   * The values that filled the template's placeholders. Empty for an authentication template, whose content is never returned.
    *
    */
-  source: EmailTemplateSource;
+  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 = {
   /**
-   * The email subject line for the initial draft.
+   * Contact's phone number in E.164 format, when known.
    */
-  subject?: string;
+  readonly phone_number?: string;
   /**
-   * The HTML body — the source markup for the chosen format.
+   * Business-scoped user ID (Meta's WhatsApp identifier for this contact within the business account), when available.
    */
-  html?: string;
+  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 = {
   /**
-   * The optional plain-text body.
+   * E.164 phone number of the WhatsApp business account that sent the message.
    */
-  text?: string;
+  readonly phone_number?: string;
   /**
-   * Optional brand kit to apply to the draft.
+   * The WhatsApp phone number identifier. Present only for account-owned numbers.
    */
-  brand_kit_id?: BrandKitId;
+  readonly phone_number_id?: string;
 };
-type EmailTemplateSummary = {
+type WhatsAppMessageId = string;
+type WhatsAppMessage = {
   /**
-   * Template ID.
+   * Message ID.
    */
-  readonly id: EmailTemplateId;
+  readonly id: WhatsAppMessageId;
   /**
-   * Workspace that owns the template.
+   * Whether the message was sent by the business (`outbound`) or received from the contact (`inbound`).
    */
-  readonly workspace_id: WorkspaceId;
+  readonly direction: "outbound" | "inbound";
+  readonly business: WhatsAppMessageBusiness;
+  readonly contact: WhatsAppMessageContact;
   /**
-   * The template's workspace-unique slug handle. Pass it (or the id) as the template reference when sending.
+   * The template the message was sent from. For authentication templates the filled-in values are not returned.
    */
-  name: string;
+  readonly template?: WhatsAppMessageTemplate;
+  readonly status: WhatsAppMessageStatus;
   /**
-   * Optional description of the template's purpose. Null when unset.
+   * Failure detail for a message that did not reach the recipient. Null when there is no failure.
    */
-  description?: string | null;
-  scope: TemplateScope;
-  category: EmailTemplateCategory;
-  source: EmailTemplateSource;
+  last_error?: WhatsAppError;
   /**
-   * The current editable draft version.
+   * When the message was accepted for delivery.
    */
-  readonly draft_version_id: EmailTemplateVersionId;
+  readonly created_at: string;
   /**
-   * The currently published version, or null if never published.
+   * When the message was handed to the WhatsApp network. Null until then.
    */
-  readonly published_version_id?: EmailTemplateVersionId | null;
+  readonly sent_at?: string | null;
   /**
-   * When the template was created.
+   * When delivery was confirmed. Null until then.
    */
-  readonly created_at: string;
+  readonly delivered_at?: string | null;
   /**
-   * When the template was last modified.
+   * When the message was read by the recipient. Null until then.
    */
-  readonly updated_at: string;
+  readonly read_at?: string | null;
 };
 type SmsTemplateList = {
   /**
@@ -1678,6 +1647,30 @@ type SmsTemplateList = {
   data: Array<SmsTemplate>;
 };
 type SmsTemplateVersionId = string;
+/**
+ * A single variable slot a template fills in from the values supplied when sending. Shared across channels (SMS, email) so template introspection reads the same everywhere.
+ *
+ */
+type TemplateVariable = {
+  /**
+   * The parameters key this slot is filled with.
+   */
+  readonly key: string;
+  /**
+   * The value type this slot accepts. Open enum — treat any unrecognized value as a future type rather than an error. SMS templates use the typed slots (`code`, `amount`, …); email templates use `text`.
+   *
+   */
+  readonly type: string;
+  /**
+   * Whether the slot must be supplied when sending. Advisory for email templates, where a missing value renders as empty rather than rejecting the send.
+   *
+   */
+  readonly required: boolean;
+  /**
+   * A human-readable description of the accepted values.
+   */
+  readonly constraint: string;
+};
 /**
  * Content classification. Drives opt-out (STOP) policy, quiet-hours, and per-country compliance.
  */
@@ -1691,7 +1684,7 @@ type SmsTemplate = {
   /**
    * The template's stable handle. Pass it (or the id) as the template reference when sending.
    */
-  readonly name: string;
+  readonly name: TemplateName;
   /**
    * Human-readable description of what the template is for.
    */
@@ -1908,7 +1901,7 @@ type SmsTemplateSend = unknown & {
    * The template to send, by its name handle (for example `bird_otp_verification`). Browse the available templates and their variables with the templates endpoint.
    *
    */
-  name?: string;
+  name?: TemplateName;
   /**
    * Language tag (BCP 47, for example `fr` or `pt-BR`) selecting the localized body. Falls back to the closest available language, then English, when the exact tag is not stocked. Omit for English.
    *
@@ -2017,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.
@@ -2084,26 +2078,6 @@ type AudienceCreateRequest = {
    */
   type?: "static" | "dynamic" | "external";
 };
-type AudienceId = string;
-type Audience = {
-  /**
-   * Audience ID.
-   */
-  readonly id: AudienceId;
-  /**
-   * Display name for the audience.
-   */
-  name: string;
-  /**
-   * Longer description of who this audience is.
-   */
-  description?: string | null;
-  /**
-   * How the audience's recipients are determined. `static` audiences have an explicit member list you manage via the API. `dynamic` and `external` are preview values and currently unavailable — creating an audience with either returns an error.
-   *
-   */
-  type: "static" | "dynamic" | "external";
-} & Timestamps;
 type ContactPropertyUpdateRequest = {
   /**
    * Default used when a contact has no value for this property and the template does not supply an inline fallback. A string, number, or boolean matching the declared type (strings up to 500 characters). Set to null to remove the fallback.
@@ -2147,6 +2121,26 @@ type ContactProperty = {
    */
   readonly archived?: boolean;
 } & Timestamps;
+type AudienceId = string;
+type Audience = {
+  /**
+   * Audience ID.
+   */
+  readonly id: AudienceId;
+  /**
+   * Display name for the audience.
+   */
+  name: string;
+  /**
+   * Longer description of who this audience is.
+   */
+  description?: string | null;
+  /**
+   * How the audience's recipients are determined. `static` audiences have an explicit member list you manage via the API. `dynamic` and `external` are preview values and currently unavailable — creating an audience with either returns an error.
+   *
+   */
+  type: "static" | "dynamic" | "external";
+} & Timestamps;
 type ContactUpdateRequest = {
   /**
    * New email address for the contact. Trimmed and lowercased before it is stored and checked for uniqueness. Must not be in use by another contact in the workspace.
@@ -2271,6 +2265,41 @@ 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 & {
   /**
    * The template to send, by its id.
@@ -2279,7 +2308,7 @@ type EmailTemplateSend = unknown & {
   /**
    * The template to send, by its name handle (for example `welcome-email`).
    */
-  name?: string;
+  name?: TemplateName;
   /**
    * Values for the template's variables, keyed by variable name. A token with no matching value renders empty. Cap: 16 KB serialized.
    *
@@ -2288,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.
@@ -2381,7 +2415,8 @@ type EmailMessageSendRequest = {
    */
   attachments?: Array<EmailAttachment>;
   /**
-   * Preview feature — send-later scheduling. Currently unavailable; supplying this field returns `422 unsupported_feature`.
+   * Schedule the message to send at a future time instead of immediately. Must be at least 30 seconds and at most 30 days ahead — outside that range the request is rejected with `422`. The message returns with status `accepted` and shows as `scheduled` on reads until it sends; cancel it before then with the message cancel endpoint. Scheduled sends count against your plan's monthly scheduled-email allowance; exceeding it is rejected with a `422`.
+   *
    */
   scheduled_at?: string;
   /**
@@ -2669,6 +2704,10 @@ type ListAudiencesData = {
   body?: never;
   path?: never;
   query?: {
+    /**
+     * Case-insensitive substring match against the audience's name.
+     */
+    search?: string;
     /**
      * Maximum number of items to return per page.
      */
@@ -2785,22 +2824,10 @@ type ListSmsTemplatesData = {
   };
   url: "/v1/sms/templates";
 };
-type ListEmailTemplatesData = {
+type ListWhatsAppMessagesData = {
   body?: never;
   path?: never;
   query?: {
-    /**
-     * Filter by template category.
-     */
-    category?: EmailTemplateCategory;
-    /**
-     * Filter by authoring format.
-     */
-    source?: EmailTemplateSource;
-    /**
-     * Case-insensitive search matching the template's name or description (substring).
-     */
-    name?: string;
     /**
      * Maximum number of items to return per page.
      */
@@ -2813,8 +2840,44 @@ type ListEmailTemplatesData = {
      * 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/email/templates";
+  url: "/v1/whatsapp/messages/{message_id}/events";
 };
 //#endregion
 //#region src/generated/core/auth.gen.d.ts
@@ -3269,6 +3332,16 @@ declare class EmailResource<D extends EmailChannelDefaults | undefined = undefin
    * msg.bounced_count;
    */
   get(messageId: string, options?: RequestOptions): APIPromise<EmailMessage>;
+  /**
+   * Cancel a message scheduled with `scheduled_at` before it sends. Only a
+   * message that is still scheduled can be canceled; one that already started
+   * sending — or was previously canceled — rejects with a conflict error.
+   * Canceling does not return consumed scheduled-send quota.
+   *
+   * @example
+   * await bird.email.cancel("em_abc123");
+   */
+  cancel(messageId: string, options?: RequestOptions): APIPromise<void>;
   /**
    * List messages, newest first. `await` resolves the first page; `for await`
    * walks every message across all pages.
@@ -3499,109 +3572,6 @@ declare class ContactsResource extends Resource {
   batch(params: ContactBatchParams, options?: RequestOptions): APIPromise<ContactUpsertResult>;
 }
 //#endregion
-//#region src/resources/emailTemplates.d.ts
-/** Body for `bird.emailTemplates.create`. */
-type EmailTemplateCreateParams = EmailTemplateCreate;
-/** Body for `bird.emailTemplates.update` — a partial patch of the draft. */
-type EmailTemplateUpdateParams = EmailTemplateUpdate;
-/** Filters and cursor params for `bird.emailTemplates.list`. */
-type EmailTemplateListQuery = NonNullable<ListEmailTemplatesData["query"]>;
-declare class EmailTemplatesResource extends Resource {
-  /**
-   * Create a template and its initial editable draft. Pick the authoring format
-   * with `source` (`liquid`, `handlebars`, or `html`); the name must be unique
-   * in the workspace or the call throws a `BirdConflictError`.
-   *
-   * @example Create a template
-   * const tpl = await bird.emailTemplates.create({
-   *   name: "welcome-email",
-   *   description: "Welcome",
-   *   category: "transactional",
-   *   source: "handlebars",
-   *   subject: "Welcome, {{ first_name }}!",
-   *   html: "<h1>Hi {{ first_name }}</h1>",
-   * });
-   * console.log(tpl.id, tpl.revision); // "emt_…", 0
-   */
-  create(params: EmailTemplateCreateParams, options?: RequestOptions): APIPromise<EmailTemplate>;
-  /**
-   * List the workspace's templates, newest first. `await` resolves the first
-   * page; `for await` walks every template across all pages. Filter by
-   * `category`, `source`, or a case-insensitive `name` prefix.
-   *
-   * @example Iterate every template, or take one page
-   * for await (const tpl of bird.emailTemplates.list({ category: "transactional" })) {
-   *   console.log(tpl.id, tpl.name);
-   * }
-   * const page = await bird.emailTemplates.list({ limit: 50 }); // page.data, page.next_cursor
-   */
-  list(query?: EmailTemplateListQuery, options?: RequestOptions): PaginatedPromise<EmailTemplateSummary>;
-  /**
-   * Fetch a template with its current draft content (subject, HTML, text), the
-   * draft `revision`, and its draft/published version ids.
-   *
-   * @example
-   * const tpl = await bird.emailTemplates.get("emt_abc123");
-   * tpl.subject;
-   * tpl.published_version_id; // null until first publish
-   */
-  get(templateId: string, options?: RequestOptions): APIPromise<EmailTemplate>;
-  /**
-   * Update a template's metadata and draft content. Only the fields you send
-   * change. Pass the draft `revision` you last read; if another edit landed
-   * first the call throws a `BirdConflictError` — reload and retry.
-   *
-   * @example Edit the draft, guarded by the revision you read
-   * const tpl = await bird.emailTemplates.get("emt_abc123");
-   * const updated = await bird.emailTemplates.update("emt_abc123", {
-   *   revision: tpl.revision,
-   *   subject: "Welcome aboard, {{ first_name }}!",
-   * });
-   */
-  update(templateId: string, params: EmailTemplateUpdateParams, options?: RequestOptions): APIPromise<EmailTemplate>;
-  /**
-   * Delete a template and all its versions. The name becomes available for
-   * reuse in the workspace.
-   *
-   * @example
-   * await bird.emailTemplates.delete("emt_abc123");
-   */
-  delete(templateId: string, options?: RequestOptions): APIPromise<void>;
-  /**
-   * Publish the current draft as a new immutable, numbered version and make it
-   * the live version used by sends. The draft stays editable. The draft must
-   * have a subject and a body, or the call throws.
-   *
-   * @example Publish, then send by template
-   * const version = await bird.emailTemplates.publish("emt_abc123");
-   * console.log(version.version_number); // 1, 2, 3…
-   * await bird.email.send({
-   *   from: "hello@acme.com",
-   *   to: ["alice@example.com"],
-   *   template: { id: "emt_abc123", parameters: { first_name: "Alice" } },
-   * });
-   */
-  publish(templateId: string, options?: RequestOptions): APIPromise<EmailTemplateVersion>;
-  /**
-   * List every version of a template — the current draft plus all published
-   * versions — newest first. Returns the full set in one response (`.data`);
-   * this list is not paginated.
-   *
-   * @example
-   * const { data } = await bird.emailTemplates.listVersions("emt_abc123");
-   * for (const v of data) console.log(v.version_number, v.status);
-   */
-  listVersions(templateId: string, options?: RequestOptions): APIPromise<EmailTemplateVersionList>;
-  /**
-   * Fetch a single version of a template.
-   *
-   * @example
-   * const version = await bird.emailTemplates.getVersion("emt_abc123", "emv_def456");
-   * version.status; // "draft" | "published"
-   */
-  getVersion(templateId: string, versionId: string, options?: RequestOptions): APIPromise<EmailTemplateVersion>;
-}
-//#endregion
 //#region src/resources/sms.d.ts
 /** Body for `bird.sms.send` — supply either `text` (with `category`) or `template`. */
 type SmsSendParams = SmsMessageSendRequest;
@@ -3691,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;
@@ -3820,12 +3863,14 @@ declare class BirdClient<const O extends BirdClientOptions = BirdClientOptions>
   protected readonly core: BirdHTTPClient;
   /** The email channel — `bird.email.send(...)`, `.get(...)`, `.list(...)`. */
   readonly email: EmailResource<EmailDefaultsOf<O>>;
-  /** Email templates — `bird.emailTemplates.create(...)`, `.list(...)`, `.publish(...)`, … */
-  readonly emailTemplates: EmailTemplatesResource;
   /** The SMS channel — `bird.sms.send(...)`, `.get(...)`, `.list(...)`. */
   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(...)`, … */
@@ -3876,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";
@@ -3900,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 EmailTemplate, type EmailTemplateCreateParams, type EmailTemplateListQuery, type EmailTemplateSummary, type EmailTemplateUpdateParams, type EmailTemplateVersion, 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, 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