@messagebird/sdk 0.11.0 → 0.12.1

package/dist/index.mjs

@@ -2524,6 +2524,428 @@ const verifyDomain = (options) => (options.client ?? client).post({
 	url: "/v1/email/domains/{domain_id}/verify",
 	...options
 });
+/**
+* List mailboxes
+*
+* Returns a paginated list of the workspace's mailboxes, newest first. Search across addresses and display names with `q`, look a mailbox up by its exact address, or filter by lifecycle state or domain.
+*
+*/
+const listMailboxes = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes",
+	...options
+});
+/**
+* Create a mailbox
+*
+* Creates a mailbox. The address is `local_part@domain`. The domain defaults to `inbox.ai`, Bird's shared mailbox domain, where creating the mailbox claims the address for your organization — first come, first served, and reserved to your organization even after the mailbox is deleted. You may instead name one of your own domains that is enabled for receiving email. An omitted local part is generated. On a custom domain, addresses of deleted mailboxes are quarantined: the same workspace can rebind one 30 days after deletion, other workspaces never can.
+*
+*/
+const createMailbox = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a mailbox
+*
+* Deletes a mailbox. The address stops receiving mail immediately and enters quarantine: the same workspace can bind it to a new mailbox after 30 days, other workspaces never can. The mailbox and its remembered messages are kept for a 30-day restore window — restore it with `POST /email/mailboxes/{mailbox_id}/restore` — and are permanently deleted once the window closes.
+*
+*/
+const deleteMailbox = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}",
+	...options
+});
+/**
+* Get a mailbox
+*
+* Returns a single mailbox by ID. A mailbox deleted within its 30-day restore window is still returned, with a non-null `deleted_at`; once the window closes it is permanently removed and returns 404.
+*
+*/
+const getMailbox = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}",
+	...options
+});
+/**
+* Update a mailbox
+*
+* Updates a mailbox. The address and domain are immutable. Lowering the retention tier deletes remembered messages older than the new horizon — pass `confirm=true` to acknowledge.
+*
+*/
+const updateMailbox = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Restore a deleted mailbox
+*
+* Restores a mailbox deleted less than 30 days ago. The address is bound back to the mailbox and starts receiving again, and the remembered messages and conversations are available as before the delete. Once the 30-day window has passed the mailbox and its messages are permanently deleted and can no longer be restored (404). Restoring a mailbox that is not deleted returns a conflict, as does an address that is no longer available.
+*
+*/
+const restoreMailbox = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}/restore",
+	...options
+});
+/**
+* Mailbox email statistics
+*
+* Returns the mailbox's sent and received email statistics over a time window: a period-wide summary plus a bucketed series. Sent-mail metrics carry the same delivery, engagement, and latency breakdowns as the email stats endpoints; `received` counts mail that arrived at the mailbox.
+* Rows are bucketed by event time, not send time — engagement received during the period for messages sent earlier is included. Statistics start when the mailbox starts sending and receiving; the mailbox's all-time `message_count` and `thread_count` live on the mailbox resource itself.
+* `from` and `to` accept either calendar days (YYYY-MM-DD, `day` granularity only) or RFC 3339 instants (`hour` granularity only). Both bounds must use the same form. Window caps depend on `granularity`: 365 days at `day`, 30 days at `hour`. Set `timezone` to report in a local zone instead of UTC.
+*
+*/
+const getMailboxStats = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}/stats",
+	...options
+});
+/**
+* Resume a suspended mailbox
+*
+* Reactivates a mailbox that was suspended because the organization dropped below the plan needed to keep it active. The mailbox can send and receive again and its threads and messages become visible. Activation is refused when the organization has no room for another active mailbox, or for another custom inbox.ai handle, on its current plan — free up a slot by deleting an active mailbox, or upgrade the plan. Activating a mailbox that is not suspended returns a conflict.
+*
+*/
+const resumeMailbox = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}/resume",
+	...options
+});
+/**
+* List receive rules
+*
+* Returns a paginated list of the mailbox's receive rules, oldest first. Filter by action to see only allow or only block entries.
+*
+*/
+const listMailboxReceiveRules = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}/receive-rules",
+	...options
+});
+/**
+* Add a receive rule
+*
+* Adds an allow or block rule to the mailbox. Rules match the message's envelope sender; domain entries also match subdomains. Block rules always win — over allow rules and over the reply admission on allowlist mailboxes. An entry can be allow or block, never both: to flip it, delete the rule and re-create it. A mailbox holds up to 200 rules.
+*
+*/
+const createMailboxReceiveRule = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}/receive-rules",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a receive rule
+*
+* Removes a receive rule from the mailbox. To change an entry from allow to block (or back), delete the rule and create a new one.
+*
+*/
+const deleteMailboxReceiveRule = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}/receive-rules/{rule_id}",
+	...options
+});
+/**
+* List threads
+*
+* Returns a paginated list of conversations across the workspace's mailboxes, most recently active first. `label` selects the view: the inbox (the default when omitted), `archive`, `spam`, `blocked`, or any custom label. Filter by mailbox, linked contact, or last-activity time, or pass `q` to full-text search conversations by their messages' subject and text. Conversations whose every message has been trashed are omitted; restoring a message returns its conversation to the list. `before` and `after` filter by time; to page through results pass the response cursors back as `starting_after` or `ending_before`.
+*
+*/
+const listEmailThreads = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/threads",
+	...options
+});
+/**
+* Delete a thread
+*
+* Moves the conversation and all of its messages to the trash. Trashed messages are permanently deleted after 30 days. Pass `permanent=true` to permanently delete the conversation and its messages immediately.
+*
+*/
+const deleteEmailThread = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/threads/{thread_id}",
+	...options
+});
+/**
+* Get a thread
+*
+* Returns a single conversation. Fetch the messages in the conversation with `GET /v1/email/threads/{thread_id}/messages`. A thread whose retention period has ended returns `410 Gone`.
+*
+*/
+const getEmailThread = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/threads/{thread_id}",
+	...options
+});
+/**
+* Update a thread
+*
+* Applies label changes to a conversation and links or unlinks a contact. System labels move the conversation: adding `spam` files it (and its received messages) as spam, adding `archive` files it away without deleting it, and adding `inbox` — or removing `spam`, `blocked`, or `archive` — returns it to the inbox; unread counts recompute to match. An archived conversation returns to the inbox by itself when a new message arrives. To block a sender going forward, add a receive rule instead. Omitted fields are left unchanged.
+*
+*/
+const updateEmailThread = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/threads/{thread_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List messages in a thread
+*
+* Returns the messages in a conversation newest first, both received and sent; page older messages with `starting_after` (fixed sort — render conversation order by reversing the page). By default every message that is not in the trash is returned, whichever folder the conversation is in; pass `label` to narrow the view instead — `trash` for trashed messages, or any custom label. Pass `include=extracted_text` to inline each message's extracted plain text. A thread whose retention period has ended returns `410 Gone`.
+*
+*/
+const listEmailThreadMessages = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/threads/{thread_id}/messages",
+	...options
+});
+/**
+* Get a message in a thread
+*
+* Returns a single message in a conversation, including its extracted plain text. Metadata and extracted text remain readable for the mailbox's retention period; a message that has passed it returns `410 Gone`. A message that exists but does not belong to this thread returns `404`.
+*
+*/
+const getEmailThreadMessage = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/threads/{thread_id}/messages/{message_id}",
+	...options
+});
+/**
+* Get a thread message's original body
+*
+* Returns the original rendered HTML and plain-text body of a message in a conversation. The original body is available for 30 days after the message occurred; after that this endpoint returns `410 Gone` while the message's extracted text remains readable on the message itself.
+*
+*/
+const getEmailThreadMessageBody = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/threads/{thread_id}/messages/{message_id}/body",
+	...options
+});
+/**
+* List a thread message's attachments
+*
+* Returns the attachments on a message in a conversation. Attachment bytes are downloadable for 30 days after the message occurred; after that this endpoint returns `410 Gone` while the attachment metadata remains readable on the message's `attachment_manifest`.
+*
+*/
+const listEmailThreadMessageAttachments = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/threads/{thread_id}/messages/{message_id}/attachments",
+	...options
+});
+/**
+* Reply to a thread message
+*
+* Sends a reply to a specific message in a conversation, from the mailbox's own address. 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. The subject and the threading headers that keep the reply in this conversation are set automatically, and the reply is recorded in the conversation. To reply to a conversation as a whole, target its newest received message.
+*
+*/
+const replyEmailThreadMessage = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/threads/{thread_id}/messages/{message_id}/reply",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Send a message from a mailbox
+*
+* Sends a new message from the mailbox's own address and starts a new conversation with it. The request mirrors the plain send request minus `from` — the mailbox is the sender identity — and Bird mints the RFC 5322 Message-ID, so later replies from the recipients thread back into the conversation automatically. The send is recorded in the mailbox's durable memory and returned as the conversation's first message. Scheduled sends are not accepted on the mailbox surface. A suspended mailbox cannot send and returns `403`.
+*
+*/
+const createMailboxMessage = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}/messages",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List a mailbox's labels
+*
+* Returns the labels available in a mailbox: the built-in system labels — the placements `inbox`, `archive`, `spam`, `blocked`, and `sent`, plus `trash` and `unread` — followed by every custom label currently in use on its conversations and messages. Apply and remove labels through the conversation and message update endpoints; custom labels exist by being applied, so this list is discovery, not management.
+*
+*/
+const listMailboxLabels = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}, {
+		in: "cookie",
+		name: "bird_session",
+		type: "apiKey"
+	}],
+	url: "/v1/email/mailboxes/{mailbox_id}/labels",
+	...options
+});
 //#endregion
 //#region src/resources/base.ts
 var Resource = class {
@@ -2564,19 +2986,10 @@ function mergeHeaders(idempotencyKey, extra) {
 	};
 }
 //#endregion
