@messagebird/sdk 0.10.1 → 0.12.0

package/dist/index.d.mts

@@ -481,7 +481,7 @@ type EventWhatsAppAccepted = {
   data: EventWhatsAppAcceptedData;
 };
 /**
- * Payload of the voice.call.initiated event.
+ * Payload of the voice_call.initiated event.
  */
 type EventVoiceCallInitiatedData = EventVoiceBase;
 /**
@@ -523,7 +523,7 @@ type EventVoiceCallInitiated = {
   /**
    * Event type.
    */
-  type: "voice.call.initiated";
+  type: "voice_call.initiated";
   /**
    * Time the call was initiated.
    */
@@ -536,7 +536,7 @@ type EventVoiceCallInitiated = {
  */
 type VoiceCallStatus = "answered" | "no_answer" | "busy" | "canceled" | "failed" | "rejected" | "unknown" | "ringing" | "in_progress";
 /**
- * Payload of the voice.call.ended event.
+ * Payload of the voice_call.ended event.
  */
 type EventVoiceCallEndedData = EventVoiceBase & {
   status: VoiceCallStatus;
@@ -560,7 +560,7 @@ type EventVoiceCallEnded = {
   /**
    * Event type.
    */
-  type: "voice.call.ended";
+  type: "voice_call.ended";
   /**
    * When the call ended (BYE or final non-2xx response).
    */
@@ -568,7 +568,7 @@ type EventVoiceCallEnded = {
   data: EventVoiceCallEndedData;
 };
 /**
- * Payload of the voice.call.answered event.
+ * Payload of the voice_call.answered event.
  */
 type EventVoiceCallAnsweredData = EventVoiceBase;
 /**
@@ -578,7 +578,7 @@ type EventVoiceCallAnswered = {
   /**
    * Event type.
    */
-  type: "voice.call.answered";
+  type: "voice_call.answered";
   /**
    * Time the call was answered.
    */
@@ -1818,11 +1818,11 @@ type WebhookEvent = ({
 } & EventSmsTfnVerificationSubmitted) | ({
   type: "sms.undelivered";
 } & EventSmsUndelivered) | ({
-  type: "voice.call.answered";
+  type: "voice_call.answered";
 } & EventVoiceCallAnswered) | ({
-  type: "voice.call.ended";
+  type: "voice_call.ended";
 } & EventVoiceCallEnded) | ({
-  type: "voice.call.initiated";
+  type: "voice_call.initiated";
 } & EventVoiceCallInitiated) | ({
   type: "whatsapp.accepted";
 } & EventWhatsAppAccepted) | ({
@@ -1840,18 +1840,968 @@ type Timestamps = {
   readonly created_at: string;
   readonly updated_at: string;
 };
+type ListEnvelope = {
+  /**
+   * Cursor for the next page. Pass back as `starting_after` to advance forward. Null when no next page exists.
+   */
+  next_cursor: string | null;
+  /**
+   * Cursor for the previous page. Pass back as `ending_before` to step backward. Null when no previous page exists.
+   */
+  prev_cursor: string | null;
+  /**
+   * Refresh anchor. Pass back as `ending_before` later to fetch items that have appeared since this response. Non-null whenever `data` is non-empty; null only on an empty page. Distinct from `prev_cursor`.
+   */
+  refresh_cursor: string | null;
+};
+/**
+ * The labels available in a mailbox.
+ */
+type EmailMailboxLabelList = {
+  data: Array<EmailMailboxLabel>;
+};
+/**
+ * One label available in a mailbox.
+ */
+type EmailMailboxLabel = {
+  /**
+   * The label name, as it appears on conversations and messages.
+   */
+  readonly name: string;
+  /**
+   * `system` labels are built in and carry state — the placements `inbox`, `archive`, `spam`, `blocked`, and `sent`, plus `trash` and `unread`. `custom` labels are the workspace's own tags.
+   */
+  readonly type: "system" | "custom";
+};
+/**
+ * A new message sent from a mailbox, starting a new conversation. Mirrors the plain send request minus `from` — the mailbox is the sender identity — and minus `scheduled_at` (mailbox sends are immediate). Bird mints the RFC 5322 Message-ID so replies thread back to this conversation. At least one of `html` or `text` must be provided.
+ *
+ */
+type EmailMailboxComposeRequest = {
+  /**
+   * Primary recipients. Each entry is a plain email string, an RFC 5322 mailbox string (`Jane <jane@example.com>`), or an object with an optional display name.
+   */
+  to: Array<EmailAddressInput>;
+  /**
+   * CC recipients. Each entry is a plain email string, an RFC 5322 mailbox string (`Jane <jane@example.com>`), or an object with an optional display name.
+   */
+  cc?: Array<EmailAddressInput>;
+  /**
+   * BCC recipients. Each entry is a plain email string, an RFC 5322 mailbox string (`Jane <jane@example.com>`), or an object with an optional display name.
+   */
+  bcc?: Array<EmailAddressInput>;
+  /**
+   * Message subject line.
+   */
+  subject: string;
+  /**
+   * HTML body. At least one of html or text must be provided.
+   */
+  html?: string;
+  /**
+   * Plain-text body. At least one of html or text must be provided.
+   */
+  text?: string;
+  /**
+   * Reply-To addresses. When omitted, the mailbox's `default_reply_to` applies (replies then come back to the mailbox itself).
+   *
+   */
+  reply_to?: Array<EmailAddressInput>;
+  /**
+   * File attachments. The send is rejected when the estimated generated message size exceeds 20 MB (bodies plus all attachments after base64 encoding). Attachment metadata endures on the message's `attachment_manifest`; the bytes are downloadable for 30 days.
+   *
+   */
+  attachments?: Array<EmailAttachment>;
+  /**
+   * Structured `{name, value}` labels for filtering and analytics on the sent-message log. Cap: 20 tags per send.
+   *
+   */
+  tags?: Array<Tag>;
+  /**
+   * Arbitrary JSON object stored on the send and echoed in webhook payloads. Cap: 2 KB serialized.
+   *
+   */
+  metadata?: {
+    [key: string]: unknown;
+  };
+  /**
+   * Content classification — controls suppression policy. `marketing` blocks on all suppression reasons; `transactional` allows delivery through complaint and unsubscribe suppressions. Default: transactional.
+   *
+   */
+  category?: "marketing" | "transactional";
+};
+/**
+ * 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 `UnsupportedEmailFeature` 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.
  */
 type EmailAddress = {
   /**
-   * Email address.
+   * Email address.
+   */
+  email: string;
+  /**
+   * Display name shown alongside the address in mail clients.
+   */
+  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;
+/**
+ * A reply to a conversation message. Recipients are derived from the message being replied to: its Reply-To address when present, otherwise its From address. Set `reply_all` to also include the original To and Cc recipients (minus the mailbox's own address). The subject and threading headers are set automatically. At least one of `html` or `text` must be provided.
+ *
+ */
+type EmailThreadMessageReplyRequest = {
+  /**
+   * HTML body of the reply. At least one of html or text must be provided.
+   */
+  html?: string;
+  /**
+   * Plain-text body of the reply. At least one of html or text must be provided.
+   */
+  text?: string;
+  /**
+   * Also send the reply to the original To and Cc recipients, minus the mailbox's own address.
+   */
+  reply_all?: boolean;
+  /**
+   * Structured `{name, value}` labels for filtering and analytics on the sent-message log. Cap: 20 tags per send.
+   *
+   */
+  tags?: Array<Tag>;
+  /**
+   * Arbitrary JSON object stored on the send and echoed in webhook payloads. Cap: 2 KB serialized.
+   *
+   */
+  metadata?: {
+    [key: string]: unknown;
+  };
+  /**
+   * Content classification — controls suppression policy. `marketing` blocks on all suppression reasons; `transactional` allows delivery through complaint and unsubscribe suppressions. Default: transactional.
+   *
+   */
+  category?: "marketing" | "transactional";
+};
+/**
+ * The attachments on a conversation message.
+ */
+type EmailThreadMessageAttachmentList = {
+  data: Array<EmailThreadMessageAttachment>;
+};
+/**
+ * Attachment metadata on a conversation message. The metadata remains readable for the mailbox's retention period; the attachment bytes are downloadable for 30 days after the message occurred.
+ *
+ */
+type EmailThreadMessageAttachment = {
+  /**
+   * Attachment ID, used to download the attachment bytes.
+   */
+  readonly id: string;
+  /**
+   * Original filename, or null when the attachment had none.
+   */
+  readonly filename: string | null;
+  /**
+   * MIME content type, or null when it could not be determined.
+   */
+  readonly content_type: string | null;
+  /**
+   * Attachment size in bytes.
+   */
+  readonly size: number;
+};
+/**
+ * The original rendered body of a conversation message. Available for 30 days after the message occurred; after that the endpoint returns `410 Gone` while the message's extracted text remains readable on the message itself.
+ *
+ */
+type EmailThreadMessageBody = {
+  /**
+   * The HTML body of the message, or null when the message had no HTML part.
+   */
+  html: string | null;
+  /**
+   * The plain-text body of the message, or null when the message had no text part.
+   */
+  text: string | null;
+};
+type ContactId = string;
+/**
+ * Label changes to apply. Labels in `add` are applied and labels in `remove` are taken off; other labels are left untouched. Adding a label that is already present, or removing one that is not, has no effect. System labels express state changes: on a conversation, adding `spam` files it as spam, adding `archive` files it away without deleting it, adding `inbox` (or removing `spam` or `archive`) returns it to the inbox, and removing `unread` marks all retained received messages as read in one call; on a message, adding or removing `unread` flips read state, and adding or removing `trash` moves it to or out of the trash. Changes that contradict this model are rejected: adding more than one placement label in one request, adding `blocked` (blocking a sender is a receive-rule decision), removing `inbox` without adding a destination, adding `trash` or `unread` to a conversation (removing `unread` is the mark-all-read shortcut; `trash` uses the DELETE verb), placement labels on a message (move its conversation instead), and `unread` on a sent message. Custom labels are 1-64 characters with no commas, control characters, or leading or trailing whitespace. System label names and a small reserved set (`all`, `archived`, `deleted`, `draft`, `drafts`, `flagged`, `important`, `junk`, `muted`, `none`, `outbox`, `pinned`, `read`, `scheduled`, `snoozed`, `starred`) cannot be used as custom labels, in any casing. A conversation or message carries at most 20 labels, system labels included.
+ *
+ */
+type EmailLabelsUpdate = {
+  /**
+   * Labels to apply.
+   */
+  add?: Array<string>;
+  /**
+   * Labels to take off.
+   */
+  remove?: Array<string>;
+};
+type EmailThreadMessageList = {
+  data: Array<EmailThreadMessage>;
+} & ListEnvelope;
+/**
+ * Link to the message's entry in the received-message or sent-message log, which carries delivery analytics such as per-recipient events. Log entries expire 30 days after the message occurred.
+ *
+ */
+type EmailThreadMessageSource = {
+  /**
+   * API path of the log entry for this message.
+   */
+  readonly resource: string;
+  /**
+   * When the log entry (and the message's original rendered source) expires.
+   */
+  readonly available_until: string;
+};
+/**
+ * One recipient's terminal delivery outcome on a sent conversation message, folded into the message's durable memory when the outcome becomes known.
+ *
+ */
+type EmailThreadMessageRecipient = {
+  /**
+   * Recipient address.
+   */
+  readonly address: string;
+  /**
+   * Terminal outcome: `delivered`, or `failed` (bounce or provider rejection).
+   */
+  readonly status: "delivered" | "failed";
+};
+/**
+ * A message in a mailbox conversation, either direction. Message metadata and extracted text remain readable for the mailbox's retention period; the original rendered source (HTML body, raw MIME, attachment bytes) is available through the body, raw, and attachment endpoints for 30 days after the message occurred.
+ *
+ */
+type EmailThreadMessage = {
+  /**
+   * Message ID. Received messages carry a `rem_` ID, sent messages an `em_` ID — the same IDs used by the received-message and sent-message logs.
+   *
+   */
+  readonly id: string;
+  /**
+   * Direction of the message — `inbound` for a received message, `outbound` for a sent one.
+   */
+  readonly direction: "inbound" | "outbound";
+  /**
+   * Channel this message was carried on. Always `email`.
+   */
+  readonly channel: string;
+  /**
+   * Conversation this message belongs to.
+   */
+  readonly thread_id: ThreadId;
+  /**
+   * Sender address.
+   */
+  readonly from: string;
+  /**
+   * Recipient addresses on the To line.
+   */
+  readonly to: Array<string>;
+  /**
+   * Recipient addresses on the Cc line. Empty when the message had none.
+   */
+  readonly cc: Array<string>;
+  /**
+   * Address the message was actually delivered to, when it differs from the mailbox address (for example mail routed in from another address). Null for sent messages and for mail addressed directly to the mailbox.
+   *
+   */
+  readonly delivered_to: string | null;
+  /**
+   * Message subject. Null when the message had no subject.
+   */
+  readonly subject: string | null;
+  /**
+   * Short plain-text preview of the message body.
+   */
+  readonly preview: string | null;
+  /**
+   * Plain-text content of the message with quoted history stripped — readable for the mailbox's full retention period, both directions. Always present when fetching a single message; on list endpoints it is included only when the request sets `include=extracted_text`. Null when no text could be extracted.
+   *
+   */
+  readonly extracted_text?: string | null;
+  /**
+   * Labels on this message. System labels carry its state: a received message holds exactly one placement label — `inbox` for accepted mail, `archive` when its conversation was filed away, `spam` (failed sender authentication), or `blocked` (rejected by the mailbox's receive policy or rules) — plus `unread` until it is read. `trash` marks a message in the trash, either direction. Custom labels share the same list; a message carries at most 20.
+   *
+   */
+  labels: Array<string>;
+  /**
+   * Folded delivery status of a sent message: `accepted`, `sent` (provider handoff), `delivered` (all attempted recipients delivered), or `failed` (terminal failure). Null for received messages.
+   *
+   */
+  readonly status: string | null;
+  /**
+   * Terminal per-recipient delivery outcomes of a sent message, folded in as they become known — part of the message's durable memory. Null for received messages and before any recipient reaches a terminal state. Per-recipient event detail lives on the sent-message log (`source`) for 30 days.
+   *
+   */
+  readonly recipients: Array<EmailThreadMessageRecipient> | null;
+  /**
+   * Whether the sender of a received message was authenticated. `pass` means the sender's identity was verified; `fail` means it was checked and did not verify; `unknown` means no verdict could be determined and the sender should not be treated as verified. Null for sent messages. Part of the message's durable memory — readable for the mailbox's full retention period, so the verdict survives after the 30-day inbound log has expired.
+   *
+   */
+  readonly authentication: "pass" | "fail" | "unknown" | null;
+  /**
+   * Whether SPF passed for the sender of a received message. Null for sent messages and when no verdict is available. Durable for the mailbox's retention period.
+   *
+   */
+  readonly spf_pass: boolean | null;
+  /**
+   * Whether DKIM passed for the sender of a received message. Null for sent messages and when no verdict is available. Durable for the mailbox's retention period.
+   *
+   */
+  readonly dkim_pass: boolean | null;
+  /**
+   * Whether DMARC passed for the sender of a received message. Null for sent messages and when no verdict is available. Durable for the mailbox's retention period.
+   *
+   */
+  readonly dmarc_pass: boolean | null;
+  /**
+   * When the message will be permanently deleted: the end of the mailbox's retention period, pulled nearer (at most 30 days out) while the message is in the trash. Restore a trashed message before then with `PATCH {"labels": {"remove": ["trash"]}}`.
+   *
+   */
+  readonly purge_at: string;
+  /**
+   * Number of attachments on the message.
+   */
+  readonly attachment_count: number;
+  /**
+   * Attachment metadata (filename, content type, size). Remains readable for the mailbox's retention period even after the attachment bytes themselves have expired.
+   *
+   */
+  readonly attachment_manifest: Array<EmailThreadMessageAttachment>;
+  /**
+   * RFC 5322 References header entries used to thread the conversation.
+   */
+  readonly reference_ids: Array<string>;
+  /**
+   * Contact linked to this message, or null when none is linked.
+   */
+  contact_id: ContactId | null;
+  readonly source: EmailThreadMessageSource;
+  /**
+   * When the message was received or accepted for sending.
+   */
+  readonly occurred_at: string;
+};
+/**
+ * Changes to apply to a thread. Omitted fields are left unchanged.
+ */
+type EmailThreadUpdateRequest = {
+  labels?: EmailLabelsUpdate;
+  /**
+   * Contact to link this conversation to, or null to unlink the current contact.
+   */
+  contact_id?: ContactId | null;
+};
+type EmailThreadList = {
+  data: Array<EmailThread>;
+} & ListEnvelope;
+/**
+ * Matched search fragments for a thread, one array per field the query matched, with the matched terms wrapped in `**`. A field is present only when the query matched it, so the keys that are present tell you which fields produced the hit. Returned only on thread search results.
+ *
+ */
+type EmailThreadHighlights = {
+  /**
+   * Matched fragments from the conversation's subject.
+   */
+  subject?: Array<string>;
+  /**
+   * Matched fragments from a message's body text.
+   */
+  text?: Array<string>;
+};
+/**
+ * A conversation in a mailbox. Threads group related messages both directions — mail the mailbox received and replies it sent — and carry the conversation-level read state, labels, and participant list. Message counts reflect the messages currently retained under the mailbox's retention period.
+ *
+ */
+type EmailThread = {
+  /**
+   * Thread ID.
+   */
+  readonly id: ThreadId;
+  /**
+   * Mailbox this conversation belongs to.
+   */
+  readonly mailbox_id: MailboxId;
+  /**
+   * Channel this conversation lives on. Always `email`.
+   */
+  readonly channel: string;
+  /**
+   * Contact linked to this conversation, or null when none is linked.
+   */
+  contact_id: ContactId | null;
+  /**
+   * Subject of the conversation, taken from its first message. Null when that message had no subject.
+   */
+  readonly subject: string | null;
+  /**
+   * Addresses that appear on the retained messages in this conversation, including the mailbox's own address.
+   */
+  readonly participants: Array<string>;
+  /**
+   * Number of retained messages in this conversation, both directions.
+   */
+  readonly message_count: number;
+  /**
+   * Number of retained received messages that are still unread. Spam and blocked mail is not counted.
+   */
+  readonly unread_count: number;
+  /**
+   * When the most recent retained message in this conversation was received or sent.
+   */
+  readonly last_message_at: string;
+  /**
+   * Direction of the most recent message — `inbound` for a received message, `outbound` for a sent one.
+   */
+  readonly last_direction: "inbound" | "outbound";
+  /**
+   * Labels on this conversation. Exactly one system placement label is always present — `inbox`, `archive` (filed away, done for now), `spam` (the opening message failed sender authentication), or `blocked` (rejected by the mailbox's receive policy or rules) — set by the message that started the conversation. Move a conversation by updating its labels: add `spam` to file it as spam, add `archive` to clean it out of the inbox, and add `inbox` — or remove `spam`, `blocked`, or `archive` — to bring it back. An archived conversation returns to the inbox by itself when a new message arrives. Custom labels share the same list; a conversation carries at most 20.
+   *
+   */
+  labels: Array<string>;
+  /**
+   * When the thread was created.
+   */
+  readonly created_at: string;
+  /**
+   * When the thread last changed.
+   */
+  readonly updated_at: string;
+  /**
+   * Matched search fragments, keyed by the field that matched. Returned only by thread search; omitted when listing threads.
+   *
+   */
+  readonly highlights?: EmailThreadHighlights;
+};
+/**
+ * Parameters for adding a receive rule to a mailbox.
+ */
+type ReceiveRuleCreate = {
+  /**
+   * What the rule does when it matches. Block rules always win. To flip an entry's action, delete the existing rule and re-create it.
+   */
+  action: "allow" | "block";
+  /**
+   * The sender address (`alice@example.com`) or domain (`example.com`) to match. Domains also match their subdomains. Stored lowercase.
+   */
+  entry: string;
+  /**
+   * Your own note about why the rule exists.
+   */
+  note?: string;
+};
+type ReceiveRuleList = {
+  data: Array<ReceiveRule>;
+} & ListEnvelope;
+type ReceiveRuleId = string;
+/**
+ * An allow or block entry on a mailbox, evaluated when inbound mail arrives. Matching is against the message's envelope sender; domain entries also match subdomains. A given entry can be allow or block, never both.
+ *
+ */
+type ReceiveRule = {
+  /**
+   * Receive rule ID.
+   */
+  readonly id: ReceiveRuleId;
+  /**
+   * The mailbox the rule applies to.
+   */
+  readonly mailbox_id: MailboxId;
+  /**
+   * What the rule does when it matches. Block rules always win — over allow rules and over the reply admission on allowlist mailboxes.
+   */
+  readonly action: "allow" | "block";
+  /**
+   * The sender address or domain the rule matches. Domains also match their subdomains.
+   */
+  readonly entry: string;
+  /**
+   * Whether the entry is a full address or a domain.
+   */
+  readonly entry_type: "address" | "domain";
+  /**
+   * Your own note about why the rule exists. Null when unset.
+   */
+  readonly note: string | null;
+  /**
+   * When the rule was created.
+   */
+  readonly created_at: string;
+};
+/**
+ * A mailbox's sent and received email statistics: a period-wide summary plus a bucketed time series. `period` echoes the range and grain the server computed against; `data` is one row per bucket in chronological order.
+ *
+ */
+type MailboxStatsResponse = {
+  period: EmailStatsSeriesPeriod;
+  summary: MailboxStatsSummary;
+  /**
+   * One row per bucket in the period, in chronological order. Buckets with no activity are included with zero counts.
+   */
+  readonly data: Array<MailboxStatsPoint>;
+};
+/**
+ * Per-mailbox email activity for one time bucket, bucketed by event time. Sent-mail metrics carry the same delivery, engagement, and latency breakdowns as the email stats endpoints; `received` counts mail that arrived at the mailbox. Buckets with no activity are included with zero counts and null latency percentiles.
+ *
+ */
+type MailboxStatsPoint = {
+  /**
+   * The day (YYYY-MM-DD) or instant (RFC 3339, on the bucket boundary) this point covers, matching the period's grain.
+   */
+  readonly bucket: string;
+  /**
+   * Distinct email messages the mailbox sent that were accepted in this bucket, counted at the message level (one per accepted send regardless of how many recipients it addresses). Every other sent-mail metric in `delivery` and `engagement` is recipient-level or event-level.
+   *
+   */
+  readonly sends_accepted: number;
+  readonly delivery: EmailDeliveryStats;
+  readonly engagement: EmailEngagementStats;
+  readonly latency: EmailLatencyStats;
+  /**
+   * Distinct emails the mailbox received in this bucket.
+   */
+  readonly received: number;
+};
+/**
+ * p50, p95, and p99 latency percentiles in milliseconds for one latency family over the bucket. Percentiles are approximate (computed from a high-volume aggregation pipeline). All three are null together when no qualifying event contributed a latency measurement in the bucket.
+ *
+ */
+type EmailLatencyQuantiles = {
+  /**
+   * Median (50th percentile) latency in milliseconds. Null when no qualifying event contributed a measurement.
+   */
+  readonly p50_ms: number | null;
+  /**
+   * 95th percentile latency in milliseconds. Null when no qualifying event contributed a measurement.
+   */
+  readonly p95_ms: number | null;
+  /**
+   * 99th percentile latency in milliseconds. Null when no qualifying event contributed a measurement.
+   */
+  readonly p99_ms: number | null;
+};
+/**
+ * Latency percentiles (p50, p95, p99) in milliseconds for the bucket. On the summary endpoint these are computed across the whole period rather than per bucket. Three families are reported:
+ *
+ * - `processing`: time from accepting the send to handing the message off for delivery, covering internal queue depth and handoff. Measured per processed recipient; null when no recipient in the bucket has reached the processed stage.
+ * - `delivery`: time from handoff to the receiving mail server accepting the message, dominated by recipient-side delivery behaviour. Measured per delivered recipient; null when no deliveries occurred in the bucket.
+ * - `total`: end-to-end time from accepting the send to delivery, the most useful tile for a customer SLO. Measured per delivered recipient; null when no deliveries occurred in the bucket.
+ *
+ * Each family is reported independently and is omitted entirely when no qualifying event contributed a latency measurement in the bucket (including when latency for that stage has not yet been recorded for the workspace), so `processing` can be present while `delivery` and `total` are absent. A client must handle a missing family, and a null p50/p95/p99 within a present family, by rendering a placeholder rather than assuming a number.
+ *
+ */
+type EmailLatencyStats = {
+  processing?: EmailLatencyQuantiles;
+  delivery?: EmailLatencyQuantiles;
+  total?: EmailLatencyQuantiles;
+};
+/**
+ * Engagement counts and rates for the scope of the containing row (a time bucket, a breakdown dimension, or the whole period). `opens`, `opens_non_prefetched` and `clicks` count distinct engagement events (deduplicated occurrences); the `unique_*` fields count distinct recipients; `unsubscribes` counts distinct unsubscribe events. Counts are attributed by event time (not send time), so an open recorded today for a message sent earlier counts in today's row. Counts are deduplicated with a scalable approximate counting method, so very large counts are close estimates rather than exact tallies. Each rate divides the counts in this scope and is null when its denominator is zero.
+ *
+ */
+type EmailEngagementStats = {
+  /**
+   * Distinct open events, counting repeat opens from the same recipient and opens auto-fetched by inbox privacy features (such as Apple Mail Privacy Protection and the Gmail image proxy).
+   *
+   */
+  readonly opens: number;
+  /**
+   * Distinct open events excluding those auto-fetched by inbox privacy features. Same event-counting semantics as `opens` (repeat opens from the same recipient count separately), with prefetched opens removed.
+   *
+   */
+  readonly opens_non_prefetched: number;
+  /**
+   * Distinct recipients who opened at least once, including opens auto-fetched by inbox privacy features.
+   */
+  readonly unique_opens: number;
+  /**
+   * Distinct recipients who opened at least once, excluding opens auto-fetched by inbox privacy features. This is the numerator used for open rate, so iOS-heavy audiences (Apple Mail Privacy Protection and similar) do not inflate it.
+   *
+   */
+  readonly unique_opens_non_prefetched: number;
+  /**
+   * Distinct click events, counting repeat clicks from the same recipient.
+   */
+  readonly clicks: number;
+  /**
+   * Distinct recipients who clicked at least once.
+   */
+  readonly unique_clicks: number;
+  /**
+   * Distinct unsubscribe events, recorded via the list-unsubscribe header or the footer link.
+   */
+  readonly unsubscribes: number;
+  /**
+   * Distinct non-prefetched openers relative to effectively delivered recipients in the same scope, computed as `unique_opens_non_prefetched / delivery.effective_delivered`; on rows without an `effective_delivered` field (the mailbox-provider breakdowns) the denominator equals `delivery.delivered`. The numerator excludes opens auto-fetched by inbox privacy features. Opens are attributed by event time, so engagement earned by earlier deliveries can push the rate above 1. Null when the denominator is zero.
+   *
+   */
+  readonly open_rate: number | null;
+  /**
+   * Distinct clickers relative to effectively delivered recipients in the same scope, computed as `unique_clicks / delivery.effective_delivered` (`delivery.delivered` on rows without an `effective_delivered` field). Clicks are attributed by event time, so engagement earned by earlier deliveries can push the rate above 1. Null when the denominator is zero.
+   *
+   */
+  readonly click_rate: number | null;
+  /**
+   * Unsubscribe events relative to effectively delivered recipients in the same scope, computed as `unsubscribes / delivery.effective_delivered` (`delivery.delivered` on rows without an `effective_delivered` field). Unsubscribes are attributed by event time, so the rate can exceed 1. Null when the denominator is zero.
+   *
+   */
+  readonly unsubscribe_rate: number | null;
+};
+/**
+ * Breakdown of `bounced` by failure type, with each rate as a fraction of `bounced`. Counts are distinct bounced recipients of that type; the five types approximately partition `bounced`, so the five rates sum to roughly 1.0 when `bounced` is non-zero.
+ *
+ */
+type EmailBounceStatsWithRates = {
+  /**
+   * Distinct recipients with a permanent delivery failure (invalid address or non-existent domain).
+   */
+  readonly hard: number;
+  /**
+   * Distinct recipients with a transient delivery failure (mailbox full or server temporarily unavailable).
+   */
+  readonly soft: number;
+  /**
+   * Distinct recipients bounced by an upstream policy block (relaying denied, blocklisted domain).
+   */
+  readonly admin: number;
+  /**
+   * Distinct recipients bounced because the receiving mail server blocked the sending IP for reputation reasons.
+   */
+  readonly block: number;
+  /**
+   * Distinct recipients bounced where the receiving server's response did not allow precise classification.
+   */
+  readonly undetermined: number;
+  /**
+   * Fraction of bounced recipients that hard bounced, computed as `hard / bounced`. Null when `bounced` is zero.
+   *
+   */
+  readonly hard_rate: number | null;
+  /**
+   * Fraction of bounced recipients that soft bounced, computed as `soft / bounced`. Null when `bounced` is zero.
+   *
+   */
+  readonly soft_rate: number | null;
+  /**
+   * Fraction of bounced recipients that admin bounced, computed as `admin / bounced`. Null when `bounced` is zero.
+   *
+   */
+  readonly admin_rate: number | null;
+  /**
+   * Fraction of bounced recipients that block bounced, computed as `block / bounced`. Null when `bounced` is zero.
+   *
+   */
+  readonly block_rate: number | null;
+  /**
+   * Fraction of bounced recipients with undetermined classification, computed as `undetermined / bounced`. Null when `bounced` is zero.
+   *
+   */
+  readonly undetermined_rate: number | null;
+};
+/**
+ * Delivery pipeline counts and rates for the scope of the containing row (a time bucket, a breakdown dimension, or the whole period). Every count is the number of distinct recipients that reached the named lifecycle stage in scope (on the period summary, the sum of the per-bucket distinct counts), attributed by event time (not send time): a recipient delivered on Monday counts in Monday's row, and a recipient who bounced then succeeded on a retry can appear in both `bounced` and `delivered`. Counts are deduplicated with a scalable approximate counting method, so very large counts are close estimates rather than exact tallies. These counts are successive lifecycle stages, not interchangeable categories: `rejected` happens before any send attempt (suppression, policy, generation failure); `deferred` is a temporary in-flight delay still being retried; `bounced` (with its hard/soft/admin/block/undetermined sub-types) is a delivery failure; and `complained` is post-delivery spam feedback. Each rate is a fraction in the range 0 to 1 and is null when its denominator is zero. `accepted` is reported only where it can be attributed (time buckets and the period summary); breakdown rows omit it.
+ *
+ */
+type EmailDeliveryStats = {
+  /**
+   * Distinct recipients accepted for delivery after suppression filtering. Reported on time buckets and the period summary; omitted on breakdown rows, whose rollups do not carry it.
+   */
+  readonly accepted?: number;
+  /**
+   * Distinct recipients whose message was processed and handed off for delivery.
+   */
+  readonly processed: number;
+  /**
+   * Distinct recipients whose message the receiving mail server accepted.
+   */
+  readonly delivered: number;
+  /**
+   * Distinct recipients whose delivery failed. Approximately the sum of the five `bounces.*` sub-counts (hard, soft, admin, block, undetermined); the totals are computed independently so they may differ slightly at the approximation error.
+   *
+   */
+  readonly bounced: number;
+  readonly bounces: EmailBounceStatsWithRates;
+  /**
+   * Distinct recipients who reported the message as spam via a feedback loop.
+   */
+  readonly complained: number;
+  /**
+   * Distinct recipients whose delivery the receiving server temporarily delayed and is still being retried.
+   *
+   */
+  readonly deferred: number;
+  /**
+   * Distinct recipients rejected before any delivery attempt. Includes recipients on the workspace suppression list, transmissions that could not be completed, message-generation failures, and recipients refused by sending policy. The per-recipient `rejection_reason` field on `GET /v1/email/messages/{message_id}/recipients` surfaces the specific cause.
+   *
+   */
+  readonly rejected: number;
+  /**
+   * Out-of-band bounce events: distinct failure notifications received after the receiving server had initially confirmed delivery. Counted as deduplicated events, not unique recipients.
+   *
+   */
+  readonly oob_bounces: number;
+  /**
+   * Recipients who remain in-inbox in this scope after all bounce signals resolve, computed as `delivered - oob_bounces`. Use this as the base for engagement-rate denominators. Clamped to 0 when `oob_bounces` exceeds `delivered`.
+   */
+  readonly effective_delivered: number;
+  /**
+   * Total recipients in this scope who did not receive the message, computed as `bounced + oob_bounces`.
+   */
+  readonly all_bounces: number;
+  /**
+   * Share of this scope's delivery attempts that resulted in an out-of-band bounce, computed as `oob_bounces / (delivered + bounced)`. Null when there were no attempts.
+   */
+  readonly oob_rate: number | null;
+  /**
+   * Share of this scope's delivery attempts that resulted in a message remaining in-inbox, computed as `effective_delivered / (delivered + bounced)`. Null when there were no attempts.
+   *
+   */
+  readonly delivery_rate: number | null;
+  /**
+   * Share of this scope's delivery attempts that ultimately failed (inband or out-of-band), computed as `all_bounces / (delivered + bounced)`. Because `oob_bounces` counts events rather than recipients, `all_bounces` can exceed the attempt count; the rate is clamped to 1. Null when there were no attempts.
+   *
+   */
+  readonly bounce_rate: number | null;
+  /**
+   * Spam complaints in this scope relative to effectively delivered recipients, computed as `complained / effective_delivered`. Complaints are attributed by event time, so a scope can record more of them than it effectively delivered, pushing the rate above 1. Null when `effective_delivered` is zero.
+   *
+   */
+  readonly complaint_rate: number | null;
+};
+/**
+ * Single-row aggregate of the mailbox's email activity across the full requested period. Counts are sums of per-bucket counts across the window; latency percentiles are computed across the whole period rather than summed per bucket. Rates are null when their denominator is zero.
+ *
+ */
+type MailboxStatsSummary = {
+  /**
+   * Distinct email messages the mailbox sent that were accepted, counted at the message level and summed per bucket across the period.
+   */
+  readonly sends_accepted: number;
+  readonly delivery: EmailDeliveryStats;
+  readonly engagement: EmailEngagementStats;
+  readonly latency: EmailLatencyStats;
+  /**
+   * Distinct emails the mailbox received, summed per bucket across the period.
+   */
+  readonly received: number;
+};
+/**
+ * The window and bucket grain the response covers, echoed from the request, plus the freshness boundary the data is current to.
+ *
+ */
+type EmailStatsSeriesPeriod = {
+  /**
+   * Inclusive start of the window. A calendar day (YYYY-MM-DD, in the requested `timezone`) on the day grain; on the hour grain, an RFC 3339 UTC instant marking the start of the first hour bucket, which falls on a local hour boundary when `timezone` is set.
+   */
+  readonly from: string;
+  /**
+   * Inclusive end of the window. A calendar day (YYYY-MM-DD, in the requested `timezone`) on the day grain; on the hour grain, an RFC 3339 UTC instant marking the start of the last hour bucket, which falls on a local hour boundary when `timezone` is set.
+   */
+  readonly to: string;
+  /**
+   * The bucket grain of the series, either `day` or `hour`.
+   */
+  readonly grain: string;
+  /**
+   * The instant the statistics in this response are current to: events recorded up to roughly this time are reflected, while more recent events may not be yet. Statistics are served from a rolling aggregation that refreshes every few seconds, so a response is near-real-time but not live; use this field to label data freshness rather than assuming the numbers are to-the-second. Null when the freshness boundary is not being reported.
+   *
+   */
+  readonly data_as_of?: string | null;
+};
+/**
+ * Fields to update on a mailbox. Omitted fields are unchanged; fields set to null are cleared. The address and domain are immutable.
+ */
+type MailboxUpdate = {
+  /**
+   * Display name used as the sender name on mail from this mailbox. Null clears it.
+   */
+  display_name?: string | null;
+  /**
+   * Default Reply-To address stamped on mail sent from this mailbox. Null clears it.
+   */
+  default_reply_to?: string | null;
+  /**
+   * Which inbound mail the mailbox accepts.
+   */
+  receive_policy?: "open" | "replies_only" | "allowlist" | "drop";
+  /**
+   * How long the mailbox remembers message metadata and extracted text. Lowering the tier deletes memory older than the new horizon and requires `confirm=true` when messages older than the new horizon would be deleted. Only `30d` is available today; longer tiers (`90d`, `1y`, and beyond) are coming soon.
+   */
+  retention_tier?: "30d";
+  /**
+   * Replaces the mailbox's key/value data. Up to 2 KB; keys starting with `__bird` are reserved.
+   */
+  metadata?: {
+    [key: string]: unknown;
+  };
+};
+/**
+ * Parameters for creating a mailbox.
+ */
+type MailboxCreate = {
+  /**
+   * The local part of the mailbox address (the part before `@`). Letters, digits, dots, underscores, and hyphens; stored lowercase. On the shared `inbox.ai` domain, separators must sit between letters or digits (no leading, trailing, or repeated separators), reserved names such as `postmaster` or `abuse` are unavailable, and choosing your own local part uses one of your plan's custom-handle allowance slots (generated addresses are always available). Omit to have Bird generate a random local part.
+   */
+  local_part?: string;
+  /**
+   * The domain the address lives under. Defaults to `inbox.ai`, Bird's shared mailbox domain, where creating the mailbox claims the address for your organization: first come, first served, and permanently reserved to your organization even after the mailbox is deleted. May instead name one of your own domains that is enabled for receiving email.
+   */
+  domain?: string;
+  /**
+   * Display name used as the sender name on mail from this mailbox.
+   */
+  display_name?: string;
+  /**
+   * Default Reply-To address stamped on mail sent from this mailbox.
+   */
+  default_reply_to?: string;
+  /**
+   * Which inbound mail the mailbox accepts. `open` accepts everything not blocked by a rule; `replies_only` accepts only replies to messages this mailbox has sent (a reply must match a message the mailbox sent, not merely land in an existing thread); `allowlist` accepts only senders matching an allow rule; `drop` stores nothing.
+   */
+  receive_policy?: "open" | "replies_only" | "allowlist" | "drop";
+  /**
+   * How long the mailbox remembers message metadata and extracted text. Original rendered source is always available for 30 days regardless of tier. Only `30d` is available today; longer tiers (`90d`, `1y`, and beyond) are coming soon.
+   */
+  retention_tier?: "30d";
+  /**
+   * Your own key/value data to attach to the mailbox. Up to 2 KB; keys starting with `__bird` are reserved.
+   */
+  metadata?: {
+    [key: string]: unknown;
+  };
+};
+type MailboxList = {
+  data: Array<Mailbox>;
+} & ListEnvelope;
+type InboundAddressId = string;
+/**
+ * The principal that owns the mailbox. Always the workspace.
+ */
+type MailboxOwner = {
+  /**
+   * Owner principal type.
+   */
+  readonly type: "workspace";
+  /**
+   * Owner principal ID.
+   */
+  readonly id: WorkspaceId;
+};
+/**
+ * A durable mailbox identity for an agent. A mailbox owns an email address, groups mail into threads, applies receive policy, and remembers message metadata and extracted text for its retention tier. The original rendered source of each message remains available for 30 days.
+ *
+ */
+type Mailbox = {
+  /**
+   * Mailbox ID.
+   */
+  readonly id: MailboxId;
+  /**
+   * The mailbox's email address. Immutable once created.
    */
-  email: string;
+  readonly address: string;
   /**
-   * Display name shown alongside the address in mail clients.
+   * Display name used as the sender name on mail from this mailbox. Null when unset.
    */
-  name?: string;
+  display_name: string | null;
+  /**
+   * Default Reply-To address stamped on mail sent from this mailbox. Null when unset.
+   */
+  default_reply_to: string | null;
+  /**
+   * Which inbound mail the mailbox accepts. `open` accepts everything not blocked by a rule; `replies_only` accepts only replies to messages this mailbox has sent (a reply must match a message the mailbox sent, not merely land in an existing thread); `allowlist` accepts only senders matching an allow rule (replies to prior outbound are always admitted unless blocked); `drop` stores nothing.
+   */
+  receive_policy: "open" | "replies_only" | "allowlist" | "drop";
+  /**
+   * Lifecycle state. Suspended mailboxes stop emitting events; inbound mail is retained as blocked.
+   */
+  readonly state: "active" | "suspended";
+  /**
+   * The channel this mailbox receives on. Always `email`.
+   */
+  readonly channel: "email";
+  readonly owner: MailboxOwner;
+  /**
+   * The underlying inbound address that receives this mailbox's mail.
+   */
+  readonly inbound_address_id: InboundAddressId;
+  /**
+   * How long the mailbox remembers message metadata and extracted text. Original rendered source (HTML, raw message, attachments) is always available for 30 days regardless of tier. `3y` and `10y` are reserved future tiers.
+   */
+  retention_tier: "30d" | "90d" | "1y";
+  /**
+   * Number of retained messages across all threads.
+   */
+  readonly message_count: number;
+  /**
+   * Number of retained threads.
+   */
+  readonly thread_count: number;
+  /**
+   * Number of threads with unread messages in this mailbox, excluding trash. Null on create/update responses.
+   *
+   */
+  readonly unread_thread_count?: number | null;
+  /**
+   * Your own key/value data attached to the mailbox. Up to 2 KB; keys starting with `__bird` are reserved.
+   */
+  metadata: {
+    [key: string]: unknown;
+  };
+  /**
+   * Whether Bird generated the local part of the address. `false` means a custom handle was chosen at creation; on the shared `inbox.ai` domain a custom handle counts against your plan's custom-handle allowance.
+   */
+  readonly local_part_generated?: boolean;
+  /**
+   * When the mailbox was created.
+   */
+  readonly created_at: string;
+  /**
+   * When the mailbox was last updated.
+   */
+  readonly updated_at: string;
+  /**
+   * When the mailbox was deleted, or null if it is active. A deleted mailbox stops receiving mail immediately but can be restored for 30 days, after which it and its remembered messages are permanently removed.
+   */
+  readonly deleted_at?: string | null;
 };
 /**
  * Partial update. `settings` changes apply immediately. Changes to `return_path`, `tracking`, or `dkim` on a verified capability are staged: the current configuration keeps serving until the new one's DNS records verify, then the change is promoted automatically and the old records are marked `deprecated`. The staged value is visible under `capabilities.*.pending` and can be replaced by submitting another change.
@@ -2138,260 +3088,54 @@ type Domain = {
  * Per-broadcast breakdown for the requested period, ranked by the `sort` metric (default `processed`) descending and capped at the requested `limit` (default 50, max 200).
  */
 type EmailStatsByBroadcastResponse = {
-  period: EmailStatsPeriod & unknown;
-  /**
-   * Broadcast breakdown rows, ranked by the `sort` metric (default `processed`) descending. Empty when no broadcast messages were active in the period.
-   */
-  readonly data: Array<EmailBroadcastStatsPoint>;
-  /**
-   * Total number of distinct broadcasts with activity in the period, regardless of `limit`. When it exceeds the number of rows returned, the ranking was capped; raise `limit` (up to 200) or narrow the window to see more.
-   *
-   */
-  readonly total: number;
-};
-/**
- * One point in a breakdown row's trend series: the headline delivery and engagement rates for that row's dimension value over a single day or hour. Returned only when `include_trend=true`; the bucket grain (day or hour) follows the `trend_grain` parameter. Counts and rates are approximate at scale.
- *
- */
-type EmailStatsSeriesPoint = {
-  /**
-   * The day (YYYY-MM-DD) or hour (ISO 8601, on the hour) this point covers, matching the requested `trend_grain`.
-   */
-  readonly bucket: string;
-  /**
-   * Delivered recipients in this bucket.
-   */
-  readonly delivered: number;
-  /**
-   * Bounced recipients in this bucket.
-   */
-  readonly bounced: number;
-  /**
-   * Delivery rate for this bucket, as a fraction. Null when nothing was delivered or bounced.
-   */
-  readonly delivery_rate: number | null;
-  /**
-   * Bounce rate for this bucket, as a fraction. Null when nothing was delivered or bounced.
-   */
-  readonly bounce_rate: number | null;
-  /**
-   * Complaint rate for this bucket, as a fraction; event-time attribution can push it above 1 when complaints outrun the bucket's deliveries. Null when nothing was delivered in the bucket. On a sending-IP row complaints are not attributed to the IP, so this reads 0 in buckets that had deliveries and null in buckets that had none.
-   */
-  readonly complaint_rate: number | null;
-  /**
-   * Open rate for this bucket, as a fraction; event-time attribution can push it above 1 when opens outrun the bucket's deliveries. Null when nothing was delivered in the bucket. On a sending-IP row engagement is not attributed to the IP, so this reads 0 in buckets that had deliveries and null in buckets that had none.
-   */
-  readonly open_rate: number | null;
-  /**
-   * Click rate for this bucket, as a fraction; event-time attribution can push it above 1 when clicks outrun the bucket's deliveries. Null when nothing was delivered in the bucket. On a sending-IP row engagement is not attributed to the IP, so this reads 0 in buckets that had deliveries and null in buckets that had none.
-   */
-  readonly click_rate: number | null;
-};
-/**
- * p50, p95, and p99 latency percentiles in milliseconds for one latency family over the bucket. Percentiles are approximate (computed from a high-volume aggregation pipeline). All three are null together when no qualifying event contributed a latency measurement in the bucket.
- *
- */
-type EmailLatencyQuantiles = {
-  /**
-   * Median (50th percentile) latency in milliseconds. Null when no qualifying event contributed a measurement.
-   */
-  readonly p50_ms: number | null;
-  /**
-   * 95th percentile latency in milliseconds. Null when no qualifying event contributed a measurement.
-   */
-  readonly p95_ms: number | null;
-  /**
-   * 99th percentile latency in milliseconds. Null when no qualifying event contributed a measurement.
-   */
-  readonly p99_ms: number | null;
-};
-/**
- * Latency percentiles (p50, p95, p99) in milliseconds for the bucket. On the summary endpoint these are computed across the whole period rather than per bucket. Three families are reported:
- *
- * - `processing`: time from accepting the send to handing the message off for delivery, covering internal queue depth and handoff. Measured per processed recipient; null when no recipient in the bucket has reached the processed stage.
- * - `delivery`: time from handoff to the receiving mail server accepting the message, dominated by recipient-side delivery behaviour. Measured per delivered recipient; null when no deliveries occurred in the bucket.
- * - `total`: end-to-end time from accepting the send to delivery, the most useful tile for a customer SLO. Measured per delivered recipient; null when no deliveries occurred in the bucket.
- *
- * Each family is reported independently and is omitted entirely when no qualifying event contributed a latency measurement in the bucket (including when latency for that stage has not yet been recorded for the workspace), so `processing` can be present while `delivery` and `total` are absent. A client must handle a missing family, and a null p50/p95/p99 within a present family, by rendering a placeholder rather than assuming a number.
- *
- */
-type EmailLatencyStats = {
-  processing?: EmailLatencyQuantiles;
-  delivery?: EmailLatencyQuantiles;
-  total?: EmailLatencyQuantiles;
-};
-/**
- * Engagement counts and rates for the scope of the containing row (a time bucket, a breakdown dimension, or the whole period). `opens`, `opens_non_prefetched` and `clicks` count distinct engagement events (deduplicated occurrences); the `unique_*` fields count distinct recipients; `unsubscribes` counts distinct unsubscribe events. Counts are attributed by event time (not send time), so an open recorded today for a message sent earlier counts in today's row. Counts are deduplicated with a scalable approximate counting method, so very large counts are close estimates rather than exact tallies. Each rate divides the counts in this scope and is null when its denominator is zero.
- *
- */
-type EmailEngagementStats = {
-  /**
-   * Distinct open events, counting repeat opens from the same recipient and opens auto-fetched by inbox privacy features (such as Apple Mail Privacy Protection and the Gmail image proxy).
-   *
-   */
-  readonly opens: number;
-  /**
-   * Distinct open events excluding those auto-fetched by inbox privacy features. Same event-counting semantics as `opens` (repeat opens from the same recipient count separately), with prefetched opens removed.
-   *
-   */
-  readonly opens_non_prefetched: number;
-  /**
-   * Distinct recipients who opened at least once, including opens auto-fetched by inbox privacy features.
-   */
-  readonly unique_opens: number;
-  /**
-   * Distinct recipients who opened at least once, excluding opens auto-fetched by inbox privacy features. This is the numerator used for open rate, so iOS-heavy audiences (Apple Mail Privacy Protection and similar) do not inflate it.
-   *
-   */
-  readonly unique_opens_non_prefetched: number;
-  /**
-   * Distinct click events, counting repeat clicks from the same recipient.
-   */
-  readonly clicks: number;
-  /**
-   * Distinct recipients who clicked at least once.
-   */
-  readonly unique_clicks: number;
-  /**
-   * Distinct unsubscribe events, recorded via the list-unsubscribe header or the footer link.
-   */
-  readonly unsubscribes: number;
-  /**
-   * Distinct non-prefetched openers relative to effectively delivered recipients in the same scope, computed as `unique_opens_non_prefetched / delivery.effective_delivered`; on rows without an `effective_delivered` field (the mailbox-provider breakdowns) the denominator equals `delivery.delivered`. The numerator excludes opens auto-fetched by inbox privacy features. Opens are attributed by event time, so engagement earned by earlier deliveries can push the rate above 1. Null when the denominator is zero.
-   *
-   */
-  readonly open_rate: number | null;
-  /**
-   * Distinct clickers relative to effectively delivered recipients in the same scope, computed as `unique_clicks / delivery.effective_delivered` (`delivery.delivered` on rows without an `effective_delivered` field). Clicks are attributed by event time, so engagement earned by earlier deliveries can push the rate above 1. Null when the denominator is zero.
-   *
-   */
-  readonly click_rate: number | null;
-  /**
-   * Unsubscribe events relative to effectively delivered recipients in the same scope, computed as `unsubscribes / delivery.effective_delivered` (`delivery.delivered` on rows without an `effective_delivered` field). Unsubscribes are attributed by event time, so the rate can exceed 1. Null when the denominator is zero.
-   *
-   */
-  readonly unsubscribe_rate: number | null;
-};
-/**
- * Breakdown of `bounced` by failure type, with each rate as a fraction of `bounced`. Counts are distinct bounced recipients of that type; the five types approximately partition `bounced`, so the five rates sum to roughly 1.0 when `bounced` is non-zero.
- *
- */
-type EmailBounceStatsWithRates = {
-  /**
-   * Distinct recipients with a permanent delivery failure (invalid address or non-existent domain).
-   */
-  readonly hard: number;
-  /**
-   * Distinct recipients with a transient delivery failure (mailbox full or server temporarily unavailable).
-   */
-  readonly soft: number;
-  /**
-   * Distinct recipients bounced by an upstream policy block (relaying denied, blocklisted domain).
-   */
-  readonly admin: number;
-  /**
-   * Distinct recipients bounced because the receiving mail server blocked the sending IP for reputation reasons.
-   */
-  readonly block: number;
-  /**
-   * Distinct recipients bounced where the receiving server's response did not allow precise classification.
-   */
-  readonly undetermined: number;
-  /**
-   * Fraction of bounced recipients that hard bounced, computed as `hard / bounced`. Null when `bounced` is zero.
-   *
-   */
-  readonly hard_rate: number | null;
-  /**
-   * Fraction of bounced recipients that soft bounced, computed as `soft / bounced`. Null when `bounced` is zero.
-   *
-   */
-  readonly soft_rate: number | null;
-  /**
-   * Fraction of bounced recipients that admin bounced, computed as `admin / bounced`. Null when `bounced` is zero.
-   *
-   */
-  readonly admin_rate: number | null;
-  /**
-   * Fraction of bounced recipients that block bounced, computed as `block / bounced`. Null when `bounced` is zero.
-   *
-   */
-  readonly block_rate: number | null;
-  /**
-   * Fraction of bounced recipients with undetermined classification, computed as `undetermined / bounced`. Null when `bounced` is zero.
-   *
-   */
-  readonly undetermined_rate: number | null;
-};
-/**
- * Delivery pipeline counts and rates for the scope of the containing row (a time bucket, a breakdown dimension, or the whole period). Every count is the number of distinct recipients that reached the named lifecycle stage in scope (on the period summary, the sum of the per-bucket distinct counts), attributed by event time (not send time): a recipient delivered on Monday counts in Monday's row, and a recipient who bounced then succeeded on a retry can appear in both `bounced` and `delivered`. Counts are deduplicated with a scalable approximate counting method, so very large counts are close estimates rather than exact tallies. These counts are successive lifecycle stages, not interchangeable categories: `rejected` happens before any send attempt (suppression, policy, generation failure); `deferred` is a temporary in-flight delay still being retried; `bounced` (with its hard/soft/admin/block/undetermined sub-types) is a delivery failure; and `complained` is post-delivery spam feedback. Each rate is a fraction in the range 0 to 1 and is null when its denominator is zero. `accepted` is reported only where it can be attributed (time buckets and the period summary); breakdown rows omit it.
- *
- */
-type EmailDeliveryStats = {
-  /**
-   * Distinct recipients accepted for delivery after suppression filtering. Reported on time buckets and the period summary; omitted on breakdown rows, whose rollups do not carry it.
-   */
-  readonly accepted?: number;
-  /**
-   * Distinct recipients whose message was processed and handed off for delivery.
-   */
-  readonly processed: number;
-  /**
-   * Distinct recipients whose message the receiving mail server accepted.
-   */
-  readonly delivered: number;
-  /**
-   * Distinct recipients whose delivery failed. Approximately the sum of the five `bounces.*` sub-counts (hard, soft, admin, block, undetermined); the totals are computed independently so they may differ slightly at the approximation error.
-   *
-   */
-  readonly bounced: number;
-  readonly bounces: EmailBounceStatsWithRates;
-  /**
-   * Distinct recipients who reported the message as spam via a feedback loop.
-   */
-  readonly complained: number;
-  /**
-   * Distinct recipients whose delivery the receiving server temporarily delayed and is still being retried.
-   *
-   */
-  readonly deferred: number;
+  period: EmailStatsPeriod & unknown;
   /**
-   * Distinct recipients rejected before any delivery attempt. Includes recipients on the workspace suppression list, transmissions that could not be completed, message-generation failures, and recipients refused by sending policy. The per-recipient `rejection_reason` field on `GET /v1/email/messages/{message_id}/recipients` surfaces the specific cause.
-   *
+   * Broadcast breakdown rows, ranked by the `sort` metric (default `processed`) descending. Empty when no broadcast messages were active in the period.
    */
-  readonly rejected: number;
+  readonly data: Array<EmailBroadcastStatsPoint>;
   /**
-   * Out-of-band bounce events: distinct failure notifications received after the receiving server had initially confirmed delivery. Counted as deduplicated events, not unique recipients.
+   * Total number of distinct broadcasts with activity in the period, regardless of `limit`. When it exceeds the number of rows returned, the ranking was capped; raise `limit` (up to 200) or narrow the window to see more.
    *
    */
-  readonly oob_bounces: number;
+  readonly total: number;
+};
+/**
+ * One point in a breakdown row's trend series: the headline delivery and engagement rates for that row's dimension value over a single day or hour. Returned only when `include_trend=true`; the bucket grain (day or hour) follows the `trend_grain` parameter. Counts and rates are approximate at scale.
+ *
+ */
+type EmailStatsSeriesPoint = {
   /**
-   * Recipients who remain in-inbox in this scope after all bounce signals resolve, computed as `delivered - oob_bounces`. Use this as the base for engagement-rate denominators. Clamped to 0 when `oob_bounces` exceeds `delivered`.
+   * The day (YYYY-MM-DD) or hour (ISO 8601, on the hour) this point covers, matching the requested `trend_grain`.
    */
-  readonly effective_delivered: number;
+  readonly bucket: string;
   /**
-   * Total recipients in this scope who did not receive the message, computed as `bounced + oob_bounces`.
+   * Delivered recipients in this bucket.
    */
-  readonly all_bounces: number;
+  readonly delivered: number;
   /**
-   * Share of this scope's delivery attempts that resulted in an out-of-band bounce, computed as `oob_bounces / (delivered + bounced)`. Null when there were no attempts.
+   * Bounced recipients in this bucket.
    */
-  readonly oob_rate: number | null;
+  readonly bounced: number;
   /**
-   * Share of this scope's delivery attempts that resulted in a message remaining in-inbox, computed as `effective_delivered / (delivered + bounced)`. Null when there were no attempts.
-   *
+   * Delivery rate for this bucket, as a fraction. Null when nothing was delivered or bounced.
    */
   readonly delivery_rate: number | null;
   /**
-   * Share of this scope's delivery attempts that ultimately failed (inband or out-of-band), computed as `all_bounces / (delivered + bounced)`. Because `oob_bounces` counts events rather than recipients, `all_bounces` can exceed the attempt count; the rate is clamped to 1. Null when there were no attempts.
-   *
+   * Bounce rate for this bucket, as a fraction. Null when nothing was delivered or bounced.
    */
   readonly bounce_rate: number | null;
   /**
-   * Spam complaints in this scope relative to effectively delivered recipients, computed as `complained / effective_delivered`. Complaints are attributed by event time, so a scope can record more of them than it effectively delivered, pushing the rate above 1. Null when `effective_delivered` is zero.
-   *
+   * Complaint rate for this bucket, as a fraction; event-time attribution can push it above 1 when complaints outrun the bucket's deliveries. Null when nothing was delivered in the bucket. On a sending-IP row complaints are not attributed to the IP, so this reads 0 in buckets that had deliveries and null in buckets that had none.
    */
   readonly complaint_rate: number | null;
+  /**
+   * Open rate for this bucket, as a fraction; event-time attribution can push it above 1 when opens outrun the bucket's deliveries. Null when nothing was delivered in the bucket. On a sending-IP row engagement is not attributed to the IP, so this reads 0 in buckets that had deliveries and null in buckets that had none.
+   */
+  readonly open_rate: number | null;
+  /**
+   * Click rate for this bucket, as a fraction; event-time attribution can push it above 1 when clicks outrun the bucket's deliveries. Null when nothing was delivered in the bucket. On a sending-IP row engagement is not attributed to the IP, so this reads 0 in buckets that had deliveries and null in buckets that had none.
+   */
+  readonly click_rate: number | null;
 };
 /**
  * Aggregate delivery, engagement, and latency stats for the messages of a single broadcast over the requested period.
@@ -3131,29 +3875,6 @@ type EmailStatsPoint = {
   readonly engagement: EmailEngagementStats;
   readonly latency: EmailLatencyStats;
 };
-/**
- * The window and bucket grain the response covers, echoed from the request, plus the freshness boundary the data is current to.
- *
- */
-type EmailStatsSeriesPeriod = {
-  /**
-   * Inclusive start of the window. A calendar day (YYYY-MM-DD, in the requested `timezone`) on the day grain; on the hour grain, an RFC 3339 UTC instant marking the start of the first hour bucket, which falls on a local hour boundary when `timezone` is set.
-   */
-  readonly from: string;
-  /**
-   * Inclusive end of the window. A calendar day (YYYY-MM-DD, in the requested `timezone`) on the day grain; on the hour grain, an RFC 3339 UTC instant marking the start of the last hour bucket, which falls on a local hour boundary when `timezone` is set.
-   */
-  readonly to: string;
-  /**
-   * The bucket grain of the series, either `day` or `hour`.
-   */
-  readonly grain: string;
-  /**
-   * The instant the statistics in this response are current to: events recorded up to roughly this time are reflected, while more recent events may not be yet. Statistics are served from a rolling aggregation that refreshes every few seconds, so a response is near-real-time but not live; use this field to label data freshness rather than assuming the numbers are to-the-second. Null when the freshness boundary is not being reported.
-   *
-   */
-  readonly data_as_of?: string | null;
-};
 type WhatsAppTemplateList = {
   /**
    * The templates available to your workspace.
@@ -3926,7 +4647,6 @@ 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 and keeps its original join time; duplicate IDs in the list are collapsed. If any ID does not exist in the workspace, the whole request fails with a validation error and no contacts are added.
@@ -4208,40 +4928,6 @@ 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 `UnsupportedEmailFeature` 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 EmailTemplateSend = unknown & {
   /**
    * The template to send, by its id.
@@ -4259,11 +4945,6 @@ 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.
@@ -4640,6 +5321,27 @@ type ListContactsData = {
   };
   url: "/v1/contacts";
 };
+type CreateContactData = {
+  body: ContactCreateRequest;
+  headers?: {
+    /**
+     * Client-supplied deduplication key. When present, the server replays the original response for any duplicate request with the same key within the idempotency TTL window (3 hours by default).
+     * Two distinct 409 errors signal misuse:
+     * - `request_in_progress` (E01004) — the same key is currently being
+     * processed by a concurrent request. Wait briefly and retry; the lock
+     * expires within 30 seconds.
+     * - `idempotency_key_reuse` (E01005) — the same key has already completed
+     * against a different request body or method. Generate a new key.
+     *
+     * Recommended key format is `<event-type>/<entity-id>` (e.g. `welcome-user/usr_abc123`).
+     *
+     */
+    "Idempotency-Key"?: string;
+  };
+  path?: never;
+  query?: never;
+  url: "/v1/contacts";
+};
 type ListContactPropertiesData = {
   body?: never;
   path?: never;
@@ -5399,62 +6101,214 @@ type GetEmailStatsByClientData = {
      * Which reading-environment facet to group rows by. `email_client` (default) groups by mail client; `os` groups by operating system; `device_type` groups by device type. Each row populates the chosen facet and leaves the other two null.
      *
      */
-    group_by?: "email_client" | "os" | "device_type";
+    group_by?: "email_client" | "os" | "device_type";
+    /**
+     * Metric to rank rows by, applied descending. Defaults to `unique_opens`. Only engagement counts are sortable; this breakdown has no rates.
+     *
+     */
+    sort?: EmailEngagementSortMetric;
+    /**
+     * Maximum number of client rows to return, ranked by the `sort` field descending.
+     */
+    limit?: number;
+  };
+  url: "/v1/email/stats/clients";
+};
+type GetEmailStatsByBounceCodeData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * Start date (inclusive) in YYYY-MM-DD, interpreted as a calendar day in `timezone` (a UTC day when `timezone` is omitted). Defaults to 30 days before `to` when omitted.
+     */
+    from?: string;
+    /**
+     * End date (inclusive) in YYYY-MM-DD, interpreted as a calendar day in `timezone` (a UTC day when `timezone` is omitted). Defaults to today in that timezone when omitted. Window may not exceed 365 days.
+     */
+    to?: string;
+    /**
+     * IANA timezone identifier (for example `Asia/Kathmandu` or `America/New_York`) to report the statistics in. It is the single source of timezone: day and hour boundaries, and the relative window defaults used when `from` and `to` are omitted, are computed in this timezone instead of UTC, so a timezone with a sub-hour offset (such as India at +05:30 or Nepal at +05:45) still gets correct local-day and local-hour totals. When it is set, a `from` or `to` given as a calendar day names a local day in this timezone, and one given as an instant stays an absolute point in time but is rounded down to its hour and bucketed in this timezone (so the hour boundaries are local, not UTC). To avoid specifying the zone twice, a `from` or `to` that carries its own numeric UTC offset (for example `+05:45`) is rejected when `timezone` is set; use a calendar day or a `Z` (UTC) instant instead. Defaults to UTC.
+     *
+     */
+    timezone?: string;
+    /**
+     * Not supported on breakdown endpoints; supplying it returns 422. To compare categories use `GET /v1/email/stats/categories`; the summary, daily, and hourly statistics accept `category` as a filter.
+     */
+    category?: string;
+    /**
+     * Metric to rank rows by, applied descending. Defaults to `bounced`. Only bounce counts are sortable; this breakdown has no rates.
+     *
+     */
+    sort?: "bounced" | "bounces.hard" | "bounces.soft" | "bounces.admin" | "bounces.block" | "bounces.undetermined";
+    /**
+     * Maximum number of bounce-code rows to return, ranked by the `sort` field descending.
+     */
+    limit?: number;
+  };
+  url: "/v1/email/stats/bounce-codes";
+};
+type GetEmailStatsByComplaintTypeData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * Start date (inclusive) in YYYY-MM-DD, interpreted as a calendar day in `timezone` (a UTC day when `timezone` is omitted). Defaults to 30 days before `to` when omitted.
+     */
+    from?: string;
+    /**
+     * End date (inclusive) in YYYY-MM-DD, interpreted as a calendar day in `timezone` (a UTC day when `timezone` is omitted). Defaults to today in that timezone when omitted. Window may not exceed 365 days.
+     */
+    to?: string;
+    /**
+     * IANA timezone identifier (for example `Asia/Kathmandu` or `America/New_York`) to report the statistics in. It is the single source of timezone: day and hour boundaries, and the relative window defaults used when `from` and `to` are omitted, are computed in this timezone instead of UTC, so a timezone with a sub-hour offset (such as India at +05:30 or Nepal at +05:45) still gets correct local-day and local-hour totals. When it is set, a `from` or `to` given as a calendar day names a local day in this timezone, and one given as an instant stays an absolute point in time but is rounded down to its hour and bucketed in this timezone (so the hour boundaries are local, not UTC). To avoid specifying the zone twice, a `from` or `to` that carries its own numeric UTC offset (for example `+05:45`) is rejected when `timezone` is set; use a calendar day or a `Z` (UTC) instant instead. Defaults to UTC.
+     *
+     */
+    timezone?: string;
+    /**
+     * Not supported on breakdown endpoints; supplying it returns 422. To compare categories use `GET /v1/email/stats/categories`; the summary, daily, and hourly statistics accept `category` as a filter.
+     */
+    category?: string;
+    /**
+     * Metric to rank rows by, applied descending. Defaults to `complained`, the only sortable metric for this breakdown.
+     *
+     */
+    sort?: "complained";
+    /**
+     * Maximum number of complaint-type rows to return, ranked by `complained` descending.
+     */
+    limit?: number;
+  };
+  url: "/v1/email/stats/complaint-types";
+};
+type GetEmailStatsByBroadcastData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * Start date (inclusive) in YYYY-MM-DD, UTC. Defaults to 30 days before `to` when omitted.
+     */
+    from?: string;
+    /**
+     * End date (inclusive) in YYYY-MM-DD, UTC. Defaults to today (UTC) when omitted. Window may not exceed 365 days.
+     */
+    to?: string;
+    /**
+     * Not supported on breakdown endpoints; supplying it returns 422. To compare categories use `GET /v1/email/stats/categories`; the summary, daily, and hourly statistics accept `category` as a filter.
+     */
+    category?: string;
+    /**
+     * Metric to rank rows by, applied descending. Any count or rate in the response may be used; rows whose rate is undefined (zero denominator) sort last. Defaults to `processed`.
+     *
+     */
+    sort?: EmailStatsSortMetric;
+    /**
+     * Maximum number of broadcast rows to return, ranked by the `sort` field descending.
+     */
+    limit?: number;
+    /**
+     * Requests a per-row `trend` series. Not available for the broadcast breakdown; supplying `true` returns 422.
+     *
+     */
+    include_trend?: boolean;
+    /**
+     * Bucket grain for the `trend` series. Has no effect on this breakdown, where `include_trend` is not available.
+     */
+    trend_grain?: "daily" | "hourly";
+  };
+  url: "/v1/email/stats/broadcasts";
+};
+type ListDomainsData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * Substring match against the domain name (case-insensitive).
+     */
+    name?: string;
+    /**
+     * Field to sort by.
+     */
+    sort?: "created_at" | "name";
+    /**
+     * Sort direction. Defaults to `desc` (newest/largest first).
+     *
+     */
+    order?: "asc" | "desc";
+    /**
+     * 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;
     /**
-     * Metric to rank rows by, applied descending. Defaults to `unique_opens`. Only engagement counts are sortable; this breakdown has no rates.
-     *
+     * Cursor from the `prev_cursor` field of a previous list response. Returns items immediately before the cursor position in the current sort order.
      */
