@marlinjai/mail-contract 0.21.0 → 0.23.0

package/dist/index.js

@@ -107,6 +107,8 @@ __export(index_exports, {
   BEARER_PREFIX: () => BEARER_PREFIX,
   BILLING_NOT_CONFIGURED_REASON: () => BILLING_NOT_CONFIGURED_REASON,
   BillingAddons: () => BillingAddons,
+  BoughtDomain: () => BoughtDomain,
+  BoughtDomainRecordParams: () => BoughtDomainRecordParams,
   BoundedAutomationFilter: () => BoundedAutomationFilter,
   BoundedSegmentFilter: () => BoundedSegmentFilter,
   COMPANY_GRANT_ROLES: () => COMPANY_GRANT_ROLES,
@@ -141,21 +143,33 @@ __export(index_exports, {
   DATE_PASSED_ANSWERS: () => DATE_PASSED_ANSWERS,
   DEFAULT_INVITE_TTL_DAYS: () => DEFAULT_INVITE_TTL_DAYS,
   DEFAULT_PAGE_LIMIT: () => DEFAULT_PAGE_LIMIT,
+  DNS_RECORD_TYPES: () => DNS_RECORD_TYPES,
   DOCUMENT_SCHEMA_VERSIONS: () => DOCUMENT_SCHEMA_VERSIONS,
   DOMAIN_BUYING_BLOCKS: () => DOMAIN_BUYING_BLOCKS,
   DOMAIN_BUYING_NOT_CONFIGURED_REASON: () => DOMAIN_BUYING_NOT_CONFIGURED_REASON,
+  DOMAIN_LEAVE_STATES: () => DOMAIN_LEAVE_STATES,
+  DOMAIN_LEAVE_WAYS: () => DOMAIN_LEAVE_WAYS,
+  DOMAIN_ORDER_KINDS: () => DOMAIN_ORDER_KINDS,
   DOMAIN_ORDER_STATES: () => DOMAIN_ORDER_STATES,
   DOMAIN_PRICE_CHANGED_REASON: () => DOMAIN_PRICE_CHANGED_REASON,
   DOMAIN_UNAVAILABLE_REASONS: () => DOMAIN_UNAVAILABLE_REASONS,
   DateOnly: () => DateOnly,
   DatePassedAnswer: () => DatePassedAnswer,
   DelayStep: () => DelayStep,
+  DnsRecordType: () => DnsRecordType,
   DocumentSchemaVersion: () => DocumentSchemaVersion,
   DomainBuyingBlock: () => DomainBuyingBlock,
+  DomainLeave: () => DomainLeave,
+  DomainLeaveCreate: () => DomainLeaveCreate,
+  DomainLeaveState: () => DomainLeaveState,
+  DomainLeaveWay: () => DomainLeaveWay,
   DomainOffer: () => DomainOffer,
   DomainOrder: () => DomainOrder,
   DomainOrderCreate: () => DomainOrderCreate,
+  DomainOrderKind: () => DomainOrderKind,
   DomainOrderState: () => DomainOrderState,
+  DomainRecord: () => DomainRecord,
+  DomainRecordInput: () => DomainRecordInput,
   DomainRegistrant: () => DomainRegistrant,
   DomainSearchQuery: () => DomainSearchQuery,
   DomainSearchResult: () => DomainSearchResult,
@@ -368,6 +382,7 @@ __export(index_exports, {
   QuietHours: () => QuietHours,
   RECIPIENT_REJECTIONS: () => RECIPIENT_REJECTIONS,
   RECIPIENT_STATUSES: () => RECIPIENT_STATUSES,
+  REGISTRY_PHONE: () => REGISTRY_PHONE,
   REQUEST_ID_HEADER: () => REQUEST_ID_HEADER,
   RESEND_EVENT_TYPES: () => RESEND_EVENT_TYPES,
   RESERVED_MERGE_FIELDS: () => RESERVED_MERGE_FIELDS,
@@ -532,6 +547,7 @@ __export(index_exports, {
   WorkspaceMove: () => WorkspaceMove,
   WorkspaceSettings: () => WorkspaceSettings,
   WorkspaceUpdate: () => WorkspaceUpdate,
+  ZoneFile: () => ZoneFile,
   acceptsIdempotencyKey: () => acceptsIdempotencyKey,
   addInsertion: () => addInsertion,
   addInsertionChoice: () => addInsertionChoice,
@@ -541,6 +557,7 @@ __export(index_exports, {
   automationFilterFamily: () => automationFilterFamily,
   automationRoutes: () => automationRoutes,
   billingRoutes: () => billingRoutes,
+  boughtDomainRoutes: () => boughtDomainRoutes,
   buildPath: () => buildPath,
   buildTemplatePatch: () => buildTemplatePatch,
   canDeleteMailing: () => canDeleteMailing,
@@ -605,6 +622,7 @@ __export(index_exports, {
   missingInsertionTexts: () => missingInsertionTexts,
   missingRequiredMergeFields: () => missingRequiredMergeFields,
   normalizeChoiceKey: () => normalizeChoiceKey,
+  normalizePhone: () => normalizePhone,
   nowSeconds: () => nowSeconds,
   operationsWithAccess: () => operationsWithAccess,
   ownEntry: () => ownEntry,
@@ -3721,8 +3739,15 @@ var AUDIT_ACTIONS = [
   "domain_order.registered",
   "domain_order.ready",
   "domain_order.needs_attention",
+  "domain_order.kind_changed",
   "domain_order.refunded",
   "domain_order.cancelled",
+  // Bought domains, managed by their holder
+  "domain_record.created",
+  "domain_record.updated",
+  "domain_record.deleted",
+  "domain_leave.requested",
+  "domain_leave.done",
   // A1: automations
   "automation.created",
   "automation.updated",
@@ -4648,6 +4673,292 @@ var SendingDomainUpdate = import_zod15.z.object({ from_name: SenderFields.from_n
 
 // src/domains.ts
 var import_zod16 = require("zod");
+
+// src/phone.ts
+var REGISTRY_PHONE = /^\+\d{1,3}\.\d{4,14}$/;
+var CALLING_CODE_OF_COUNTRY = {
+  DE: "49",
+  AT: "43",
+  CH: "41",
+  LI: "423",
+  LU: "352",
+  NL: "31",
+  BE: "32",
+  FR: "33",
+  IT: "39",
+  ES: "34",
+  PT: "351",
+  IE: "353",
+  GB: "44",
+  DK: "45",
+  SE: "46",
+  NO: "47",
+  FI: "358",
+  IS: "354",
+  PL: "48",
+  CZ: "420",
+  SK: "421",
+  HU: "36",
+  SI: "386",
+  HR: "385",
+  RO: "40",
+  BG: "359",
+  GR: "30",
+  CY: "357",
+  MT: "356",
+  EE: "372",
+  LV: "371",
+  LT: "370",
+  US: "1",
+  CA: "1",
+  AU: "61",
+  NZ: "64",
+  TR: "90",
+  IL: "972",
+  AE: "971",
+  IN: "91",
+  JP: "81",
+  CN: "86",
+  SG: "65",
+  ZA: "27",
+  BR: "55",
+  MX: "52",
+  UA: "380",
+  RS: "381"
+};
+var CALLING_CODES = /* @__PURE__ */ new Set([
+  "1",
+  "7",
+  "20",
+  "27",
+  "30",
+  "31",
+  "32",
+  "33",
+  "34",
+  "36",
+  "39",
+  "40",
+  "41",
+  "43",
+  "44",
+  "45",
+  "46",
+  "47",
+  "48",
+  "49",
+  "51",
+  "52",
+  "53",
+  "54",
+  "55",
+  "56",
+  "57",
+  "58",
+  "60",
+  "61",
+  "62",
+  "63",
+  "64",
+  "65",
+  "66",
+  "81",
+  "82",
+  "84",
+  "86",
+  "90",
+  "91",
+  "92",
+  "93",
+  "94",
+  "95",
+  "98",
+  "211",
+  "212",
+  "213",
+  "216",
+  "218",
+  "220",
+  "221",
+  "222",
+  "223",
+  "224",
+  "225",
+  "226",
+  "227",
+  "228",
+  "229",
+  "230",
+  "231",
+  "232",
+  "233",
+  "234",
+  "235",
+  "236",
+  "237",
+  "238",
+  "239",
+  "240",
+  "241",
+  "242",
+  "243",
+  "244",
+  "245",
+  "246",
+  "247",
+  "248",
+  "249",
+  "250",
+  "251",
+  "252",
+  "253",
+  "254",
+  "255",
+  "256",
+  "257",
+  "258",
+  "260",
+  "261",
+  "262",
+  "263",
+  "264",
+  "265",
+  "266",
+  "267",
+  "268",
+  "269",
+  "290",
+  "291",
+  "297",
+  "298",
+  "299",
+  "350",
+  "351",
+  "352",
+  "353",
+  "354",
+  "355",
+  "356",
+  "357",
+  "358",
+  "359",
+  "370",
+  "371",
+  "372",
+  "373",
+  "374",
+  "375",
+  "376",
+  "377",
+  "378",
+  "379",
+  "380",
+  "381",
+  "382",
+  "383",
+  "385",
+  "386",
+  "387",
+  "389",
+  "420",
+  "421",
+  "423",
+  "500",
+  "501",
+  "502",
+  "503",
+  "504",
+  "505",
+  "506",
+  "507",
+  "508",
+  "509",
+  "590",
+  "591",
+  "592",
+  "593",
+  "594",
+  "595",
+  "596",
+  "597",
+  "598",
+  "599",
+  "670",
+  "672",
+  "673",
+  "674",
+  "675",
+  "676",
+  "677",
+  "678",
+  "679",
+  "680",
+  "681",
+  "682",
+  "683",
+  "685",
+  "686",
+  "687",
+  "688",
+  "689",
+  "690",
+  "691",
+  "692",
+  "850",
+  "852",
+  "853",
+  "855",
+  "856",
+  "880",
+  "886",
+  "960",
+  "961",
+  "962",
+  "963",
+  "964",
+  "965",
+  "966",
+  "967",
+  "968",
+  "970",
+  "971",
+  "972",
+  "973",
+  "974",
+  "975",
+  "976",
+  "977",
+  "992",
+  "993",
+  "994",
+  "995",
+  "996",
+  "998"
+]);
+var KEEPS_LEADING_ZERO = /* @__PURE__ */ new Set(["39", "378", "379"]);
+function normalizePhone(raw, country) {
+  const text = raw.trim();
+  if (REGISTRY_PHONE.test(text)) return text;
+  const compact = text.replace(/\(0\)/g, "").replace(/[\s\-./()]/g, "");
+  let international;
+  if (/^\+\d+$/.test(compact)) international = compact.slice(1);
+  else if (/^00\d+$/.test(compact)) international = compact.slice(2);
+  else if (/^0\d+$/.test(compact)) {
+    const code = country ? CALLING_CODE_OF_COUNTRY[country.trim().toUpperCase()] : void 0;
+    if (!code) return raw;
+    return `+${code}.${KEEPS_LEADING_ZERO.has(code) ? compact : compact.slice(1)}`;
+  } else return raw;
+  for (const length of [1, 2, 3]) {
+    const code = international.slice(0, length);
+    if (CALLING_CODES.has(code)) {
+      const rest = international.slice(length);
+      return `+${code}.${KEEPS_LEADING_ZERO.has(code) ? rest : rest.replace(/^0/, "")}`;
+    }
+  }
+  return raw;
+}
+
+// src/domains.ts
 var DomainSearchQuery = import_zod16.z.object({ q: import_zod16.z.string().trim().min(1).max(63) });
 var DOMAIN_UNAVAILABLE_REASONS = ["taken", "extension_not_supported", "premium", "not_registrable"];
 var DomainUnavailableReason = import_zod16.z.enum(DOMAIN_UNAVAILABLE_REASONS);
@@ -4669,20 +4980,27 @@ var DomainRegistrant = import_zod16.z.object({
   name: import_zod16.z.string().trim().min(3).max(120).regex(/\S+\s+\S+/, "must be a first and a last name"),
   organization: import_zod16.z.string().trim().min(1).max(120).nullable().optional(),
   email: Email,
-  phone: import_zod16.z.string().trim().regex(/^\+\d{1,3}\.\d{4,14}$/, "must be +<country code>.<number>, such as +49.3012345678"),
+  phone: import_zod16.z.string().trim().min(1).max(40),
   street: import_zod16.z.string().trim().min(3).max(200),
   city: import_zod16.z.string().trim().min(1).max(100),
   state: import_zod16.z.string().trim().min(1).max(100),
   postal_code: import_zod16.z.string().trim().min(2).max(20),
   country_code: import_zod16.z.string().trim().toUpperCase().regex(/^[A-Z]{2}$/, "must be a two-letter country code such as DE")
-});
+}).superRefine((holder, ctx) => {
+  if (typeof holder.phone === "string" && !REGISTRY_PHONE.test(normalizePhone(holder.phone, holder.country_code))) {
+    ctx.addIssue({ code: import_zod16.z.ZodIssueCode.custom, path: ["phone"], message: "must be a phone number with its country code, such as +49 30 1234 5678" });
+  }
+}).transform((holder) => ({ ...holder, phone: normalizePhone(holder.phone, holder.country_code) }));
 var MAX_DOMAIN_ORDERS_PER_DAY = 2;
+var DOMAIN_ORDER_KINDS = ["sending", "domain_only"];
+var DomainOrderKind = import_zod16.z.enum(DOMAIN_ORDER_KINDS);
 var DomainOrderCreate = import_zod16.z.object({
   domain: SendingDomainName,
   price_cents: import_zod16.z.number().int().min(0),
   registrant: DomainRegistrant,
-  from_name: import_zod16.z.string().trim().min(1).max(120),
-  from_local_part: import_zod16.z.string().trim().toLowerCase().regex(/^[a-z0-9](?:[a-z0-9._+-]{0,62}[a-z0-9])?$/, "must be the part before the @, such as hello"),
+  kind: DomainOrderKind.default("sending"),
+  from_name: import_zod16.z.string().trim().min(1).max(120).optional(),
+  from_local_part: import_zod16.z.string().trim().toLowerCase().regex(/^[a-z0-9](?:[a-z0-9._+-]{0,62}[a-z0-9])?$/, "must be the part before the @, such as hello").optional(),
   /**
    * Where Stripe returns to after paying, and after leaving the payment. The
    * service adds `domain_order=<order id>` to both, so the page coming back
@@ -4693,6 +5011,10 @@ var DomainOrderCreate = import_zod16.z.object({
   cancel_url: import_zod16.z.string().url(),
   /** The buyer accepted the terms of service (which cover bought domains) of this version. */
   accept_terms: AcceptTerms
+}).superRefine((order, ctx) => {
+  if (order.kind !== "sending") return;
+  if (!order.from_name) ctx.addIssue({ code: import_zod16.z.ZodIssueCode.custom, path: ["from_name"], message: "is needed for a domain mail is sent from" });
+  if (!order.from_local_part) ctx.addIssue({ code: import_zod16.z.ZodIssueCode.custom, path: ["from_local_part"], message: "is needed for a domain mail is sent from" });
 });
 var DOMAIN_ORDER_STATES = [
   "awaiting_payment",
@@ -4715,8 +5037,10 @@ var DomainOrder = import_zod16.z.object({
   /** Stripe's payment page while `awaiting_payment`; null otherwise. */
   checkout_url: import_zod16.z.string().url().nullable(),
   registrant_name: import_zod16.z.string(),
-  from_name: import_zod16.z.string(),
-  from_email: Email,
+  kind: DomainOrderKind,
+  /** The sender, for a `sending` order; null for `domain_only`. */
+  from_name: import_zod16.z.string().nullable(),
+  from_email: Email.nullable(),
   /** The sending domain once `ready`. */
   sending_domain_id: Id.nullable(),
   /** When the paid year ends, once registered. */
@@ -4729,36 +5053,124 @@ var DomainOrder = import_zod16.z.object({
   updated_at: Timestamp
 });
 
-// src/contacts.ts
+// src/bought-domains.ts
 var import_zod17 = require("zod");
-var Topic = import_zod17.z.object({
+var DOMAIN_LEAVE_WAYS = ["cloudflare_account", "transfer"];
+var DomainLeaveWay = import_zod17.z.enum(DOMAIN_LEAVE_WAYS);
+var DOMAIN_LEAVE_STATES = ["requested", "done", "cancelled"];
+var DomainLeaveState = import_zod17.z.enum(DOMAIN_LEAVE_STATES);
+var DomainLeave = import_zod17.z.object({
+  id: Id,
+  way: DomainLeaveWay,
+  state: DomainLeaveState,
+  /** The Cloudflare account the domain moves into (way `cloudflare_account`). */
+  target_account_id: import_zod17.z.string().nullable(),
+  /** The transfer code, once support has it (way `transfer`, state `done`); only owners and admins read it. */
+  auth_code: import_zod17.z.string().nullable(),
+  requested_at: Timestamp,
+  done_at: Timestamp.nullable()
+});
+var BoughtDomain = import_zod17.z.object({
+  /** The order the domain was bought with. */
+  id: Id,
+  domain: import_zod17.z.string(),
+  kind: DomainOrderKind,
+  registrant_name: import_zod17.z.string(),
+  registered_at: Timestamp,
+  /** When the paid year ends. */
+  expires_at: Timestamp.nullable(),
+  /** Each further year, final, in euro cents; 0 for a domain registered without a charge. */
+  renewal_price_cents: import_zod17.z.number().int().min(0),
+  currency: import_zod17.z.literal("EUR"),
+  /** Registered for one of Lumitra's own companies, never charged. */
+  no_charge: import_zod17.z.boolean(),
+  /** The earliest moment each way of leaving is possible. */
+  move_account_from: Timestamp,
+  transfer_from: Timestamp,
+  /** The latest request to leave, if any. */
+  leave: DomainLeave.nullable(),
+  /** True once the domain has left: its records are no longer Lumitra Mail's to edit. */
+  left: import_zod17.z.boolean()
+});
+var DNS_RECORD_TYPES = ["A", "AAAA", "CNAME", "TXT", "MX", "NS"];
+var DnsRecordType = import_zod17.z.enum(DNS_RECORD_TYPES);
+var DomainRecord = import_zod17.z.object({
+  id: import_zod17.z.string(),
+  type: import_zod17.z.string(),
+  /** The full name (www.example.com). */
+  name: import_zod17.z.string(),
+  content: import_zod17.z.string(),
+  /** Seconds; 1 is automatic. */
+  ttl: import_zod17.z.number().int(),
+  /** Served through Cloudflare's proxy (A, AAAA, CNAME only). */
+  proxied: import_zod17.z.boolean(),
+  priority: import_zod17.z.number().int().nullable(),
+  /**
+   * Not the holder's to change: a record Lumitra Mail wrote for sending (it
+   * keeps those right itself), or a type the dashboard does not edit.
+   */
+  locked: import_zod17.z.boolean()
+});
+var IPV4 = /^(25[0-5]|2[0-4]\d|1?\d?\d)(\.(25[0-5]|2[0-4]\d|1?\d?\d)){3}$/;
+var HOSTNAME = /^(?=.{1,253}\.?$)([a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9])?\.)*[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9])?\.?$/i;
+var DomainRecordInput = import_zod17.z.object({
+  type: DnsRecordType,
+  name: import_zod17.z.string().trim().min(1).max(253),
+  content: import_zod17.z.string().trim().min(1).max(2048),
+  ttl: import_zod17.z.union([import_zod17.z.literal(1), import_zod17.z.number().int().min(60).max(86400)]).default(1),
+  proxied: import_zod17.z.boolean().default(false),
+  priority: import_zod17.z.number().int().min(0).max(65535).nullable().optional()
+}).superRefine((r, ctx) => {
+  const bad = (path, message) => ctx.addIssue({ code: import_zod17.z.ZodIssueCode.custom, path: [path], message });
+  if (r.type === "A" && !IPV4.test(r.content)) bad("content", "must be an IPv4 address, such as 192.0.2.10");
+  if (r.type === "AAAA" && (!r.content.includes(":") || !/^[0-9a-f:.]+$/i.test(r.content))) bad("content", "must be an IPv6 address, such as 2001:db8::10");
+  if ((r.type === "CNAME" || r.type === "MX" || r.type === "NS") && !HOSTNAME.test(r.content)) bad("content", "must be a host name, such as host.example.com");
+  if (r.type === "MX" && (r.priority === void 0 || r.priority === null)) bad("priority", "is needed for an MX record");
+  if (r.type !== "MX" && r.priority !== void 0 && r.priority !== null) bad("priority", "is only for an MX record");
+  if (r.proxied && !["A", "AAAA", "CNAME"].includes(r.type)) bad("proxied", "is only for A, AAAA and CNAME records");
+});
+var BoughtDomainRecordParams = import_zod17.z.object({ id: Id, record_id: import_zod17.z.string().regex(/^[0-9a-f]{32}$/, "must be a record id") });
+var DomainLeaveCreate = import_zod17.z.object({
+  way: DomainLeaveWay,
+  /** The holder's own Cloudflare account id (32 hex characters), for `cloudflare_account`. */
+  target_account_id: import_zod17.z.string().trim().toLowerCase().regex(/^[0-9a-f]{32}$/, "must be a Cloudflare account id: 32 letters and digits, from the account\u2019s overview page").optional()
+}).superRefine((r, ctx) => {
+  if (r.way === "cloudflare_account" && !r.target_account_id) {
+    ctx.addIssue({ code: import_zod17.z.ZodIssueCode.custom, path: ["target_account_id"], message: "is needed to move the domain into your Cloudflare account" });
+  }
+});
+var ZoneFile = import_zod17.z.object({ domain: import_zod17.z.string(), zone_file: import_zod17.z.string() });
+
+// src/contacts.ts
+var import_zod18 = require("zod");
+var Topic = import_zod18.z.object({
   id: Id,
   slug: Slug,
-  name: import_zod17.z.string().min(1).max(120),
+  name: import_zod18.z.string().min(1).max(120),
   /** Shown on the hosted preference page. */
-  description: import_zod17.z.string().max(1e3).nullable(),
+  description: import_zod18.z.string().max(1e3).nullable(),
   /** Translations of `name` and `description` per locale, for the hosted page. */
-  translations: import_zod17.z.record(
-    import_zod17.z.object({ name: import_zod17.z.string().min(1).max(120), description: import_zod17.z.string().max(1e3).nullable() })
+  translations: import_zod18.z.record(
+    import_zod18.z.object({ name: import_zod18.z.string().min(1).max(120), description: import_zod18.z.string().max(1e3).nullable() })
   ),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var TopicCreate = import_zod17.z.object({
+var TopicCreate = import_zod18.z.object({
   slug: Slug,
-  name: import_zod17.z.string().min(1).max(120),
-  description: import_zod17.z.string().max(1e3).optional(),
+  name: import_zod18.z.string().min(1).max(120),
+  description: import_zod18.z.string().max(1e3).optional(),
   translations: Topic.shape.translations.optional()
 });
 var TopicUpdate = TopicCreate.omit({ slug: true }).partial().refine((v) => Object.keys(v).length > 0, "at least one field");
-var Contact = import_zod17.z.object({
+var Contact = import_zod18.z.object({
   id: Id,
-  external_id: import_zod17.z.string().min(1).max(255).nullable(),
+  external_id: import_zod18.z.string().min(1).max(255).nullable(),
   /** Stored lowercased, unique per workspace. */
   email: Email,
-  first_name: import_zod17.z.string().max(200).nullable(),
-  last_name: import_zod17.z.string().max(200).nullable(),
-  locale: import_zod17.z.string().min(2).max(35).nullable(),
+  first_name: import_zod18.z.string().max(200).nullable(),
+  last_name: import_zod18.z.string().max(200).nullable(),
+  locale: import_zod18.z.string().min(2).max(35).nullable(),
   /**
    * The person's own time zone, an IANA name such as `Europe/Berlin` (A1).
    * Every wall clock an automation waits for is read in it, falling back to the
@@ -4766,65 +5178,65 @@ var Contact = import_zod17.z.object({
    */
   timezone: TimezoneName.nullable(),
   properties: Properties,
-  topics: import_zod17.z.array(Slug),
+  topics: import_zod18.z.array(Slug),
   /** The slugs of the contact's tags (S4). */
-  tags: import_zod17.z.array(Slug),
+  tags: import_zod18.z.array(Slug),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var ContactUpsert = import_zod17.z.object({
-  external_id: import_zod17.z.string().min(1).max(255).optional(),
+var ContactUpsert = import_zod18.z.object({
+  external_id: import_zod18.z.string().min(1).max(255).optional(),
   email: Email.optional(),
-  first_name: import_zod17.z.string().max(200).nullable().optional(),
-  last_name: import_zod17.z.string().max(200).nullable().optional(),
-  locale: import_zod17.z.string().min(2).max(35).nullable().optional(),
+  first_name: import_zod18.z.string().max(200).nullable().optional(),
+  last_name: import_zod18.z.string().max(200).nullable().optional(),
+  locale: import_zod18.z.string().min(2).max(35).nullable().optional(),
   timezone: TimezoneName.nullable().optional(),
   properties: Properties.optional(),
-  topics: import_zod17.z.array(Slug).max(100).optional()
+  topics: import_zod18.z.array(Slug).max(100).optional()
 }).refine((v) => v.external_id !== void 0 || v.email !== void 0, {
   message: "external_id or email is required",
   path: ["email"]
 });
-var ContactUpsertResult = import_zod17.z.object({
+var ContactUpsertResult = import_zod18.z.object({
   contact: Contact,
-  created: import_zod17.z.boolean()
+  created: import_zod18.z.boolean()
 });
 var ContactListQuery = PageQuery.extend({
-  email: import_zod17.z.string().min(1).max(254).optional(),
-  external_id: import_zod17.z.string().min(1).max(255).optional(),
+  email: import_zod18.z.string().min(1).max(254).optional(),
+  external_id: import_zod18.z.string().min(1).max(255).optional(),
   topic: Slug.optional()
 });
-var ContactErased = import_zod17.z.object({
-  ok: import_zod17.z.literal(true),
-  erased_messages: import_zod17.z.number().int().min(0),
-  erased_recipients: import_zod17.z.number().int().min(0),
-  suppressions_kept: import_zod17.z.number().int().min(0)
+var ContactErased = import_zod18.z.object({
+  ok: import_zod18.z.literal(true),
+  erased_messages: import_zod18.z.number().int().min(0),
+  erased_recipients: import_zod18.z.number().int().min(0),
+  suppressions_kept: import_zod18.z.number().int().min(0)
 });
 var SUPPRESSION_REASONS = ["unsubscribed", "bounced", "complained", "manual"];
-var SuppressionReason = import_zod17.z.enum(SUPPRESSION_REASONS);
-var Suppression = import_zod17.z.object({
+var SuppressionReason = import_zod18.z.enum(SUPPRESSION_REASONS);
+var Suppression = import_zod18.z.object({
   id: Id,
   email: Email,
   reason: SuppressionReason,
   topic: Slug.nullable(),
   source_message_id: Id.nullable(),
-  note: import_zod17.z.string().max(1e3).nullable(),
+  note: import_zod18.z.string().max(1e3).nullable(),
   created_at: Timestamp
 });
-var SuppressionCreate = import_zod17.z.object({
+var SuppressionCreate = import_zod18.z.object({
   email: Email,
-  reason: import_zod17.z.enum(["manual", "unsubscribed"]),
+  reason: import_zod18.z.enum(["manual", "unsubscribed"]),
   topic: Slug.nullable().optional(),
-  note: import_zod17.z.string().max(1e3).optional()
+  note: import_zod18.z.string().max(1e3).optional()
 });
 var SuppressionListQuery = PageQuery.extend({
-  email: import_zod17.z.string().min(1).max(254).optional(),
+  email: import_zod18.z.string().min(1).max(254).optional(),
   reason: SuppressionReason.optional(),
   topic: Slug.optional()
 });
 
 // src/webhooks.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 var WEBHOOK_EVENT_TYPES = [
   "message.sent",
   "message.failed",
@@ -4868,23 +5280,23 @@ var WEBHOOK_EVENT_TYPES = [
   "template.updated",
   "template.deleted"
 ];
-var WebhookEventType = import_zod18.z.enum(WEBHOOK_EVENT_TYPES);
-var MessageEventBase = import_zod18.z.object({
+var WebhookEventType = import_zod19.z.enum(WEBHOOK_EVENT_TYPES);
+var MessageEventBase = import_zod19.z.object({
   message_id: Id,
   mailing_id: Id.nullable(),
   mailing_metadata: MailingMetadata.nullable(),
   recipient_id: Id.nullable(),
   contact_id: Id.nullable(),
-  external_id: import_zod18.z.string().nullable(),
+  external_id: import_zod19.z.string().nullable(),
   email: Email,
-  subject: import_zod18.z.string(),
+  subject: import_zod19.z.string(),
   topic: Slug.nullable(),
-  provider_message_id: import_zod18.z.string().nullable(),
-  is_test: import_zod18.z.boolean()
+  provider_message_id: import_zod19.z.string().nullable(),
+  is_test: import_zod19.z.boolean()
 });
 var MessageSentData = MessageEventBase.extend({
   /** The final HTML as sent, so the client can archive it beside its own records. */
-  html: import_zod18.z.string(),
+  html: import_zod19.z.string(),
   sent_at: Timestamp,
   /**
    * The choice each insertion made (see `Message.insertions`); absent or null
@@ -4895,20 +5307,20 @@ var MessageSentData = MessageEventBase.extend({
   insertions: InsertionChoices.nullish()
 });
 var MessageFailedData = MessageEventBase.extend({
-  error: import_zod18.z.string(),
+  error: import_zod19.z.string(),
   /** False when the provider rejected permanently; the recipient will not be retried. */
-  retryable: import_zod18.z.boolean(),
+  retryable: import_zod19.z.boolean(),
   failed_at: Timestamp
 });
 var UNSUBSCRIBE_SOURCES = ["hosted_page", "one_click", "api", "dashboard", "signup_form"];
-var ContactUnsubscribedData = import_zod18.z.object({
+var ContactUnsubscribedData = import_zod19.z.object({
   contact_id: Id.nullable(),
-  external_id: import_zod18.z.string().nullable(),
+  external_id: import_zod19.z.string().nullable(),
   email: Email,
   /** The topic unsubscribed from; null means every topic. */
   topic: Slug.nullable(),
   mailing_id: Id.nullable(),
-  source: import_zod18.z.enum(UNSUBSCRIBE_SOURCES),
+  source: import_zod19.z.enum(UNSUBSCRIBE_SOURCES),
   unsubscribed_at: Timestamp
 });
 var ContactResubscribedData = ContactUnsubscribedData.omit({ unsubscribed_at: true }).extend({
@@ -4917,142 +5329,142 @@ var ContactResubscribedData = ContactUnsubscribedData.omit({ unsubscribed_at: tr
    * breaker undid a `bounced` block it judged false (a `contact.bounced` for the
    * same address and mailing went out before); `topic` is null.
    */
-  source: import_zod18.z.enum([...UNSUBSCRIBE_SOURCES, "bounce_reverted"]),
+  source: import_zod19.z.enum([...UNSUBSCRIBE_SOURCES, "bounce_reverted"]),
   resubscribed_at: Timestamp
 });
-var ContactBouncedData = import_zod18.z.object({
+var ContactBouncedData = import_zod19.z.object({
   contact_id: Id.nullable(),
-  external_id: import_zod18.z.string().nullable(),
+  external_id: import_zod19.z.string().nullable(),
   email: Email,
   /** `bounced` for a hard bounce, `complained` for a spam complaint. */
-  reason: import_zod18.z.enum(["bounced", "complained"]),
+  reason: import_zod19.z.enum(["bounced", "complained"]),
   message_id: Id.nullable(),
-  diagnostic: import_zod18.z.string().nullable(),
+  diagnostic: import_zod19.z.string().nullable(),
   bounced_at: Timestamp
 });
-var MailingFinishedData = import_zod18.z.object({
+var MailingFinishedData = import_zod19.z.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  status: import_zod18.z.enum(["sent", "partially_failed", "cancelled"]),
+  status: import_zod19.z.enum(["sent", "partially_failed", "cancelled"]),
   counts: MailingCounts,
   finished_at: Timestamp
 });
-var ContactSubscribedData = import_zod18.z.object({
+var ContactSubscribedData = import_zod19.z.object({
   contact_id: Id,
-  external_id: import_zod18.z.string().nullable(),
+  external_id: import_zod19.z.string().nullable(),
   email: Email,
-  topics: import_zod18.z.array(Slug),
-  source: import_zod18.z.enum(["signup_form", "api", "dashboard", "automation"]),
+  topics: import_zod19.z.array(Slug),
+  source: import_zod19.z.enum(["signup_form", "api", "dashboard", "automation"]),
   signup_form_id: Id.nullable(),
-  signup_form_version: import_zod18.z.number().int().min(1).nullable(),
+  signup_form_version: import_zod19.z.number().int().min(1).nullable(),
   subscribed_at: Timestamp
 });
-var ImportFinishedData = import_zod18.z.object({
+var ImportFinishedData = import_zod19.z.object({
   import_id: Id,
-  status: import_zod18.z.enum(["completed", "cancelled", "failed"]),
+  status: import_zod19.z.enum(["completed", "cancelled", "failed"]),
   result: ImportReport.nullable(),
-  error: import_zod18.z.string().nullable(),
+  error: import_zod19.z.string().nullable(),
   finished_at: Timestamp
 });
-var MailingScheduledData = import_zod18.z.object({
+var MailingScheduledData = import_zod19.z.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
   scheduled_at: Timestamp.nullable()
 });
-var MailingStartedData = import_zod18.z.object({
+var MailingStartedData = import_zod19.z.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  trigger: import_zod18.z.enum(["send", "schedule"]),
-  recipients: import_zod18.z.number().int().min(0),
+  trigger: import_zod19.z.enum(["send", "schedule"]),
+  recipients: import_zod19.z.number().int().min(0),
   started_at: Timestamp
 });
-var MailingScheduleFailedData = import_zod18.z.object({
+var MailingScheduleFailedData = import_zod19.z.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  code: import_zod18.z.string(),
-  message: import_zod18.z.string(),
+  code: import_zod19.z.string(),
+  message: import_zod19.z.string(),
   failed_at: Timestamp
 });
-var MailingAbWinnerSelectedData = import_zod18.z.object({
+var MailingAbWinnerSelectedData = import_zod19.z.object({
   mailing_id: Id,
   mailing_metadata: MailingMetadata,
-  winner: import_zod18.z.string(),
-  decided_by: import_zod18.z.enum(["metric", "manual"]),
-  variants: import_zod18.z.array(VariantAnalytics),
+  winner: import_zod19.z.string(),
+  decided_by: import_zod19.z.enum(["metric", "manual"]),
+  variants: import_zod19.z.array(VariantAnalytics),
   decided_at: Timestamp
 });
-var ContactTaggedData = import_zod18.z.object({
+var ContactTaggedData = import_zod19.z.object({
   contact_id: Id,
-  external_id: import_zod18.z.string().nullable(),
+  external_id: import_zod19.z.string().nullable(),
   email: Email,
   /** Only the tags the contact did not already have. */
-  tags: import_zod18.z.array(Slug).min(1),
-  source: import_zod18.z.enum(["api", "dashboard", "signup_form", "import", "automation"]),
+  tags: import_zod19.z.array(Slug).min(1),
+  source: import_zod19.z.enum(["api", "dashboard", "signup_form", "import", "automation"]),
   tagged_at: Timestamp
 });
-var ContactUpdatedData = import_zod18.z.object({
+var ContactUpdatedData = import_zod19.z.object({
   contact_id: Id,
-  external_id: import_zod18.z.string().nullable(),
+  external_id: import_zod19.z.string().nullable(),
   email: Email,
-  changed: import_zod18.z.array(import_zod18.z.string()).min(1),
+  changed: import_zod19.z.array(import_zod19.z.string()).min(1),
   properties: Properties,
-  source: import_zod18.z.enum(["api", "dashboard", "signup_form", "import", "automation"]),
+  source: import_zod19.z.enum(["api", "dashboard", "signup_form", "import", "automation"]),
   updated_at: Timestamp
 });
-var AutomationRunEventBase = import_zod18.z.object({
+var AutomationRunEventBase = import_zod19.z.object({
   automation_id: Id,
-  automation_name: import_zod18.z.string(),
+  automation_name: import_zod19.z.string(),
   run_id: Id,
-  version: import_zod18.z.number().int().min(1),
+  version: import_zod19.z.number().int().min(1),
   contact_id: Id,
-  external_id: import_zod18.z.string().nullable(),
+  external_id: import_zod19.z.string().nullable(),
   email: Email
 });
 var AutomationRunStartedData = AutomationRunEventBase.extend({
   /** What let them in: a trigger kind, or `manual` for an explicit enrolment. */
-  trigger_kind: import_zod18.z.string(),
+  trigger_kind: import_zod19.z.string(),
   entered_at: Timestamp
 });
 var AutomationRunCompletedData = AutomationRunEventBase.extend({
-  last_step_id: import_zod18.z.string().nullable(),
+  last_step_id: import_zod19.z.string().nullable(),
   completed_at: Timestamp
 });
 var AutomationRunExitedData = AutomationRunEventBase.extend({
   reason: AutomationEndReason,
-  step_id: import_zod18.z.string().nullable(),
+  step_id: import_zod19.z.string().nullable(),
   exited_at: Timestamp
 });
 var AutomationRunFailedData = AutomationRunEventBase.extend({
-  reason: import_zod18.z.string(),
-  step_id: import_zod18.z.string().nullable(),
+  reason: import_zod19.z.string(),
+  step_id: import_zod19.z.string().nullable(),
   failed_at: Timestamp
 });
 var AutomationWebhookData = AutomationRunEventBase.extend({
-  step_id: import_zod18.z.string(),
+  step_id: import_zod19.z.string(),
   /** The step's own label, when it was given one, so a receiver can branch on a name. */
-  step_label: import_zod18.z.string().nullable(),
+  step_label: import_zod19.z.string().nullable(),
   /** Whatever the step carries, verbatim. Null when it carries nothing. */
   payload: JsonValue.nullable(),
   fired_at: Timestamp
 });
-var TemplateEventBase = import_zod18.z.object({
+var TemplateEventBase = import_zod19.z.object({
   template_id: Id,
-  name: import_zod18.z.string().min(1).max(200),
-  version: import_zod18.z.number().int().min(1),
-  source: import_zod18.z.enum(["api", "dashboard", "mjml_import"])
+  name: import_zod19.z.string().min(1).max(200),
+  version: import_zod19.z.number().int().min(1),
+  source: import_zod19.z.enum(["api", "dashboard", "mjml_import"])
 });
 var TemplateCreatedData = TemplateEventBase.extend({ created_at: Timestamp });
-var TemplateUpdatedData = TemplateEventBase.extend({ archived: import_zod18.z.boolean(), updated_at: Timestamp });
+var TemplateUpdatedData = TemplateEventBase.extend({ archived: import_zod19.z.boolean(), updated_at: Timestamp });
 var TemplateDeletedData = TemplateEventBase.extend({ deleted_at: Timestamp });
-var envelope = (type, data) => import_zod18.z.object({
+var envelope = (type, data) => import_zod19.z.object({
   /** Unique per event: a receiver deduplicates on it (deliveries may repeat). */
   id: Id,
-  type: import_zod18.z.literal(type),
+  type: import_zod19.z.literal(type),
   created_at: Timestamp,
   workspace_id: Id,
   data
 });
-var WebhookEvent = import_zod18.z.discriminatedUnion("type", [
+var WebhookEvent = import_zod19.z.discriminatedUnion("type", [
   envelope("message.sent", MessageSentData),
   envelope("message.failed", MessageFailedData),
   envelope("contact.unsubscribed", ContactUnsubscribedData),
@@ -5076,16 +5488,16 @@ var WebhookEvent = import_zod18.z.discriminatedUnion("type", [
   envelope("template.updated", TemplateUpdatedData),
   envelope("template.deleted", TemplateDeletedData)
 ]);
-var WebhookEndpoint = import_zod18.z.object({
+var WebhookEndpoint = import_zod19.z.object({
   id: Id,
-  url: import_zod18.z.string().url(),
-  description: import_zod18.z.string().max(500).nullable(),
-  events: import_zod18.z.array(WebhookEventType).min(1),
-  enabled: import_zod18.z.boolean(),
+  url: import_zod19.z.string().url(),
+  description: import_zod19.z.string().max(500).nullable(),
+  events: import_zod19.z.array(WebhookEventType).min(1),
+  enabled: import_zod19.z.boolean(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var WebhookUrl = import_zod18.z.string().url().refine((u) => {
+var WebhookUrl = import_zod19.z.string().url().refine((u) => {
   try {
     const url = new URL(u);
     if (url.protocol === "https:") return true;
@@ -5094,35 +5506,35 @@ var WebhookUrl = import_zod18.z.string().url().refine((u) => {
     return false;
   }
 }, "must be https (http only for localhost)");
-var WebhookEndpointCreate = import_zod18.z.object({
+var WebhookEndpointCreate = import_zod19.z.object({
   url: WebhookUrl,
-  description: import_zod18.z.string().max(500).optional(),
-  events: import_zod18.z.array(WebhookEventType).min(1),
-  enabled: import_zod18.z.boolean().optional()
+  description: import_zod19.z.string().max(500).optional(),
+  events: import_zod19.z.array(WebhookEventType).min(1),
+  enabled: import_zod19.z.boolean().optional()
 });
-var WebhookEndpointUpdate = import_zod18.z.object({
+var WebhookEndpointUpdate = import_zod19.z.object({
   url: WebhookUrl,
-  description: import_zod18.z.string().max(500).nullable(),
-  events: import_zod18.z.array(WebhookEventType).min(1),
-  enabled: import_zod18.z.boolean()
+  description: import_zod19.z.string().max(500).nullable(),
+  events: import_zod19.z.array(WebhookEventType).min(1),
+  enabled: import_zod19.z.boolean()
 }).partial().refine((v) => Object.keys(v).length > 0, "at least one field");
-var WebhookEndpointWithSecret = import_zod18.z.object({
+var WebhookEndpointWithSecret = import_zod19.z.object({
   endpoint: WebhookEndpoint,
-  secret: import_zod18.z.string().min(32)
+  secret: import_zod19.z.string().min(32)
 });
 var WEBHOOK_DELIVERY_STATUSES = ["pending", "succeeded", "failed"];
-var WebhookDeliveryStatus = import_zod18.z.enum(WEBHOOK_DELIVERY_STATUSES);
+var WebhookDeliveryStatus = import_zod19.z.enum(WEBHOOK_DELIVERY_STATUSES);
 var WEBHOOK_MAX_ATTEMPTS = 8;
 var WEBHOOK_RETRY_DELAYS_SECONDS = [30, 120, 600, 1800, 3600, 7200, 21600];
-var WebhookDelivery = import_zod18.z.object({
+var WebhookDelivery = import_zod19.z.object({
   id: Id,
   endpoint_id: Id,
   event_id: Id,
   event_type: WebhookEventType,
   status: WebhookDeliveryStatus,
-  attempts: import_zod18.z.number().int().min(0),
-  last_status_code: import_zod18.z.number().int().min(100).max(599).nullable(),
-  last_error: import_zod18.z.string().nullable(),
+  attempts: import_zod19.z.number().int().min(0),
+  last_status_code: import_zod19.z.number().int().min(100).max(599).nullable(),
+  last_error: import_zod19.z.string().nullable(),
   next_attempt_at: Timestamp.nullable(),
   delivered_at: Timestamp.nullable(),
   created_at: Timestamp
@@ -5131,7 +5543,7 @@ var WebhookDeliveryListQuery = PageQuery.extend({
   status: WebhookDeliveryStatus.optional(),
   event_type: WebhookEventType.optional()
 });
-var WebhookDeliveryParams = import_zod18.z.object({ id: Id, delivery_id: Id });
+var WebhookDeliveryParams = import_zod19.z.object({ id: Id, delivery_id: Id });
 
 // src/webhook-signing.ts
 var WEBHOOK_SIGNATURE_HEADER = "x-mail-signature";
@@ -5198,99 +5610,99 @@ async function verifyWebhook(input) {
 }
 
 // src/billing.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 var PLAN_IDS = ["free", "starter", "growth", "design_partner"];
-var PlanId = import_zod19.z.enum(PLAN_IDS);
-var PlanLimits = import_zod19.z.object({
-  monthly_messages: import_zod19.z.number().int().min(0).nullable(),
-  contacts: import_zod19.z.number().int().min(0).nullable(),
-  members: import_zod19.z.number().int().min(1).nullable(),
-  providers: import_zod19.z.number().int().min(1).nullable(),
-  webhook_endpoints: import_zod19.z.number().int().min(0).nullable(),
+var PlanId = import_zod20.z.enum(PLAN_IDS);
+var PlanLimits = import_zod20.z.object({
+  monthly_messages: import_zod20.z.number().int().min(0).nullable(),
+  contacts: import_zod20.z.number().int().min(0).nullable(),
+  members: import_zod20.z.number().int().min(1).nullable(),
+  providers: import_zod20.z.number().int().min(1).nullable(),
+  webhook_endpoints: import_zod20.z.number().int().min(0).nullable(),
   /** Automations that may be live (active or paused) at once (A1). */
-  active_automations: import_zod19.z.number().int().min(0).nullable(),
+  active_automations: import_zod20.z.number().int().min(0).nullable(),
   /** Steps one automation may hold. Null is the flow's own cap, not unlimited. */
-  automation_steps: import_zod19.z.number().int().min(1).nullable(),
+  automation_steps: import_zod20.z.number().int().min(1).nullable(),
   /** Own domains Lumitra Mail sends from (managed sending domains); 0 when the plan has none. */
-  sending_domains: import_zod19.z.number().int().min(0).nullable()
+  sending_domains: import_zod20.z.number().int().min(0).nullable()
 });
-var PlanFeatures = import_zod19.z.object({
+var PlanFeatures = import_zod20.z.object({
   /** A/B tests of subject and content on a mailing (S4). */
-  ab_testing: import_zod19.z.boolean(),
+  ab_testing: import_zod20.z.boolean(),
   /** Open and click tracking, still off until a workspace turns it on (`settings.tracking_enabled`). */
-  tracking: import_zod19.z.boolean(),
+  tracking: import_zod20.z.boolean(),
   /** Automations: flows a person walks through step by step (A1). */
-  automations: import_zod19.z.boolean()
+  automations: import_zod20.z.boolean()
 });
 var PLAN_FEATURES = ["ab_testing", "tracking", "automations"];
-var Plan = import_zod19.z.object({
+var Plan = import_zod20.z.object({
   id: PlanId,
-  name: import_zod19.z.string().min(1),
+  name: import_zod20.z.string().min(1),
   /** Price in the smallest currency unit per month; null for plans not sold. */
-  monthly_price_cents: import_zod19.z.number().int().min(0).nullable(),
-  currency: import_zod19.z.string().length(3),
+  monthly_price_cents: import_zod20.z.number().int().min(0).nullable(),
+  currency: import_zod20.z.string().length(3),
   limits: PlanLimits,
   features: PlanFeatures
 });
-var CatalogPlan = Plan.extend({ sellable: import_zod19.z.boolean() });
-var Subscription = import_zod19.z.object({
+var CatalogPlan = Plan.extend({ sellable: import_zod20.z.boolean() });
+var Subscription = import_zod20.z.object({
   workspace_id: Id,
   plan: PlanId,
-  status: import_zod19.z.enum(["active", "trialing", "past_due", "cancelled"]),
+  status: import_zod20.z.enum(["active", "trialing", "past_due", "cancelled"]),
   current_period_start: Timestamp,
   current_period_end: Timestamp,
-  cancel_at_period_end: import_zod19.z.boolean(),
+  cancel_at_period_end: import_zod20.z.boolean(),
   /**
    * A design partner outside billing (plan `design_partner`, no limits, no
    * checkout). Set only by an operator, never through the API.
    */
-  billing_exempt: import_zod19.z.boolean(),
+  billing_exempt: import_zod20.z.boolean(),
   /**
    * Own sending domains bought on top of the plan's included ones (the
    * add-on), each a monthly charge on the same subscription. 0 without the
    * add-on; the usage limit `sending_domains` is the plan's plus these.
    */
-  extra_sending_domains: import_zod19.z.number().int().min(0)
+  extra_sending_domains: import_zod20.z.number().int().min(0)
 });
-var BillingAddons = import_zod19.z.object({
-  sending_domain: import_zod19.z.object({
-    monthly_price_cents: import_zod19.z.number().int().min(0),
-    currency: import_zod19.z.string().length(3),
-    sellable: import_zod19.z.boolean()
+var BillingAddons = import_zod20.z.object({
+  sending_domain: import_zod20.z.object({
+    monthly_price_cents: import_zod20.z.number().int().min(0),
+    currency: import_zod20.z.string().length(3),
+    sellable: import_zod20.z.boolean()
   })
 });
 var MAX_EXTRA_SENDING_DOMAINS = 100;
-var ExtraSendingDomainsUpdate = import_zod19.z.object({ quantity: import_zod19.z.number().int().min(0).max(MAX_EXTRA_SENDING_DOMAINS) });
+var ExtraSendingDomainsUpdate = import_zod20.z.object({ quantity: import_zod20.z.number().int().min(0).max(MAX_EXTRA_SENDING_DOMAINS) });
 var USAGE_METRICS = ["messages", "contacts", "members", "providers", "webhook_endpoints", "active_automations", "sending_domains"];
-var UsageMetric = import_zod19.z.enum(USAGE_METRICS);
+var UsageMetric = import_zod20.z.enum(USAGE_METRICS);
 var USAGE_WARNING_RATIO = 0.8;
-var UsageWarning = import_zod19.z.object({
+var UsageWarning = import_zod20.z.object({
   metric: UsageMetric,
-  used: import_zod19.z.number().int().min(0),
-  limit: import_zod19.z.number().int().min(0),
+  used: import_zod20.z.number().int().min(0),
+  limit: import_zod20.z.number().int().min(0),
   /** `approaching`: at or above USAGE_WARNING_RATIO of the limit; `reached`: at or above the limit. */
-  level: import_zod19.z.enum(["approaching", "reached"])
+  level: import_zod20.z.enum(["approaching", "reached"])
 });
-var TermsStatus = import_zod19.z.object({ accepted_version: import_zod19.z.string().nullable(), current_version: import_zod19.z.string() });
-var Usage = import_zod19.z.object({
+var TermsStatus = import_zod20.z.object({ accepted_version: import_zod20.z.string().nullable(), current_version: import_zod20.z.string() });
+var Usage = import_zod20.z.object({
   plan: PlanId,
   period_start: Timestamp,
   period_end: Timestamp,
-  metrics: import_zod19.z.record(UsageMetric, import_zod19.z.object({ used: import_zod19.z.number().int().min(0), limit: import_zod19.z.number().int().min(0).nullable() })),
-  warnings: import_zod19.z.array(UsageWarning),
+  metrics: import_zod20.z.record(UsageMetric, import_zod20.z.object({ used: import_zod20.z.number().int().min(0), limit: import_zod20.z.number().int().min(0).nullable() })),
+  warnings: import_zod20.z.array(UsageWarning),
   terms: TermsStatus
 });
-var TermsAcceptance = import_zod19.z.object({ accept_terms: AcceptTerms });
-var CheckoutRequest = import_zod19.z.object({
-  plan: import_zod19.z.enum(["starter", "growth"]),
-  success_url: import_zod19.z.string().url(),
-  cancel_url: import_zod19.z.string().url(),
+var TermsAcceptance = import_zod20.z.object({ accept_terms: AcceptTerms });
+var CheckoutRequest = import_zod20.z.object({
+  plan: import_zod20.z.enum(["starter", "growth"]),
+  success_url: import_zod20.z.string().url(),
+  cancel_url: import_zod20.z.string().url(),
   /** The buyer accepted the terms of service and the processing agreement of this version. */
   accept_terms: AcceptTerms
 });
-var CheckoutSession = import_zod19.z.object({ url: import_zod19.z.string().url() });
-var PortalRequest = import_zod19.z.object({ return_url: import_zod19.z.string().url() });
-var PortalSession = import_zod19.z.object({ url: import_zod19.z.string().url() });
+var CheckoutSession = import_zod20.z.object({ url: import_zod20.z.string().url() });
+var PortalRequest = import_zod20.z.object({ return_url: import_zod20.z.string().url() });
+var PortalSession = import_zod20.z.object({ url: import_zod20.z.string().url() });
 var USAGE_WARNING_HEADER = "x-mail-usage-warning";
 function formatUsageWarningHeader(warnings) {
   if (warnings.length === 0) return null;
@@ -5310,7 +5722,7 @@ function parseUsageWarningHeader(value) {
 }
 
 // src/routes.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var list = (item) => page(item);
 var foundationRoutes = {
   "workspaces.create": {
@@ -5556,7 +5968,7 @@ var templateRoutes = {
     path: "/v1/templates/:id/export",
     params: IdParams,
     query: TemplateExportQuery,
-    response: import_zod20.z.string(),
+    response: import_zod21.z.string(),
     responseType: "text",
     status: 200,
     access: "read",
@@ -5936,7 +6348,7 @@ var sendingRoutes = {
     path: "/v1/mailings/:id/export",
     params: IdParams,
     query: MailingExportQuery,
-    response: import_zod20.z.string(),
+    response: import_zod21.z.string(),
     responseType: "text",
     status: 200,
     access: "read",
@@ -6203,7 +6615,7 @@ var platformRoutes = {
   "contactProperties.list": {
     method: "GET",
     path: "/v1/contact-properties",
-    response: import_zod20.z.object({ data: import_zod20.z.array(ContactPropertyDefinition) }),
+    response: import_zod21.z.object({ data: import_zod21.z.array(ContactPropertyDefinition) }),
     status: 200,
     access: "read",
     phase: "S4"
@@ -6502,7 +6914,7 @@ var billingRoutes = {
   "billing.plans": {
     method: "GET",
     path: "/v1/billing/plans",
-    response: import_zod20.z.object({ data: import_zod20.z.array(CatalogPlan), addons: BillingAddons }),
+    response: import_zod21.z.object({ data: import_zod21.z.array(CatalogPlan), addons: BillingAddons }),
     status: 200,
     access: "read",
     phase: "S5"
@@ -6591,6 +7003,73 @@ var domainBuyingRoutes = {
     phase: "S5"
   }
 };
+var boughtDomainRoutes = {
+  "boughtDomains.list": {
+    method: "GET",
+    path: "/v1/bought-domains",
+    response: import_zod21.z.object({ data: import_zod21.z.array(BoughtDomain) }),
+    status: 200,
+    access: "admin",
+    phase: "S5"
+  },
+  "boughtDomains.records": {
+    method: "GET",
+    path: "/v1/bought-domains/:id/records",
+    params: IdParams,
+    response: import_zod21.z.object({ data: import_zod21.z.array(DomainRecord) }),
+    status: 200,
+    access: "admin",
+    phase: "S5"
+  },
+  "boughtDomains.createRecord": {
+    method: "POST",
+    path: "/v1/bought-domains/:id/records",
+    params: IdParams,
+    body: DomainRecordInput,
+    response: DomainRecord,
+    status: 201,
+    access: "admin",
+    phase: "S5"
+  },
+  "boughtDomains.updateRecord": {
+    method: "PATCH",
+    path: "/v1/bought-domains/:id/records/:record_id",
+    params: BoughtDomainRecordParams,
+    body: DomainRecordInput,
+    response: DomainRecord,
+    status: 200,
+    access: "admin",
+    phase: "S5"
+  },
+  "boughtDomains.deleteRecord": {
+    method: "DELETE",
+    path: "/v1/bought-domains/:id/records/:record_id",
+    params: BoughtDomainRecordParams,
+    response: Ok,
+    status: 200,
+    access: "admin",
+    phase: "S5"
+  },
+  "boughtDomains.zoneFile": {
+    method: "GET",
+    path: "/v1/bought-domains/:id/zone-file",
+    params: IdParams,
+    response: ZoneFile,
+    status: 200,
+    access: "admin",
+    phase: "S5"
+  },
+  "boughtDomains.leave": {
+    method: "POST",
+    path: "/v1/bought-domains/:id/leave",
+    params: IdParams,
+    body: DomainLeaveCreate,
+    response: BoughtDomain,
+    status: 201,
+    access: "admin",
+    phase: "S5"
+  }
+};
 var inviteRoutes = {
   "invites.create": {
     method: "POST",
@@ -6700,7 +7179,7 @@ var automationRoutes = {
     method: "POST",
     path: "/v1/automations/:id/pause",
     params: IdParams,
-    body: import_zod20.z.object({}).strict(),
+    body: import_zod21.z.object({}).strict(),
     response: Automation,
     status: 200,
     access: "write",
@@ -6710,7 +7189,7 @@ var automationRoutes = {
     method: "POST",
     path: "/v1/automations/:id/resume",
     params: IdParams,
-    body: import_zod20.z.object({}).strict(),
+    body: import_zod21.z.object({}).strict(),
     response: Automation,
     status: 200,
     access: "write",
@@ -6720,7 +7199,7 @@ var automationRoutes = {
     method: "POST",
     path: "/v1/automations/:id/archive",
     params: IdParams,
-    body: import_zod20.z.object({}).strict(),
+    body: import_zod21.z.object({}).strict(),
     response: Automation,
     status: 200,
     access: "write",
@@ -6836,6 +7315,7 @@ var routes = {
   ...platformRoutes,
   ...billingRoutes,
   ...domainBuyingRoutes,
+  ...boughtDomainRoutes,
   ...automationRoutes
 };
 var TRUSTED_APP_OPERATIONS = {
@@ -6968,6 +7448,8 @@ function matchRoute(method, pathname) {
   BEARER_PREFIX,
   BILLING_NOT_CONFIGURED_REASON,
   BillingAddons,
+  BoughtDomain,
+  BoughtDomainRecordParams,
   BoundedAutomationFilter,
   BoundedSegmentFilter,
   COMPANY_GRANT_ROLES,
@@ -7002,21 +7484,33 @@ function matchRoute(method, pathname) {
   DATE_PASSED_ANSWERS,
   DEFAULT_INVITE_TTL_DAYS,
   DEFAULT_PAGE_LIMIT,
+  DNS_RECORD_TYPES,
   DOCUMENT_SCHEMA_VERSIONS,
   DOMAIN_BUYING_BLOCKS,
   DOMAIN_BUYING_NOT_CONFIGURED_REASON,
+  DOMAIN_LEAVE_STATES,
+  DOMAIN_LEAVE_WAYS,
+  DOMAIN_ORDER_KINDS,
   DOMAIN_ORDER_STATES,
   DOMAIN_PRICE_CHANGED_REASON,
   DOMAIN_UNAVAILABLE_REASONS,
   DateOnly,
   DatePassedAnswer,
   DelayStep,
+  DnsRecordType,
   DocumentSchemaVersion,
   DomainBuyingBlock,
+  DomainLeave,
+  DomainLeaveCreate,
+  DomainLeaveState,
+  DomainLeaveWay,
   DomainOffer,
   DomainOrder,
   DomainOrderCreate,
+  DomainOrderKind,
   DomainOrderState,
+  DomainRecord,
+  DomainRecordInput,
   DomainRegistrant,
   DomainSearchQuery,
   DomainSearchResult,
@@ -7229,6 +7723,7 @@ function matchRoute(method, pathname) {
   QuietHours,
   RECIPIENT_REJECTIONS,
   RECIPIENT_STATUSES,
+  REGISTRY_PHONE,
   REQUEST_ID_HEADER,
   RESEND_EVENT_TYPES,
   RESERVED_MERGE_FIELDS,
@@ -7393,6 +7888,7 @@ function matchRoute(method, pathname) {
   WorkspaceMove,
   WorkspaceSettings,
   WorkspaceUpdate,
+  ZoneFile,
   acceptsIdempotencyKey,
   addInsertion,
   addInsertionChoice,
@@ -7402,6 +7898,7 @@ function matchRoute(method, pathname) {
   automationFilterFamily,
   automationRoutes,
   billingRoutes,
+  boughtDomainRoutes,
   buildPath,
   buildTemplatePatch,
   canDeleteMailing,
@@ -7466,6 +7963,7 @@ function matchRoute(method, pathname) {
   missingInsertionTexts,
   missingRequiredMergeFields,
   normalizeChoiceKey,
+  normalizePhone,
   nowSeconds,
   operationsWithAccess,
   ownEntry,