-//#region src/resources/emailStats.ts
-/**
-* `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.*`.
-*/
+//#region src/resources/emailStats.gen.ts
 var EmailStatsResource = class 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" });
@@ -2591,9 +3004,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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);
 	*/
@@ -2606,9 +3019,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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);
 	*/
@@ -2621,7 +3034,7 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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({
@@ -2641,9 +3054,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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);
 	*/
@@ -2656,9 +3069,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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",
@@ -2676,9 +3089,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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",
@@ -2696,9 +3109,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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",
@@ -2716,9 +3129,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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",
@@ -2735,9 +3148,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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",
@@ -2754,9 +3167,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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",
@@ -2774,9 +3187,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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",
@@ -2793,9 +3206,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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",
@@ -2812,9 +3225,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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",
@@ -2832,9 +3245,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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);
 	*/
@@ -2847,9 +3260,9 @@ var EmailStatsResource = class extends Resource {
 		}));
 	}
 	/**
-	* 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",
@@ -3401,64 +3814,79 @@ var ContactPropertiesResource = class extends Resource {
 	}
 };
 //#endregion
-//#region src/resources/contacts.ts
-var ContactsResource = class extends Resource {
+//#region src/resources/contacts.gen.ts
+var ContactsResourceBase = class 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).
+	* 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 Create a contact
-	* const contact = await bird.contacts.create({
-	*   email: "jane@acme.com",
-	*   first_name: "Jane",
-	* });
-	* console.log(contact.id); // "con_…"
+	* @example Iterate every contact, or take one page
+	* for await (const contact of bird.contacts.list({ q: "acme.com" })) {
+	*   console.log(contact.id, contact.email);
+	* }
+	* const page = await bird.contacts.list({ limit: 50 }); // page.data, page.next_cursor
 	*/