-    sort?: EmailEngagementSortMetric;
+    ending_before?: string;
     /**
-     * Maximum number of client rows to return, ranked by the `sort` field descending.
+     * When true, the response includes a `total` field with the total number of items matching the request's filters across all pages.
      */
-    limit?: number;
+    include_total?: boolean;
   };
-  url: "/v1/email/stats/clients";
+  url: "/v1/email/domains";
 };
-type GetEmailStatsByBounceCodeData = {
+type ListMailboxesData = {
   body?: never;
   path?: never;
   query?: {
     /**
-     * Start date (inclusive) in YYYY-MM-DD, interpreted as a calendar day in `timezone` (a UTC day when `timezone` is omitted). Defaults to 30 days before `to` when omitted.
+     * Filter to the mailbox with exactly this address.
      */
-    from?: string;
+    address?: string;
     /**
-     * End date (inclusive) in YYYY-MM-DD, interpreted as a calendar day in `timezone` (a UTC day when `timezone` is omitted). Defaults to today in that timezone when omitted. Window may not exceed 365 days.
+     * Case-insensitive search matching the mailbox's address or display name (substring).
      */
-    to?: string;
+    q?: string;
     /**
-     * IANA timezone identifier (for example `Asia/Kathmandu` or `America/New_York`) to report the statistics in. It is the single source of timezone: day and hour boundaries, and the relative window defaults used when `from` and `to` are omitted, are computed in this timezone instead of UTC, so a timezone with a sub-hour offset (such as India at +05:30 or Nepal at +05:45) still gets correct local-day and local-hour totals. When it is set, a `from` or `to` given as a calendar day names a local day in this timezone, and one given as an instant stays an absolute point in time but is rounded down to its hour and bucketed in this timezone (so the hour boundaries are local, not UTC). To avoid specifying the zone twice, a `from` or `to` that carries its own numeric UTC offset (for example `+05:45`) is rejected when `timezone` is set; use a calendar day or a `Z` (UTC) instant instead. Defaults to UTC.
-     *
+     * Filter by lifecycle state.
      */
-    timezone?: string;
+    state?: "active" | "suspended";
     /**
-     * Not supported on breakdown endpoints; supplying it returns 422. To compare categories use `GET /v1/email/stats/categories`; the summary, daily, and hourly statistics accept `category` as a filter.
+     * Filter to mailboxes whose address is on this domain.
      */
-    category?: string;
+    domain?: string;
     /**
-     * Metric to rank rows by, applied descending. Defaults to `bounced`. Only bounce counts are sortable; this breakdown has no rates.
-     *
+     * Include mailboxes deleted within their 30-day restore window. Defaults to false, so only active and suspended mailboxes are returned. Deleted mailboxes carry a non-null `deleted_at`.
      */
-    sort?: "bounced" | "bounces.hard" | "bounces.soft" | "bounces.admin" | "bounces.block" | "bounces.undetermined";
+    include_deleted?: boolean;
     /**
-     * Maximum number of bounce-code rows to return, ranked by the `sort` field descending.
+     * 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;
   };
-  url: "/v1/email/stats/bounce-codes";
+  url: "/v1/email/mailboxes";
 };
-type GetEmailStatsByComplaintTypeData = {
+type GetMailboxStatsData = {
   body?: never;
-  path?: never;
+  path: {
+    /**
+     * Mailbox ID.
+     */
+    mailbox_id: MailboxId;
+  };
   query?: {
     /**
-     * Start date (inclusive) in YYYY-MM-DD, interpreted as a calendar day in `timezone` (a UTC day when `timezone` is omitted). Defaults to 30 days before `to` when omitted.
+     * Inclusive start of the window: a calendar day (YYYY-MM-DD, `day` granularity only) or an RFC 3339 instant rounded down to the hour (`hour` granularity only). Interpreted in `timezone`, or in UTC when `timezone` is omitted. A numeric UTC offset is rejected when `timezone` is set; use a calendar day or a `Z` (UTC) instant. Must use the same form as `to`. Defaults to 30 days before `to` at `day` granularity and 7 days before `to` at `hour`, when omitted.
+     *
      */
     from?: string;
     /**
-     * End date (inclusive) in YYYY-MM-DD, interpreted as a calendar day in `timezone` (a UTC day when `timezone` is omitted). Defaults to today in that timezone when omitted. Window may not exceed 365 days.
+     * Inclusive end of the window: a calendar day (YYYY-MM-DD, `day` granularity only) or an RFC 3339 instant rounded down to the hour (`hour` granularity only). Interpreted in `timezone`, or in UTC when `timezone` is omitted. A numeric UTC offset is rejected when `timezone` is set; use a calendar day or a `Z` (UTC) instant. Must use the same form as `from`. Defaults to today (day) or the current hour (hour) in that timezone when omitted. Window may not exceed 365 days at `day` or 30 days at `hour` granularity.
+     *
      */
     to?: string;
     /**
@@ -5463,75 +6317,114 @@ type GetEmailStatsByComplaintTypeData = {
      */
     timezone?: string;
     /**
-     * Not supported on breakdown endpoints; supplying it returns 422. To compare categories use `GET /v1/email/stats/categories`; the summary, daily, and hourly statistics accept `category` as a filter.
+     * Bucket grain of the series: `day` (default) or `hour`. Echoed back as `period.grain`.
+     *
      */
-    category?: string;
+    granularity?: "day" | "hour";
+  };
+  url: "/v1/email/mailboxes/{mailbox_id}/stats";
+};
+type ListMailboxReceiveRulesData = {
+  body?: never;
+  path: {
     /**
-     * Metric to rank rows by, applied descending. Defaults to `complained`, the only sortable metric for this breakdown.
-     *
+     * Mailbox ID.
      */
-    sort?: "complained";
+    mailbox_id: MailboxId;
+  };
+  query?: {
     /**
-     * Maximum number of complaint-type rows to return, ranked by `complained` descending.
+     * Filter by rule action.
+     */
+    action?: "allow" | "block";
+    /**
+     * 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;
   };
-  url: "/v1/email/stats/complaint-types";
+  url: "/v1/email/mailboxes/{mailbox_id}/receive-rules";
 };
-type GetEmailStatsByBroadcastData = {
+type ListEmailThreadsData = {
   body?: never;
   path?: never;
   query?: {
     /**
-     * Start date (inclusive) in YYYY-MM-DD, UTC. Defaults to 30 days before `to` when omitted.
+     * Filter to conversations in a specific mailbox.
      */
-    from?: string;
+    mailbox_id?: MailboxId;
     /**
-     * End date (inclusive) in YYYY-MM-DD, UTC. Defaults to today (UTC) when omitted. Window may not exceed 365 days.
+     * Filter to conversations linked to a specific contact.
      */
-    to?: string;
+    contact_id?: ContactId;
     /**
-     * Not supported on breakdown endpoints; supplying it returns 422. To compare categories use `GET /v1/email/stats/categories`; the summary, daily, and hourly statistics accept `category` as a filter.
+     * Filter to conversations carrying this label. Repeat the parameter to require several — only conversations carrying every listed label match. A placement label selects a folder (`inbox`, `archive`, `spam`, `blocked`); a custom label matches conversations in any folder. Defaults to `inbox` when omitted.
      */
-    category?: string;
+    label?: Array<string>;
     /**
-     * Metric to rank rows by, applied descending. Any count or rate in the response may be used; rows whose rate is undefined (zero denominator) sort last. Defaults to `processed`.
-     *
+     * When `true`, only conversations with unread messages are returned. This filters on the conversation's unread state, so it combines with `label` — for example, unread conversations in the archive. (The `unread` label itself lives on messages, not conversations.)
      */
-    sort?: EmailStatsSortMetric;
+    has_unread?: boolean;
     /**
-     * Maximum number of broadcast rows to return, ranked by the `sort` field descending.
+     * Conversations involving this address — matches the sender or any recipient, as a case-insensitive contains-match, so a full address or any fragment of one works.
+     */
+    participant?: string;
+    /**
+     * Conversations whose subject contains this text (case-insensitive).
+     */
+    subject?: string;
+    /**
+     * Filter to conversations whose most recent message is at or after this time. This is a time filter, not a cursor.
+     */
+    after?: string;
+    /**
+     * Filter to conversations whose most recent message is at or before this time. This is a time filter, not a cursor.
+     */
+    before?: string;
+    /**
+     * Maximum number of items to return per page.
      */
     limit?: number;
     /**
-     * Requests a per-row `trend` series. Not available for the broadcast breakdown; supplying `true` returns 422.
-     *
+     * Cursor from the `next_cursor` field of a previous list response. Returns items immediately after the cursor position in the current sort order.
      */
-    include_trend?: boolean;
+    starting_after?: string;
     /**
-     * Bucket grain for the `trend` series. Has no effect on this breakdown, where `include_trend` is not available.
+     * Cursor from the `prev_cursor` field of a previous list response. Returns items immediately before the cursor position in the current sort order.
      */
-    trend_grain?: "daily" | "hourly";
+    ending_before?: string;
   };
-  url: "/v1/email/stats/broadcasts";
+  url: "/v1/email/threads";
 };
-type ListDomainsData = {
+type ListEmailThreadMessagesData = {
   body?: never;
-  path?: never;
-  query?: {
+  path: {
     /**
-     * Substring match against the domain name (case-insensitive).
+     * Thread ID.
      */
-    name?: string;
+    thread_id: ThreadId;
+  };
+  query?: {
     /**
-     * Field to sort by.
+     * Filter to received (`inbound`) or sent (`outbound`) messages.
      */
-    sort?: "created_at" | "name";
+    direction?: "inbound" | "outbound";
     /**
-     * Sort direction. Defaults to `desc` (newest/largest first).
+     * Filter to messages carrying this label. `trash` lists trashed messages; any other label — `archive`, `spam`, `blocked`, `unread`, or a custom label — lists its non-trashed carriers. When omitted, received messages in the inbox and all sent messages are returned.
      *
      */
-    order?: "asc" | "desc";
+    label?: string;
+    /**
+     * Set to `extracted_text` to inline each message's extracted plain text.
+     */
+    include?: "extracted_text";
     /**
      * Maximum number of items to return per page.
      */
@@ -5544,12 +6437,8 @@ type ListDomainsData = {
      * 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;
-    /**
-     * When true, the response includes a `total` field with the total number of items matching the request's filters across all pages.
-     */
-    include_total?: boolean;
   };
-  url: "/v1/email/domains";
+  url: "/v1/email/threads/{thread_id}/messages";
 };
 //#endregion
 //#region src/generated/core/auth.gen.d.ts
@@ -5884,51 +6773,26 @@ declare abstract class Resource {
   protected paginated<T>(method: string, options: RequestOptions | undefined, invoke: (ctx: CallContext, cursor: string | undefined) => Promise<FetchOutcome<CursorPage<T>>>): PaginatedPromise<T>;
 }
 //#endregion
-//#region src/resources/emailStats.d.ts
-/** Query params for `bird.email.stats.summary`. */
+//#region src/resources/emailStats.gen.d.ts
 type EmailStatsSummaryQuery = NonNullable<GetEmailStatsSummaryData["query"]>;
-/** Query params for `bird.email.stats.daily`. */
 type EmailStatsDailyQuery = NonNullable<GetEmailStatsDailyData["query"]>;
-/** Query params for `bird.email.stats.hourly`. */
 type EmailStatsHourlyQuery = NonNullable<GetEmailStatsHourlyData["query"]>;
-/** Query params for `bird.email.stats.byTag`. */
 type EmailStatsByTagQuery = NonNullable<GetEmailStatsByTagData["query"]>;
-/** Query params for `bird.email.stats.byCategory`. */
 type EmailStatsByCategoryQuery = NonNullable<GetEmailStatsByCategoryData["query"]>;
-/** Query params for `bird.email.stats.bySendingIp`. */
 type EmailStatsBySendingIpQuery = NonNullable<GetEmailStatsBySendingIpData["query"]>;
-/** Query params for `bird.email.stats.bySendingDomain`. */
 type EmailStatsBySendingDomainQuery = NonNullable<GetEmailStatsBySendingDomainData["query"]>;
-/** Query params for `bird.email.stats.byRecipientDomain`. */
 type EmailStatsByRecipientDomainQuery = NonNullable<GetEmailStatsByRecipientDomainData["query"]>;
-/** Query params for `bird.email.stats.byMailboxProvider`. */
 type EmailStatsByMailboxProviderQuery = NonNullable<GetEmailStatsByMailboxProviderData["query"]>;
-/** Query params for `bird.email.stats.byMailboxProviderRegion`. */
 type EmailStatsByMailboxProviderRegionQuery = NonNullable<GetEmailStatsByMailboxProviderRegionData["query"]>;
-/** Query params for `bird.email.stats.byTemplate`. */
 type EmailStatsByTemplateQuery = NonNullable<GetEmailStatsByTemplateData["query"]>;
-/** Query params for `bird.email.stats.byLocation`. */
 type EmailStatsByLocationQuery = NonNullable<GetEmailStatsByLocationData["query"]>;
-/** Query params for `bird.email.stats.byClient`. */
 type EmailStatsByClientQuery = NonNullable<GetEmailStatsByClientData["query"]>;
-/** Query params for `bird.email.stats.byBounceCode`. */
 type EmailStatsByBounceCodeQuery = NonNullable<GetEmailStatsByBounceCodeData["query"]>;
-/** Query params for `bird.email.stats.byComplaintType`. */
 type EmailStatsByComplaintTypeQuery = NonNullable<GetEmailStatsByComplaintTypeData["query"]>;
-/** Query params for `bird.email.stats.byBroadcast`. */
 type EmailStatsByBroadcastQuery = NonNullable<GetEmailStatsByBroadcastData["query"]>;
-/**
- * `bird.email.stats` — read-only email statistics. Every method takes an
- * optional query object (window, timezone, and — for breakdowns — `limit` and
- * `sort`) and resolves the typed aggregate or breakdown for that window. These
- * are point reads, not cursor lists, so each returns an `APIPromise`, not a
- * paginated iterator. Reached as `bird.email.stats.*`.
- */
 declare class EmailStatsResource extends Resource {
   /**
-   * Aggregate delivery, engagement, and latency for a window. Pass
-   * `compare: "previous_period"` to also get the preceding window and the
-   * change between the two.
+   * Aggregate email KPIs for one period: sends, delivered, bounces, complaints, opens, clicks, their rates, and latency percentiles. `from`/`to` are both YYYY-MM-DD days or both RFC 3339 instants (hour grain); add `compare=previous_period` for deltas versus the prior window. For a per-day or per-hour series use email_stats_daily or email_stats_hourly.
    *
    * @example Summary for a month
    * const s = await bird.email.stats.summary({ from: "2026-05-01", to: "2026-05-31" });
@@ -5936,23 +6800,23 @@ declare class EmailStatsResource extends Resource {
    */
   summary(query?: EmailStatsSummaryQuery, options?: RequestOptions): APIPromise<EmailStatsSummary>;
   /**
-   * Daily time series — one row per calendar day in the window.
+   * Per-day email stats series (counts, rates, latency percentiles), gap-filled with zero rows, max 365 days. At most one filter of `category`, `sending_domain`, `tag`, `sending_ip`, `recipient_domain`, `template`. For hour resolution use email_stats_hourly; for one aggregate row use email_stats_summary.
    *
-   * @example Per-day series for a month
+   * @example
    * const series = await bird.email.stats.daily({ from: "2026-05-01", to: "2026-05-31" });
    * for (const row of series.data) console.log(row.bucket, row.delivery.delivered);
    */
   daily(query?: EmailStatsDailyQuery, options?: RequestOptions): APIPromise<EmailStatsResponse>;
   /**
-   * Hourly time series — one row per hour in the window (max 720 hours).
+   * Per-hour email stats series, gap-filled with zero rows, max 720 hours (30 days). Takes the same single-dimension filters as email_stats_daily; for longer ranges use email_stats_daily, for one aggregate row use email_stats_summary.
    *
-   * @example Per-hour series for a day
+   * @example
    * const series = await bird.email.stats.hourly({ from: "2026-05-01", to: "2026-05-02" });
    * for (const row of series.data) console.log(row.bucket, row.delivery.delivered);
    */
   hourly(query?: EmailStatsHourlyQuery, options?: RequestOptions): APIPromise<EmailStatsResponse>;
   /**
-   * Breakdown by tag, ranked by `sort` (default `processed`) descending.
+   * Email delivery and engagement stats grouped by tag, one row per `name:value` pair set at send time; ranked by `sort` (default `processed`). `include_trend=true` adds a per-bucket rate series to each row.
    *
    * @example Top 10 tags by delivered
    * const { data } = await bird.email.stats.byTag({
@@ -5965,17 +6829,17 @@ declare class EmailStatsResource extends Resource {
    */
   byTag(query?: EmailStatsByTagQuery, options?: RequestOptions): APIPromise<EmailStatsTagsResponse>;
   /**
-   * Breakdown by category (`transactional` / `marketing`).
+   * Email delivery and engagement stats grouped by category (`transactional` versus `marketing`), ranked by `sort` (default `processed`). `include_trend=true` adds a per-bucket rate series to each row.
    *
-   * @example By category for a month
+   * @example
    * const { data } = await bird.email.stats.byCategory({ from: "2026-05-01", to: "2026-05-31" });
    * for (const row of data) console.log(row.category, row.delivery.delivered);
    */
   byCategory(query?: EmailStatsByCategoryQuery, options?: RequestOptions): APIPromise<EmailStatsByCategoryResponse>;
   /**
-   * Breakdown by sending IP, ranked by `sort` (default `delivered`) descending.
+   * Delivery and bounce stats grouped by sending IP; `sort=bounces.block` surfaces reputation-damaged IPs first. No engagement, complaint, or accepted/processed counts per IP; use email_stats_daily for workspace-wide figures.
    *
-   * @example IPs with the most block bounces
+   * @example
    * const { data } = await bird.email.stats.bySendingIp({
    *   from: "2026-05-01",
    *   to: "2026-05-31",
@@ -5986,9 +6850,9 @@ declare class EmailStatsResource extends Resource {
    */
   bySendingIp(query?: EmailStatsBySendingIpQuery, options?: RequestOptions): APIPromise<EmailStatsBySendingIpResponse>;
   /**
-   * Breakdown by sending domain.
+   * Email delivery and engagement stats grouped by sending (`From`) domain; compare deliverability across the workspace's verified domains. For per-IP reputation use email_stats_by_sending_ip.
    *
-   * @example By sending domain
+   * @example
    * const { data } = await bird.email.stats.bySendingDomain({
    *   from: "2026-05-01",
    *   to: "2026-05-31",
@@ -5999,9 +6863,9 @@ declare class EmailStatsResource extends Resource {
    */
   bySendingDomain(query?: EmailStatsBySendingDomainQuery, options?: RequestOptions): APIPromise<EmailStatsBySendingDomainResponse>;
   /**
-   * Breakdown by recipient mailbox domain (e.g. `gmail.com`).
+   * Email delivery and engagement stats grouped by exact recipient mailbox domain (for example `gmail.com`). Finer-grained than email_stats_by_mailbox_provider, which buckets domains into providers.
    *
-   * @example Recipient domains with the highest bounce rate
+   * @example
    * const { data } = await bird.email.stats.byRecipientDomain({
    *   from: "2026-05-01",
    *   to: "2026-05-31",
@@ -6012,9 +6876,9 @@ declare class EmailStatsResource extends Resource {
    */
   byRecipientDomain(query?: EmailStatsByRecipientDomainQuery, options?: RequestOptions): APIPromise<EmailStatsByRecipientDomainResponse>;
   /**
-   * Breakdown by mailbox provider (e.g. Google, Microsoft).
+   * Email delivery and engagement stats grouped by recipient mailbox provider (`gmail`, `microsoft`, `yahoo`, ...); covers the delivery stage onward, no accepted/processed counts. For a per-region split use email_stats_by_mailbox_provider_region; for exact destination domains use email_stats_by_recipient_domain.
    *
-   * @example By mailbox provider
+   * @example
    * const { data } = await bird.email.stats.byMailboxProvider({
    *   from: "2026-05-01",
    *   to: "2026-05-31",
@@ -6024,9 +6888,9 @@ declare class EmailStatsResource extends Resource {
    */
   byMailboxProvider(query?: EmailStatsByMailboxProviderQuery, options?: RequestOptions): APIPromise<EmailStatsByMailboxProviderResponse>;
   /**
-   * Breakdown by mailbox provider and region.
+   * Email delivery and engagement stats grouped by mailbox provider and provider region pair (for example `gmail` in `NA`); covers the delivery stage onward, no accepted/processed counts. For the provider-level view use email_stats_by_mailbox_provider.
    *
-   * @example By mailbox provider and region
+   * @example
    * const { data } = await bird.email.stats.byMailboxProviderRegion({
    *   from: "2026-05-01",
    *   to: "2026-05-31",
@@ -6036,9 +6900,9 @@ declare class EmailStatsResource extends Resource {
    */
   byMailboxProviderRegion(query?: EmailStatsByMailboxProviderRegionQuery, options?: RequestOptions): APIPromise<EmailStatsByMailboxProviderRegionResponse>;
   /**
-   * Breakdown by template (by `emt_…` ID or name).
+   * Email delivery and engagement stats grouped by the template used at send time, keyed by template id (`emt_…`); only templated sends appear. To track a single template over time, pass `template` to email_stats_daily instead.
    *
-   * @example By template
+   * @example
    * const { data } = await bird.email.stats.byTemplate({
    *   from: "2026-05-01",
    *   to: "2026-05-31",
@@ -6049,9 +6913,9 @@ declare class EmailStatsResource extends Resource {
    */
   byTemplate(query?: EmailStatsByTemplateQuery, options?: RequestOptions): APIPromise<EmailStatsByTemplateResponse>;
   /**
-   * Breakdown by recipient geographic location.
+   * Opens and clicks grouped by country, region, or city (`group_by`); engagement counts only, no delivery counts or rates. For engagement by mail client or device use email_stats_by_client.
    *
-   * @example By location
+   * @example
    * const { data } = await bird.email.stats.byLocation({
    *   from: "2026-05-01",
    *   to: "2026-05-31",
@@ -6061,9 +6925,9 @@ declare class EmailStatsResource extends Resource {
    */
   byLocation(query?: EmailStatsByLocationQuery, options?: RequestOptions): APIPromise<EmailStatsByLocationResponse>;
   /**
-   * Breakdown by opening client (the application that opened the message).
+   * Opens and clicks grouped by mail client, OS, or device type (`group_by`); engagement counts only, no delivery counts or rates. For engagement by geography use email_stats_by_location.
    *
-   * @example By client
+   * @example
    * const { data } = await bird.email.stats.byClient({
    *   from: "2026-05-01",
    *   to: "2026-05-31",
@@ -6073,9 +6937,9 @@ declare class EmailStatsResource extends Resource {
    */
   byClient(query?: EmailStatsByClientQuery, options?: RequestOptions): APIPromise<EmailStatsByClientResponse>;
   /**
-   * Breakdown by bounce code — which SMTP/enhanced codes drove bounces.
+   * Bounce counts grouped by the SMTP error code the receiving server returned, with the hard/soft/admin/block/undetermined split; failure side only. Use it to find what is driving bounces; for bounces by destination use email_stats_by_recipient_domain or email_stats_by_mailbox_provider.
    *
-   * @example By bounce code
+   * @example
    * const { data } = await bird.email.stats.byBounceCode({
    *   from: "2026-05-01",
    *   to: "2026-05-31",
@@ -6086,17 +6950,17 @@ declare class EmailStatsResource extends Resource {
    */
   byBounceCode(query?: EmailStatsByBounceCodeQuery, options?: RequestOptions): APIPromise<EmailStatsByBounceCodeResponse>;
   /**
-   * Breakdown by complaint type.
+   * Spam-complaint counts grouped by the feedback-loop complaint type (for example `abuse`, `fraud`, `virus`); complaint side only. For complaints by destination use email_stats_by_mailbox_provider or email_stats_by_recipient_domain.
    *
-   * @example By complaint type
+   * @example
    * const { data } = await bird.email.stats.byComplaintType({ from: "2026-05-01", to: "2026-05-31" });
    * for (const row of data) console.log(row.feedback_type, row.complained);
    */
   byComplaintType(query?: EmailStatsByComplaintTypeQuery, options?: RequestOptions): APIPromise<EmailStatsByComplaintTypeResponse>;
   /**
-   * Breakdown by broadcast.
+   * Email delivery and engagement stats grouped by broadcast; only broadcast sends appear. Reflects roughly the last 30 days of activity; `include_trend` is not available here and returns 422.
    *
-   * @example By broadcast
+   * @example
    * const { data } = await bird.email.stats.byBroadcast({
    *   from: "2026-05-01",
    *   to: "2026-05-31",
@@ -6470,32 +7334,12 @@ declare class ContactPropertiesResource extends Resource {
   unarchive(propertyId: string, options?: RequestOptions): APIPromise<ContactProperty>;
 }
 //#endregion
-//#region src/resources/contacts.d.ts
-/** Body for `bird.contacts.create`. */
-type ContactCreateParams = ContactCreateRequest;
-/** Body for `bird.contacts.update` — a partial patch. */
-type ContactUpdateParams = ContactUpdateRequest;
-/** Body for `bird.contacts.batch` — create-or-update many contacts in one call. */
-type ContactBatchParams = ContactUpsertRequest;
-/** Filters and cursor params for `bird.contacts.list`. */
+//#region src/resources/contacts.gen.d.ts
 type ContactListQuery = NonNullable<ListContactsData["query"]>;
-declare class ContactsResource extends Resource {
+type ContactCreateParams = NonNullable<CreateContactData["body"]>;
+declare class ContactsResourceBase extends Resource {
   /**
-   * Create a contact. `email` is required and unique within the workspace; set
-   * custom fields via `data` (each key a property defined in contact properties).
-   *
-   * @example Create a contact
-   * const contact = await bird.contacts.create({
-   *   email: "jane@acme.com",
-   *   first_name: "Jane",
-   * });
-   * console.log(contact.id); // "con_…"
-   */
-  create(params: ContactCreateParams, options?: RequestOptions): APIPromise<Contact>;
-  /**
-   * List the workspace's contacts, newest first. `await` resolves the first page;
-   * `for await` walks every contact across pages. Filter by `email`,
-   * `external_id`, or a `q` search term.
+   * List the workspace's contacts as a cursor page, newest first. Look one up by exact email or external_id, or search by email substring.
    *
    * @example Iterate every contact, or take one page
    * for await (const contact of bird.contacts.list({ q: "acme.com" })) {
@@ -6505,29 +7349,48 @@ declare class ContactsResource extends Resource {
    */
   list(query?: ContactListQuery, options?: RequestOptions): PaginatedPromise<Contact>;
   /**
-   * Fetch a single contact by id.
+   * Get a single contact by ID (`con_`-prefixed). Look up an ID by exact email or external_id with `contacts.list`.
    *
-   * @example
+   * @example Fetch a contact by id
    * const contact = await bird.contacts.get("con_01krdgeqcxet5s7t44vh8rt9mg");
-   * contact.email;
+   * console.log(contact.email, contact.first_name);
    */
   get(contactId: string, options?: RequestOptions): APIPromise<Contact>;
   /**
-   * Update a contact. Only the fields you send change.
+   * Create a contact by email address in the workspace. Fails with a conflict if the email or external_id is already used by another contact. For bulk import or create-or-update semantics use `contacts.batch`.
    *
-   * @example
-   * const contact = await bird.contacts.update("con_01krdgeqcxet5s7t44vh8rt9mg", {
+   * @example Create a contact
+   * const contact = await bird.contacts.create({
+   *   email: "jane@acme.com",
    *   first_name: "Jane",
    * });
+   * console.log(contact.id); // "con_…"
    */
-  update(contactId: string, params: ContactUpdateParams, options?: RequestOptions): APIPromise<Contact>;
+  create(params: ContactCreateParams, options?: RequestOptions): APIPromise<Contact>;
   /**
-   * Delete a contact by id.
+   * Delete a contact and remove it from every audience it belongs to. Suppression records for the address are unaffected.
    *
-   * @example
+   * @example Delete a contact by id
    * await bird.contacts.delete("con_01krdgeqcxet5s7t44vh8rt9mg");
    */
   delete(contactId: string, options?: RequestOptions): APIPromise<void>;
+}
+//#endregion
+//#region src/resources/contacts.d.ts
+/** Body for `bird.contacts.update` — a partial patch. */
+type ContactUpdateParams = ContactUpdateRequest;
+/** Body for `bird.contacts.batch` — create-or-update many contacts in one call. */
+type ContactBatchParams = ContactUpsertRequest;
+declare class ContactsResource extends ContactsResourceBase {
+  /**
+   * Update a contact. Only the fields you send change.
+   *
+   * @example
+   * const contact = await bird.contacts.update("con_01krdgeqcxet5s7t44vh8rt9mg", {
+   *   first_name: "Jane",
+   * });
+   */
+  update(contactId: string, params: ContactUpdateParams, options?: RequestOptions): APIPromise<Contact>;
   /**
    * Create or update many contacts in one call, matched by email. Returns a
    * per-contact result.
@@ -6798,6 +7661,226 @@ declare class WebhooksResource {
   unwrap(payload: string, headers: WebhookHeaders, options?: WebhookOptions): BirdWebhookEvent;
 }
 //#endregion
+//#region src/resources/mailbox.d.ts
+/** Parameters for creating a mailbox. */
+type MailboxCreateParams = MailboxCreate;
+/** Partial update for a mailbox; omitted fields are unchanged. */
+type MailboxUpdateParams = MailboxUpdate;
+/** Filters for `bird.mailbox.list`. */
+type MailboxListQuery = NonNullable<ListMailboxesData["query"]>;
+/** Stats query parameters. */
+type MailboxStatsQuery = NonNullable<GetMailboxStatsData["query"]>;
+/** Parameters for composing a new message from a mailbox. */
+type MailboxComposeParams = EmailMailboxComposeRequest;
+/** Parameters for creating a receive rule. */
+type MailboxReceiveRuleCreateParams = ReceiveRuleCreate;
+/** Filters for `bird.mailboxReceiveRule.list`. */
+type MailboxReceiveRuleListQuery = NonNullable<ListMailboxReceiveRulesData["query"]>;
+declare class MailboxResource extends Resource {
+  /**
+   * Create a mailbox. Omit `local_part` to auto-generate a handle on inbox.ai.
+   *
+   * @example Create a mailbox
+   * const mailbox = await bird.mailbox.create({ display_name: "Support" });
+   * console.log(mailbox.address); // "abc123@inbox.ai"
+   */
+  create(params?: MailboxCreateParams, options?: RequestOptions): APIPromise<Mailbox>;
+  /**
+   * Get a mailbox by id.
+   *
+   * @example Get a mailbox
+   * const mailbox = await bird.mailbox.get("mbx_01abc");
+   * console.log(mailbox.state); // "active"
+   */
+  get(mailboxId: string, options?: RequestOptions): APIPromise<Mailbox>;
+  /**
+   * Update a mailbox. Only the fields you provide change.
+   *
+   * @example Update receive policy
+   * const mailbox = await bird.mailbox.update("mbx_01abc", { receive_policy: "open" });
+   */
+  update(mailboxId: string, params: MailboxUpdateParams, options?: RequestOptions): APIPromise<Mailbox>;
+  /**
+   * Soft-delete a mailbox. It can be restored within 30 days.
+   *
+   * @example Delete a mailbox
+   * await bird.mailbox.delete("mbx_01abc");
+   */
+  delete(mailboxId: string, options?: RequestOptions): APIPromise<void>;
+  /**
+   * Restore a deleted mailbox within its 30-day window.
+   *
+   * @example Restore a mailbox
+   * const mailbox = await bird.mailbox.restore("mbx_01abc");
+   */
+  restore(mailboxId: string, options?: RequestOptions): APIPromise<Mailbox>;
+  /**
+   * Reactivate a suspended mailbox.
+   *
+   * @example Resume a mailbox
+   * const mailbox = await bird.mailbox.resume("mbx_01abc");
+   */
+  resume(mailboxId: string, options?: RequestOptions): APIPromise<Mailbox>;
+  /**
+   * Get email activity statistics for a mailbox.
+   *
+   * @example Get mailbox stats
+   * const stats = await bird.mailbox.stats("mbx_01abc");
+   * console.log(stats.summary?.sends_accepted);
+   */
+  stats(mailboxId: string, query?: MailboxStatsQuery, options?: RequestOptions): APIPromise<MailboxStatsResponse>;
+  /**
+   * Send a new email from this mailbox, starting a new conversation.
+   *
+   * @example Send from a mailbox
+   * const msg = await bird.mailbox.compose("mbx_01abc", {
+   *   to: ["customer@example.com"],
+   *   subject: "Hello",
+   *   text: "Hi there!",
+   * });
+   */
+  compose(mailboxId: string, params: MailboxComposeParams, options?: RequestOptions): APIPromise<EmailThreadMessage>;
+  /**
+   * List labels available in a mailbox.
+   *
+   * @example List labels
+   * const labels = await bird.mailbox.labels("mbx_01abc");
+   * console.log(labels.data.map(l => l.name));
+   */
+  labels(mailboxId: string, options?: RequestOptions): APIPromise<EmailMailboxLabelList>;
+  /**
+   * List mailboxes in the workspace. `await` resolves the first page;
+   * `for await` walks every mailbox.
+   *
+   * @example List mailboxes
+   * for await (const mailbox of bird.mailbox.list()) {
+   *   console.log(mailbox.address);
+   * }
+   */
+  list(query?: MailboxListQuery, options?: RequestOptions): PaginatedPromise<Mailbox>;
+}
+declare class MailboxReceiveRuleResource extends Resource {
+  /**
+   * Add an allow or block rule to a mailbox. Block rules always win.
+   *
+   * @example Block a domain
+   * const rule = await bird.mailboxReceiveRule.create("mbx_01abc", {
+   *   action: "block",
+   *   entry: "spam.example.com",
+   * });
+   */
+  create(mailboxId: string, params: MailboxReceiveRuleCreateParams, options?: RequestOptions): APIPromise<ReceiveRule>;
+  /**
+   * Remove a receive rule.
+   *
+   * @example Delete a rule
+   * await bird.mailboxReceiveRule.delete("mbx_01abc", "erl_01xyz");
+   */
+  delete(mailboxId: string, ruleId: string, options?: RequestOptions): APIPromise<void>;
+  /**
+   * List receive rules for a mailbox.
+   *
+   * @example List rules
+   * for await (const rule of bird.mailboxReceiveRule.list("mbx_01abc")) {
+   *   console.log(rule.action, rule.entry);
+   * }
+   */
+  list(mailboxId: string, query?: MailboxReceiveRuleListQuery, options?: RequestOptions): PaginatedPromise<ReceiveRule>;
+}
+//#endregion
+//#region src/resources/mailboxThread.d.ts
+/** Partial update for a thread — add/remove labels, link/unlink a contact. */
+type MailboxThreadUpdateParams = EmailThreadUpdateRequest;
+/** Filters for `bird.mailboxThread.list`. */
+type MailboxThreadListQuery = NonNullable<ListEmailThreadsData["query"]>;
+/** Parameters for `bird.mailboxThreadMessage.reply`. */
+type MailboxThreadMessageReplyParams = EmailThreadMessageReplyRequest;
+/** Filters for `bird.mailboxThreadMessage.list`. */
+type MailboxThreadMessageListQuery = NonNullable<ListEmailThreadMessagesData["query"]>;
+declare class MailboxThreadResource extends Resource {
+  /**
+   * Get a conversation thread.
+   *
+   * @example Get a thread
+   * const thread = await bird.mailboxThread.get("thr_01abc");
+   * console.log(thread.message_count);
+   */
+  get(threadId: string, options?: RequestOptions): APIPromise<EmailThread>;
+  /**
+   * Apply label changes or contact link changes to a thread.
+   *
+   * @example Archive a thread
+   * const thread = await bird.mailboxThread.update("thr_01abc", {
+   *   labels: { add: ["archive"] },
+   * });
+   */
+  update(threadId: string, params: MailboxThreadUpdateParams, options?: RequestOptions): APIPromise<EmailThread>;
+  /**
+   * Move a thread to trash. Pass `query.permanent = true` to delete immediately.
+   *
+   * @example Delete a thread
+   * await bird.mailboxThread.delete("thr_01abc");
+   */
+  delete(threadId: string, query?: {
+    permanent?: boolean;
+  }, options?: RequestOptions): APIPromise<void>;
+  /**
+   * List threads across the workspace's mailboxes. `await` resolves the first
+   * page; `for await` walks every thread.
+   *
+   * @example List threads in the inbox
+   * for await (const thread of bird.mailboxThread.list()) {
+   *   console.log(thread.id, thread.message_count);
+   * }
+   */
+  list(query?: MailboxThreadListQuery, options?: RequestOptions): PaginatedPromise<EmailThread>;
+}
+declare class MailboxThreadMessageResource extends Resource {
+  /**
+   * Get metadata for a message (not the body; use `body` for that).
+   *
+   * @example Get a message
+   * const msg = await bird.mailboxThreadMessage.get("thr_01abc", "rem_01xyz");
+   * console.log(msg.direction); // "inbound"
+   */
+  get(threadId: string, messageId: string, options?: RequestOptions): APIPromise<EmailThreadMessage>;
+  /**
+   * Get the parsed HTML and plain-text body of a message.
+   *
+   * @example Get message body
+   * const body = await bird.mailboxThreadMessage.body("thr_01abc", "rem_01xyz");
+   * console.log(body.text);
+   */
+  body(threadId: string, messageId: string, options?: RequestOptions): APIPromise<EmailThreadMessageBody>;
+  /**
+   * Reply to a message from the mailbox's own address.
+   *
+   * @example Reply to a message
+   * const reply = await bird.mailboxThreadMessage.reply("thr_01abc", "rem_01xyz", {
+   *   text: "Thanks for reaching out!",
+   * });
+   */
+  reply(threadId: string, messageId: string, params: MailboxThreadMessageReplyParams, options?: RequestOptions): APIPromise<EmailThreadMessage>;
+  /**
+   * List the attachment manifest for a message.
+   *
+   * @example List attachments
+   * const atts = await bird.mailboxThreadMessage.attachments("thr_01abc", "rem_01xyz");
+   * console.log(atts.data.map(a => a.filename));
+   */
+  attachments(threadId: string, messageId: string, options?: RequestOptions): APIPromise<EmailThreadMessageAttachmentList>;
+  /**
+   * List messages in a thread. `await` resolves the first page; `for await`
+   * walks every message.
+   *
+   * @example List messages
+   * for await (const msg of bird.mailboxThreadMessage.list("thr_01abc")) {
+   *   console.log(msg.id, msg.direction);
+   * }
+   */
+  list(threadId: string, query?: MailboxThreadMessageListQuery, options?: RequestOptions): PaginatedPromise<EmailThreadMessage>;
+}
+//#endregion
 //#region src/client.d.ts
 interface BirdClientOptions {
   apiKey: string;
@@ -6893,6 +7976,14 @@ declare class BirdClient<const O extends BirdClientOptions = BirdClientOptions>
   readonly domains: DomainsResource;
   /** Webhooks — `bird.webhooks.unwrap(payload, headers)` verifies an inbound delivery. */
   readonly webhooks: WebhooksResource;
+  /** Agent mailboxes — `bird.mailbox.create(...)`, `.compose(...)`, `.list(...)`, … */
+  readonly mailbox: MailboxResource;
+  /** Mailbox receive rules — `bird.mailboxReceiveRule.create(...)`, `.delete(...)`, `.list(...)`. */
+  readonly mailboxReceiveRule: MailboxReceiveRuleResource;
+  /** Mailbox threads — `bird.mailboxThread.list(...)`, `.get(...)`, `.update(...)`, `.delete(...)`. */
+  readonly mailboxThread: MailboxThreadResource;
+  /** Thread messages — `bird.mailboxThreadMessage.list(...)`, `.get(...)`, `.reply(...)`, `.body(...)`, … */
+  readonly mailboxThreadMessage: MailboxThreadMessageResource;
   constructor(options: O);
   /**
    * Escape hatch for endpoints the typed resources don't cover. Runs the full
@@ -6962,9 +8053,9 @@ declare const WebhookEventType: {
   readonly SmsTfnVerificationRejected: "sms.tfn_verification.rejected";
   readonly SmsTfnVerificationSubmitted: "sms.tfn_verification.submitted";
   readonly SmsUndelivered: "sms.undelivered";
-  readonly VoiceCallAnswered: "voice.call.answered";
-  readonly VoiceCallEnded: "voice.call.ended";
-  readonly VoiceCallInitiated: "voice.call.initiated";
+  readonly VoiceCallAnswered: "voice_call.answered";
+  readonly VoiceCallEnded: "voice_call.ended";
+  readonly VoiceCallInitiated: "voice_call.initiated";
   readonly WhatsappAccepted: "whatsapp.accepted";
   readonly WhatsappDelivered: "whatsapp.delivered";
   readonly WhatsappFailed: "whatsapp.failed";
@@ -6975,5 +8066,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 DnsRecord, type Domain, type DomainCapabilities, type DomainCreateParams, type DomainDkim, type DomainListQuery, type DomainUpdateParams, type EmailChannelDefaults, type EmailListQuery, type EmailMessage, type EmailSendBatchParams, type EmailSendBatchResult, type EmailSendParams, type EmailStatsByBounceCodeQuery, type EmailStatsByBounceCodeResponse, type EmailStatsByBroadcastQuery, type EmailStatsByBroadcastResponse, type EmailStatsByCategoryQuery, type EmailStatsByCategoryResponse, type EmailStatsByClientQuery, type EmailStatsByClientResponse, type EmailStatsByComplaintTypeQuery, type EmailStatsByComplaintTypeResponse, type EmailStatsByLocationQuery, type EmailStatsByLocationResponse, type EmailStatsByMailboxProviderQuery, type EmailStatsByMailboxProviderRegionQuery, type EmailStatsByMailboxProviderRegionResponse, type EmailStatsByMailboxProviderResponse, type EmailStatsByRecipientDomainQuery, type EmailStatsByRecipientDomainResponse, type EmailStatsBySendingDomainQuery, type EmailStatsBySendingDomainResponse, type EmailStatsBySendingIpQuery, type EmailStatsBySendingIpResponse, type EmailStatsByTagQuery, type EmailStatsByTemplateQuery, type EmailStatsByTemplateResponse, type EmailStatsDailyQuery, type EmailStatsHourlyQuery, type EmailStatsResponse, type EmailStatsSummary, type EmailStatsSummaryQuery, type EmailStatsTagsResponse, 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 };
+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 DnsRecord, type Domain, type DomainCapabilities, type DomainCreateParams, type DomainDkim, type DomainListQuery, type DomainUpdateParams, type EmailChannelDefaults, type EmailListQuery, type EmailMailboxLabelList, type EmailMessage, type EmailSendBatchParams, type EmailSendBatchResult, type EmailSendParams, type EmailStatsByBounceCodeQuery, type EmailStatsByBounceCodeResponse, type EmailStatsByBroadcastQuery, type EmailStatsByBroadcastResponse, type EmailStatsByCategoryQuery, type EmailStatsByCategoryResponse, type EmailStatsByClientQuery, type EmailStatsByClientResponse, type EmailStatsByComplaintTypeQuery, type EmailStatsByComplaintTypeResponse, type EmailStatsByLocationQuery, type EmailStatsByLocationResponse, type EmailStatsByMailboxProviderQuery, type EmailStatsByMailboxProviderRegionQuery, type EmailStatsByMailboxProviderRegionResponse, type EmailStatsByMailboxProviderResponse, type EmailStatsByRecipientDomainQuery, type EmailStatsByRecipientDomainResponse, type EmailStatsBySendingDomainQuery, type EmailStatsBySendingDomainResponse, type EmailStatsBySendingIpQuery, type EmailStatsBySendingIpResponse, type EmailStatsByTagQuery, type EmailStatsByTemplateQuery, type EmailStatsByTemplateResponse, type EmailStatsDailyQuery, type EmailStatsHourlyQuery, type EmailStatsResponse, type EmailStatsSummary, type EmailStatsSummaryQuery, type EmailStatsTagsResponse, type EmailThread, type EmailThreadList, type EmailThreadMessage, type EmailThreadMessageAttachmentList, type EmailThreadMessageBody, type EmailThreadMessageList, type ErrorDetail, type ErrorNextAction, type Mailbox, type MailboxComposeParams, type MailboxCreateParams, type MailboxList, type MailboxListQuery, type MailboxReceiveRuleCreateParams, type MailboxReceiveRuleListQuery, type MailboxStatsResponse, type MailboxThreadListQuery, type MailboxThreadMessageListQuery, type MailboxThreadMessageReplyParams, type MailboxThreadUpdateParams, type MailboxUpdateParams, type PaginatedPromise, type ReceiveRule, type ReceiveRuleList, 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