-	create(params, options) {
-		return this.call("POST", options, ({ signal, headers }) => createContact({
+	list(query, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listContacts({
 			client: this.client,
-			body: params,
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
 			headers,
 			signal
 		}));
 	}
 	/**
-	* 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.
+	* Get a single contact by ID (`con_`-prefixed). Look up an ID by exact email or external_id with `contacts.list`.
 	*
-	* @example Iterate every contact, or take one page
-	* for await (const contact of bird.contacts.list({ q: "acme.com" })) {
-	*   console.log(contact.id, contact.email);
-	* }
-	* const page = await bird.contacts.list({ limit: 50 }); // page.data, page.next_cursor
+	* @example Fetch a contact by id
+	* const contact = await bird.contacts.get("con_01krdgeqcxet5s7t44vh8rt9mg");
+	* console.log(contact.email, contact.first_name);
 	*/
-	list(query, options) {
-		return this.paginated("GET", options, ({ signal, headers }, cursor) => listContacts({
+	get(contactId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getContact({
+			client: this.client,
+			path: { contact_id: contactId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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 Create a contact
+	* const contact = await bird.contacts.create({
+	*   email: "jane@acme.com",
+	*   first_name: "Jane",
+	* });
+	* console.log(contact.id); // "con_…"
+	*/
+	create(params, options) {
+		return this.call("POST", options, ({ signal, headers }) => createContact({
 			client: this.client,
-			query: {
-				...query,
-				starting_after: cursor ?? query?.starting_after
-			},
+			body: params,
 			headers,
 			signal
 		}));
 	}
 	/**
-	* Fetch a single contact by id.
+	* Delete a contact and remove it from every audience it belongs to. Suppression records for the address are unaffected.
 	*
-	* @example
-	* const contact = await bird.contacts.get("con_01krdgeqcxet5s7t44vh8rt9mg");
-	* contact.email;
+	* @example Delete a contact by id
+	* await bird.contacts.delete("con_01krdgeqcxet5s7t44vh8rt9mg");
 	*/
-	get(contactId, options) {
-		return this.call("GET", options, ({ signal, headers }) => getContact({
+	delete(contactId, options) {
+		return this.call("DELETE", options, ({ signal, headers }) => deleteContact({
 			client: this.client,
 			path: { contact_id: contactId },
 			headers,
 			signal
 		}));
 	}
+};
+//#endregion
+//#region src/resources/contacts.ts
+var ContactsResource = class extends ContactsResourceBase {
 	/**
 	* Update a contact. Only the fields you send change.
 	*
@@ -3477,20 +3905,6 @@ var ContactsResource = class extends Resource {
 		}));
 	}
 	/**
-	* Delete a contact by id.
-	*
-	* @example
-	* await bird.contacts.delete("con_01krdgeqcxet5s7t44vh8rt9mg");
-	*/
-	delete(contactId, options) {
-		return this.call("DELETE", options, ({ signal, headers }) => deleteContact({
-			client: this.client,
-			path: { contact_id: contactId },
-			headers,
-			signal
-		}));
-	}
-	/**
 	* Create or update many contacts in one call, matched by email. Returns a
 	* per-contact result.
 	*
@@ -3853,6 +4267,392 @@ function toHeaderRecord(headers) {
 	return headers instanceof Headers ? Object.fromEntries(headers) : headers;
 }
 //#endregion
+//#region src/resources/mailbox.ts
+var MailboxResource = class 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, options) {
+		return this.call("POST", options, ({ signal, headers }) => createMailbox({
+			client: this.client,
+			body: params ?? {},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Get a mailbox by id.
+	*
+	* @example Get a mailbox
+	* const mailbox = await bird.mailbox.get("mbx_01abc");
+	* console.log(mailbox.state); // "active"
+	*/
+	get(mailboxId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getMailbox({
+			client: this.client,
+			path: { mailbox_id: mailboxId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, params, options) {
+		return this.call("PATCH", options, ({ signal, headers }) => updateMailbox({
+			client: this.client,
+			path: { mailbox_id: mailboxId },
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Soft-delete a mailbox. It can be restored within 30 days.
+	*
+	* @example Delete a mailbox
+	* await bird.mailbox.delete("mbx_01abc");
+	*/
+	delete(mailboxId, options) {
+		return this.call("DELETE", options, ({ signal, headers }) => deleteMailbox({
+			client: this.client,
+			path: { mailbox_id: mailboxId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Restore a deleted mailbox within its 30-day window.
+	*
+	* @example Restore a mailbox
+	* const mailbox = await bird.mailbox.restore("mbx_01abc");
+	*/
+	restore(mailboxId, options) {
+		return this.call("POST", options, ({ signal, headers }) => restoreMailbox({
+			client: this.client,
+			path: { mailbox_id: mailboxId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Reactivate a suspended mailbox.
+	*
+	* @example Resume a mailbox
+	* const mailbox = await bird.mailbox.resume("mbx_01abc");
+	*/
+	resume(mailboxId, options) {
+		return this.call("POST", options, ({ signal, headers }) => resumeMailbox({
+			client: this.client,
+			path: { mailbox_id: mailboxId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, query, options) {
+		return this.call("GET", options, ({ signal, headers }) => getMailboxStats({
+			client: this.client,
+			path: { mailbox_id: mailboxId },
+			query: query ?? {},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, params, options) {
+		return this.call("POST", options, ({ signal, headers }) => createMailboxMessage({
+			client: this.client,
+			path: { mailbox_id: mailboxId },
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, options) {
+		return this.call("GET", options, ({ signal, headers }) => listMailboxLabels({
+			client: this.client,
+			path: { mailbox_id: mailboxId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listMailboxes({
+			client: this.client,
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+};
+var MailboxReceiveRuleResource = class 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, params, options) {
+		return this.call("POST", options, ({ signal, headers }) => createMailboxReceiveRule({
+			client: this.client,
+			path: { mailbox_id: mailboxId },
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Remove a receive rule.
+	*
+	* @example Delete a rule
+	* await bird.mailboxReceiveRule.delete("mbx_01abc", "erl_01xyz");
+	*/
+	delete(mailboxId, ruleId, options) {
+		return this.call("DELETE", options, ({ signal, headers }) => deleteMailboxReceiveRule({
+			client: this.client,
+			path: {
+				mailbox_id: mailboxId,
+				rule_id: ruleId
+			},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, query, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listMailboxReceiveRules({
+			client: this.client,
+			path: { mailbox_id: mailboxId },
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+};
+//#endregion
+//#region src/resources/mailboxThread.ts
+var MailboxThreadResource = class 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, options) {
+		return this.call("GET", options, ({ signal, headers }) => getEmailThread({
+			client: this.client,
+			path: { thread_id: threadId },
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, params, options) {
+		return this.call("PATCH", options, ({ signal, headers }) => updateEmailThread({
+			client: this.client,
+			path: { thread_id: threadId },
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* Move a thread to trash. Pass `query.permanent = true` to delete immediately.
+	*
+	* @example Delete a thread
+	* await bird.mailboxThread.delete("thr_01abc");
+	*/
+	delete(threadId, query, options) {
+		return this.call("DELETE", options, ({ signal, headers }) => deleteEmailThread({
+			client: this.client,
+			path: { thread_id: threadId },
+			query,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listEmailThreads({
+			client: this.client,
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+};
+var MailboxThreadMessageResource = class 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, messageId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getEmailThreadMessage({
+			client: this.client,
+			path: {
+				thread_id: threadId,
+				message_id: messageId
+			},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, messageId, options) {
+		return this.call("GET", options, ({ signal, headers }) => getEmailThreadMessageBody({
+			client: this.client,
+			path: {
+				thread_id: threadId,
+				message_id: messageId
+			},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, messageId, params, options) {
+		return this.call("POST", options, ({ signal, headers }) => replyEmailThreadMessage({
+			client: this.client,
+			path: {
+				thread_id: threadId,
+				message_id: messageId
+			},
+			body: params,
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, messageId, options) {
+		return this.call("GET", options, ({ signal, headers }) => listEmailThreadMessageAttachments({
+			client: this.client,
+			path: {
+				thread_id: threadId,
+				message_id: messageId
+			},
+			headers,
+			signal
+		}));
+	}
+	/**
+	* 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, query, options) {
+		return this.paginated("GET", options, ({ signal, headers }, cursor) => listEmailThreadMessages({
+			client: this.client,
+			path: { thread_id: threadId },
+			query: {
+				...query,
+				starting_after: cursor ?? query?.starting_after
+			},
+			headers,
+			signal
+		}));
+	}
+};
+//#endregion
 //#region src/client.ts
 const DEFAULT_TIMEOUT_MS = 6e4;
 const DEFAULT_MAX_RETRIES = 2;
@@ -3928,6 +4728,14 @@ var BirdClient = class {
 	domains;
 	/** Webhooks — `bird.webhooks.unwrap(payload, headers)` verifies an inbound delivery. */
 	webhooks;
+	/** Agent mailboxes — `bird.mailbox.create(...)`, `.compose(...)`, `.list(...)`, … */
+	mailbox;
+	/** Mailbox receive rules — `bird.mailboxReceiveRule.create(...)`, `.delete(...)`, `.list(...)`. */
+	mailboxReceiveRule;
+	/** Mailbox threads — `bird.mailboxThread.list(...)`, `.get(...)`, `.update(...)`, `.delete(...)`. */
+	mailboxThread;
+	/** Thread messages — `bird.mailboxThreadMessage.list(...)`, `.get(...)`, `.reply(...)`, `.body(...)`, … */
+	mailboxThreadMessage;
 	constructor(options) {
 		const opts = options;
 		this.#baseUrl = resolveBaseUrl(opts);
@@ -3935,9 +4743,9 @@ var BirdClient = class {
 		this.#headers = {
 			...opts.defaultHeaders,
 			Authorization: `Bearer ${opts.apiKey}`,
-			"User-Agent": `bird-sdk-js/0.11.0`,
+			"User-Agent": `bird-sdk-js/0.12.1`,
 			"Bird-Surface": "sdk-js",
-			"Bird-Version": "0.11.0"
+			"Bird-Version": "0.12.1"
 		};
 		const caller = detectCaller();
 		if (caller) this.#headers["Bird-Caller"] = caller;
@@ -3961,6 +4769,10 @@ var BirdClient = class {
 		this.contactProperties = new ContactPropertiesResource(this.core, this.#client);
 		this.domains = new DomainsResource(this.core, this.#client);
 		this.webhooks = new WebhooksResource(opts.webhooks);
+		this.mailbox = new MailboxResource(this.core, this.#client);
+		this.mailboxReceiveRule = new MailboxReceiveRuleResource(this.core, this.#client);
+		this.mailboxThread = new MailboxThreadResource(this.core, this.#client);
+		this.mailboxThreadMessage = new MailboxThreadMessageResource(this.core, this.#client);
 	}
 	/**
 	* Escape hatch for endpoints the typed resources don't cover. Runs the full