@marlinjai/mail-contract 0.2.0

package/dist/index.mjs

@@ -0,0 +1,4631 @@
+// src/common.ts
+import { z } from "zod";
+var Id = z.string().min(1).max(64);
+var Timestamp = z.string().datetime({ offset: true });
+var Email = z.string().trim().min(3).max(254).email();
+var Slug = z.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "lowercase letters, digits and single hyphens");
+var JsonValue = z.lazy(
+  () => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(JsonValue), z.record(JsonValue)])
+);
+var Properties = z.record(JsonValue);
+var DEFAULT_PAGE_LIMIT = 50;
+var MAX_PAGE_LIMIT = 100;
+var PageQuery = z.object({
+  cursor: z.string().min(1).max(512).optional(),
+  limit: z.coerce.number().int().min(1).max(MAX_PAGE_LIMIT).optional()
+});
+function page(item) {
+  return z.object({
+    data: z.array(item),
+    next_cursor: z.string().nullable()
+  });
+}
+var IdParams = z.object({ id: Id });
+var Ok = z.object({ ok: z.literal(true) });
+
+// src/errors.ts
+import { z as z2 } from "zod";
+var ERROR_STATUS = {
+  // 400: the request is malformed or fails validation
+  invalid_request: 400,
+  validation_failed: 400,
+  invalid_cursor: 400,
+  // 401 and 403: who is calling and whether they may
+  unauthenticated: 401,
+  invalid_api_key: 401,
+  api_key_revoked: 401,
+  forbidden: 403,
+  insufficient_role: 403,
+  // 404
+  not_found: 404,
+  // 409: the resource is in a state that does not allow the operation
+  conflict: 409,
+  already_exists: 409,
+  mailing_invalid_state: 409,
+  idempotency_key_reused: 409,
+  last_owner: 409,
+  /** The provider's bounce circuit breaker is open: an admin clears it with providers.clearAnomaly. */
+  provider_anomaly: 409,
+  // 413
+  payload_too_large: 413,
+  // 422: well-formed, but the content cannot be used
+  compile_failed: 422,
+  /** MJML that cannot be imported; `details.reason` is one of MJML_IMPORT_REFUSALS, with `line` and `column`. */
+  invalid_mjml: 422,
+  missing_unsubscribe_url: 422,
+  mailing_not_ready: 422,
+  unknown_topic: 422,
+  unknown_provider: 422,
+  /**
+   * A1: an automation names a tag, topic, template, segment or signup form the
+   * workspace no longer has. `details` carries which.
+   */
+  unknown_reference: 422,
+  /** A1: the automation is not in a state this call can act on (publishing an archived one, enrolling into a draft). */
+  automation_invalid_state: 422,
+  recipient_suppressed: 422,
+  unsupported_media_type: 422,
+  /** Opens and clicks are not tracked in this workspace (an A/B metric, an engagement filter). */
+  tracking_disabled: 422,
+  // 429
+  rate_limited: 429,
+  daily_budget_exhausted: 429,
+  plan_limit_reached: 429,
+  // 5xx
+  provider_error: 502,
+  internal_error: 500,
+  service_unavailable: 503
+};
+var ERROR_CODES = Object.keys(ERROR_STATUS);
+var ErrorCodeSchema = z2.enum(ERROR_CODES);
+var ErrorBody = z2.object({
+  error: z2.object({
+    code: ErrorCodeSchema,
+    message: z2.string().min(1),
+    details: z2.record(z2.unknown()).optional()
+  })
+});
+var ValidationIssue = z2.object({
+  path: z2.array(z2.union([z2.string(), z2.number()])),
+  message: z2.string()
+});
+function statusForError(code) {
+  return ERROR_STATUS[code];
+}
+function errorBody(code, message, details) {
+  return details === void 0 ? { error: { code, message } } : { error: { code, message, details } };
+}
+var RETRYABLE_ERRORS = [
+  "rate_limited",
+  "provider_error",
+  "internal_error",
+  "service_unavailable"
+];
+var BILLING_NOT_CONFIGURED_REASON = "billing_not_configured";
+function isRetryableError(code, details) {
+  return RETRYABLE_ERRORS.includes(code) && details?.reason !== BILLING_NOT_CONFIGURED_REASON;
+}
+
+// src/headers.ts
+var AUTHORIZATION_HEADER = "authorization";
+var BEARER_PREFIX = "Bearer ";
+var IDEMPOTENCY_KEY_HEADER = "idempotency-key";
+var IDEMPOTENCY_KEY_MAX_LENGTH = 255;
+var IDEMPOTENCY_KEY_RETENTION_HOURS = 24;
+var SUBJECT_HEADER = "x-mail-subject";
+var WORKSPACE_HEADER = "x-mail-workspace";
+var REQUEST_ID_HEADER = "x-request-id";
+var RETRY_AFTER_HEADER = "retry-after";
+var API_VERSION_PREFIX = "/v1";
+var HEALTH_PATH = "/healthz";
+
+// src/workspace.ts
+import { z as z8 } from "zod";
+
+// src/automations.ts
+import { z as z7 } from "zod";
+
+// src/templates.ts
+import { z as z3 } from "zod";
+var DOCUMENT_SCHEMA_VERSIONS = ["1.0", "1.1"];
+var DocumentSchemaVersion = z3.enum(DOCUMENT_SCHEMA_VERSIONS);
+var TemplateDocument = z3.object({
+  version: DocumentSchemaVersion,
+  metadata: z3.record(z3.unknown()),
+  sections: z3.array(z3.record(z3.unknown()))
+}).passthrough();
+var MAX_DOCUMENT_BYTES = 1e6;
+var Template = z3.object({
+  id: Id,
+  name: z3.string().min(1).max(200),
+  description: z3.string().max(2e3).nullable(),
+  document: TemplateDocument,
+  /** Increments on every saved change. */
+  version: z3.number().int().min(1),
+  thumbnail_url: z3.string().url().nullable(),
+  archived_at: Timestamp.nullable(),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var TemplateSummary = Template.omit({ document: true });
+var TemplateCreate = z3.object({
+  name: z3.string().min(1).max(200),
+  description: z3.string().max(2e3).optional(),
+  document: TemplateDocument
+});
+var TemplateUpdate = z3.object({
+  base_version: z3.number().int().min(1),
+  name: z3.string().min(1).max(200).optional(),
+  description: z3.string().max(2e3).nullable().optional(),
+  document: TemplateDocument.optional(),
+  archived: z3.boolean().optional()
+}).refine(
+  (v) => v.name !== void 0 || v.description !== void 0 || v.document !== void 0 || v.archived !== void 0,
+  "at least one field besides base_version"
+);
+var SavedSectionBody = z3.record(z3.unknown());
+var MAX_SAVED_SECTIONS = 50;
+var SavedSection = z3.object({
+  id: Id,
+  name: z3.string().min(1).max(200),
+  description: z3.string().max(2e3).nullable(),
+  section: SavedSectionBody,
+  created_by: z3.string().nullable(),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var SavedSectionCreate = z3.object({
+  name: z3.string().min(1).max(200),
+  description: z3.string().max(2e3).optional(),
+  section: SavedSectionBody
+});
+var SavedSectionUpdate = z3.object({
+  name: z3.string().min(1).max(200).optional(),
+  description: z3.string().max(2e3).nullable().optional(),
+  section: SavedSectionBody.optional()
+}).refine((v) => v.name !== void 0 || v.description !== void 0 || v.section !== void 0, "at least one field");
+var TemplateListQuery = PageQuery.extend({
+  archived: z3.enum(["true", "false"]).optional()
+});
+var TemplateVersion = z3.object({
+  template_id: Id,
+  version: z3.number().int().min(1),
+  document: TemplateDocument,
+  created_by: z3.string().nullable(),
+  created_at: Timestamp
+});
+var TemplateVersionParams = z3.object({
+  id: Id,
+  version: z3.coerce.number().int().min(1)
+});
+var CompileMessage = z3.object({
+  message: z3.string().min(1),
+  /** Where in the document or the MJML the message points, when known. */
+  path: z3.string().optional(),
+  line: z3.number().int().min(1).optional()
+});
+var CompileResult = z3.object({
+  mjml: z3.string(),
+  html: z3.string(),
+  warnings: z3.array(CompileMessage),
+  errors: z3.array(CompileMessage)
+});
+var TemplateCompileRequest = z3.object({
+  version: z3.number().int().min(1).optional()
+});
+var CompileRequest = z3.object({
+  document: TemplateDocument
+});
+var ASSET_CONTENT_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+var AssetContentType = z3.enum(ASSET_CONTENT_TYPES);
+var MAX_ASSET_BYTES = 10 * 1024 * 1024;
+var Asset = z3.object({
+  id: Id,
+  url: z3.string().url(),
+  content_type: AssetContentType,
+  size_bytes: z3.number().int().min(1).max(MAX_ASSET_BYTES),
+  width: z3.number().int().min(1).nullable(),
+  height: z3.number().int().min(1).nullable(),
+  filename: z3.string().min(1).max(255),
+  created_at: Timestamp
+});
+var ASSET_UPLOAD_FIELD = "file";
+var MAX_IMPORT_URL_LENGTH = 2048;
+var AssetImport = z3.object({
+  url: z3.string().max(MAX_IMPORT_URL_LENGTH).url().refine((u) => {
+    try {
+      const url = new URL(u);
+      if (url.protocol === "https:") return true;
+      return url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1");
+    } catch {
+      return false;
+    }
+  }, "must be https (http only for localhost)"),
+  /** The stored file name; derived from the address when omitted. */
+  filename: z3.string().min(1).max(255).optional()
+});
+var MAX_MJML_IMPORT_BYTES = 512 * 1024;
+var MAX_MJML_DEPTH = 32;
+var MAX_MJML_ELEMENTS = 5e3;
+var MAX_IMPORTED_REMOTE_IMAGES = 50;
+var MJML_IMPORT_REFUSALS = [
+  "invalid_xml",
+  "not_mjml",
+  "include_not_supported",
+  "too_deep",
+  "too_many_elements",
+  "too_complex",
+  "invalid_document"
+];
+var ImportWarning = z3.object({
+  severity: z3.enum(["info", "warning"]),
+  /** Stable kind, e.g. `kept_as_html`, `unknown_component`, `remote_image_not_imported`. */
+  code: z3.string().min(1).max(64),
+  /** Where in the source, e.g. `mj-body > mj-section[2] > mj-column[1] > mj-social[1]`. */
+  path: z3.string(),
+  line: z3.number().int().min(1).optional(),
+  message: z3.string().min(1),
+  fragment: z3.string().optional()
+});
+var RemoteImage = z3.object({
+  url: z3.string().min(1),
+  /** The element and attribute it is loaded from, e.g. `<img src>`. */
+  where: z3.string()
+});
+var ImportedAsset = z3.object({
+  source_url: z3.string().min(1),
+  asset_id: Id,
+  url: z3.string().url()
+});
+var mjmlSource = z3.string().min(1, "paste or upload the MJML");
+var TemplateImportPreviewRequest = z3.object({ mjml: mjmlSource });
+var TemplateImportPreview = z3.object({
+  document: TemplateDocument,
+  warnings: z3.array(ImportWarning),
+  /** The document compiled under the workspace's asset policy, exactly as a send would. */
+  compiled: CompileResult,
+  /** Images loaded from outside the service; under `service_only` each is also a compile error. */
+  remote_images: z3.array(RemoteImage),
+  asset_policy: z3.enum(["any", "service_only"])
+});
+var TemplateImport = z3.object({
+  name: z3.string().min(1).max(200),
+  description: z3.string().max(2e3).optional(),
+  mjml: mjmlSource,
+  import_remote_assets: z3.boolean().optional()
+});
+var TemplateImportResult = z3.object({
+  template: Template,
+  warnings: z3.array(ImportWarning),
+  imported_assets: z3.array(ImportedAsset)
+});
+var EXPORT_FORMATS = ["mjml", "html"];
+var ExportFormat = z3.enum(EXPORT_FORMATS);
+var TemplateExportQuery = z3.object({
+  format: ExportFormat,
+  version: z3.coerce.number().int().min(1).optional()
+});
+var MailingExportQuery = z3.object({ format: ExportFormat });
+var EXPORT_CONTENT_TYPES = {
+  mjml: "text/plain; charset=utf-8",
+  html: "text/html; charset=utf-8"
+};
+var EXPORT_WARNINGS_HEADER = "x-mail-export-warnings";
+var EXPORT_WARNING_COUNT_HEADER = "x-mail-export-warning-count";
+var MAX_EXPORT_WARNINGS_HEADER_LENGTH = 6e3;
+function formatExportWarningsHeader(messages) {
+  const kept = [];
+  for (const m of messages) {
+    if (encodeURIComponent(JSON.stringify([...kept, m])).length > MAX_EXPORT_WARNINGS_HEADER_LENGTH) break;
+    kept.push(m);
+  }
+  return encodeURIComponent(JSON.stringify(kept));
+}
+function parseExportWarningsHeader(value) {
+  if (!value) return [];
+  try {
+    const parsed = z3.array(CompileMessage).safeParse(JSON.parse(decodeURIComponent(value)));
+    return parsed.success ? parsed.data : [];
+  } catch {
+    return [];
+  }
+}
+function exportFilename(name, format) {
+  const stem = name.replace(/ß/g, "ss").normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/g, "");
+  return `${stem || "export"}.${format}`;
+}
+
+// src/platform.ts
+import { z as z6 } from "zod";
+
+// src/mailings.ts
+import { z as z5 } from "zod";
+
+// src/ab-test.ts
+import { z as z4 } from "zod";
+var AbVariant = z4.object({
+  key: z4.string().regex(/^[a-z]$/, "a single lowercase letter"),
+  subject: z4.string().min(1).max(998).optional(),
+  /** Replaces the mailing's document for this variant. */
+  document: z4.record(z4.unknown()).optional(),
+  /**
+   * Keeps the document this variant key already has in the mailing's current
+   * test, so a test can be changed without sending every document again. The
+   * service refuses it (`validation_failed`) when that variant has none.
+   */
+  keep_document: z4.literal(true).optional()
+});
+var AB_WINNER_METRICS = ["opens", "clicks", "manual"];
+var AbTestConfig = z4.object({
+  variants: z4.array(AbVariant).min(2).max(5),
+  /** Share of recipients in the test group, split evenly across variants; the rest get the winner. */
+  test_fraction: z4.number().gt(0).lte(1),
+  winner_metric: z4.enum(AB_WINNER_METRICS),
+  decide_after_minutes: z4.number().int().min(15).max(10080).optional()
+}).refine((c) => new Set(c.variants.map((v) => v.key)).size === c.variants.length, "variant keys must be unique").refine((c) => c.variants.every((v) => v.subject !== void 0 || v.document !== void 0 || v.keep_document === true), {
+  message: "every variant changes the subject, the document or both",
+  path: ["variants"]
+}).refine((c) => c.variants.every((v) => !(v.document !== void 0 && v.keep_document === true)), {
+  message: "a variant sends a new document or keeps its current one, not both",
+  path: ["variants"]
+}).refine((c) => c.winner_metric === "manual" === (c.decide_after_minutes === void 0), {
+  message: "opens and clicks need decide_after_minutes; manual takes none",
+  path: ["decide_after_minutes"]
+});
+var AB_TEST_STATUSES = ["pending", "testing", "awaiting_pick", "decided"];
+var AbTestState = z4.object({
+  variants: z4.array(z4.object({ key: z4.string(), subject: z4.string().nullable(), has_document: z4.boolean() })),
+  test_fraction: z4.number(),
+  winner_metric: z4.enum(AB_WINNER_METRICS),
+  decide_after_minutes: z4.number().int().nullable(),
+  status: z4.enum(AB_TEST_STATUSES),
+  /** When the metric decides; null for manual or before the start. */
+  decide_at: Timestamp.nullable(),
+  winner: z4.string().nullable(),
+  decided_by: z4.enum(["metric", "manual"]).nullable(),
+  decided_at: Timestamp.nullable()
+});
+var AbWinnerRequest = z4.object({ variant: z4.string().regex(/^[a-z]$/) });
+function testGroupSize(total, fraction, variants) {
+  return Math.min(total, Math.max(variants, Math.ceil(total * fraction)));
+}
+
+// src/mailings.ts
+var MAILING_STATUSES = [
+  "draft",
+  "scheduled",
+  "sending",
+  "paused",
+  "sent",
+  "partially_failed",
+  "cancelled"
+];
+var MailingStatus = z5.enum(MAILING_STATUSES);
+var MAILING_ACTIONS = ["send", "schedule", "unschedule", "pause", "resume", "cancel", "retry-failed"];
+var MailingAction = z5.enum(MAILING_ACTIONS);
+var MAILING_TRANSITIONS = {
+  draft: ["send", "schedule", "cancel"],
+  scheduled: ["send", "schedule", "unschedule", "cancel"],
+  sending: ["pause", "cancel"],
+  paused: ["resume", "cancel"],
+  sent: [],
+  partially_failed: ["retry-failed"],
+  cancelled: []
+};
+function canTransition(status, action) {
+  return MAILING_TRANSITIONS[status].includes(action);
+}
+var EDITABLE_MAILING_STATUSES = ["draft", "scheduled"];
+var TERMINAL_MAILING_STATUSES = ["sent", "cancelled"];
+var MailingMetadata = z5.record(z5.string().max(500)).refine((v) => Object.keys(v).length <= 20, "at most 20 keys").refine((v) => Object.keys(v).every((k) => k.length >= 1 && k.length <= 64), "keys are 1 to 64 characters");
+var MailingCounts = z5.object({
+  total: z5.number().int().min(0),
+  queued: z5.number().int().min(0),
+  sending: z5.number().int().min(0),
+  sent: z5.number().int().min(0),
+  failed: z5.number().int().min(0),
+  skipped: z5.number().int().min(0)
+});
+var MAILING_KINDS = ["broadcast", "automation", "notification"];
+var MailingKind = z5.enum(MAILING_KINDS);
+var Mailing = z5.object({
+  id: Id,
+  kind: MailingKind,
+  name: z5.string().max(200).nullable(),
+  subject: z5.string().min(1).max(998),
+  preheader: z5.string().max(500).nullable(),
+  /** The template the document was taken from, if any. The snapshot is what is sent. */
+  template_id: Id.nullable(),
+  document: TemplateDocument,
+  topic: Slug,
+  provider_id: Id,
+  status: MailingStatus,
+  counts: MailingCounts,
+  metadata: MailingMetadata,
+  scheduled_at: Timestamp.nullable(),
+  /** The A/B test on subject or content (S4), null when there is none. */
+  ab_test: AbTestState.nullable(),
+  started_at: Timestamp.nullable(),
+  finished_at: Timestamp.nullable(),
+  /**
+   * Why the service paused the mailing itself, null when a person paused it or
+   * it is not paused. Today only the bounce circuit breaker does: too many
+   * recipients refused as dead addresses in one run (see the provider's
+   * `rejections.anomaly`). Resuming clears it and starts a new run.
+   */
+  pause_reason: z5.string().nullable().default(null),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var MailingSummary = Mailing.omit({ document: true });
+var MailingContent = {
+  name: z5.string().max(200).optional(),
+  subject: z5.string().min(1).max(998),
+  preheader: z5.string().max(500).optional(),
+  topic: Slug,
+  provider_id: Id,
+  metadata: MailingMetadata.optional()
+};
+var MailingCreate = z5.object({
+  ...MailingContent,
+  document: TemplateDocument.optional(),
+  template_id: Id.optional()
+}).refine((v) => v.document === void 0 !== (v.template_id === void 0), {
+  message: "exactly one of document or template_id",
+  path: ["document"]
+});
+var MailingUpdate = z5.object({
+  name: z5.string().max(200).nullable().optional(),
+  subject: MailingContent.subject.optional(),
+  preheader: z5.string().max(500).nullable().optional(),
+  topic: Slug.optional(),
+  provider_id: Id.optional(),
+  metadata: MailingMetadata.optional(),
+  document: TemplateDocument.optional()
+}).refine((v) => Object.keys(v).length > 0, "at least one field");
+var MailingListQuery = PageQuery.extend({
+  status: MailingStatus.optional(),
+  topic: Slug.optional(),
+  kind: MailingKind.optional(),
+  automation_id: Id.optional()
+});
+var MailingSendRequest = z5.object({}).strict();
+var MailingRetryFailedRequest = z5.object({
+  /**
+   * Also requeue recipients whose outcome is unknown after a crash. They may
+   * already have received the message, so this is a human's decision, never a
+   * default.
+   */
+  include_outcome_unknown: z5.boolean().optional()
+}).strict();
+var MailingActionRequest = z5.object({}).strict();
+var MailingTestRequest = z5.object({
+  to: Email,
+  merge: Properties.optional()
+});
+var MailingTestResult = z5.object({
+  message_id: Id,
+  provider_message_id: z5.string().nullable()
+});
+var RECIPIENT_STATUSES = ["queued", "sending", "sent", "failed", "skipped"];
+var RecipientStatus = z5.enum(RECIPIENT_STATUSES);
+var SKIP_REASONS = ["suppressed", "not_subscribed", "contact_erased", "cancelled", "outcome_unknown"];
+var SkipReason = z5.enum(SKIP_REASONS);
+var Recipient = z5.object({
+  id: Id,
+  mailing_id: Id,
+  contact_id: Id.nullable(),
+  email: Email,
+  merge: Properties,
+  status: RecipientStatus,
+  skip_reason: SkipReason.nullable(),
+  attempts: z5.number().int().min(0),
+  message_id: Id.nullable(),
+  last_error: z5.string().nullable(),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var MAX_RECIPIENTS_PER_BATCH = 1e3;
+var RecipientInput = z5.object({
+  contact_id: Id.optional(),
+  external_id: z5.string().min(1).max(255).optional(),
+  email: Email.optional(),
+  merge: Properties.optional()
+}).refine((v) => v.contact_id !== void 0 || v.external_id !== void 0 || v.email !== void 0, {
+  message: "contact_id, external_id or email is required",
+  path: ["email"]
+});
+var RecipientBatch = z5.object({
+  recipients: z5.array(RecipientInput).min(1).max(MAX_RECIPIENTS_PER_BATCH)
+});
+var RECIPIENT_REJECTIONS = ["unknown_contact", "duplicate_in_batch"];
+var RecipientBatchResult = z5.object({
+  /** Newly queued. */
+  added: z5.number().int().min(0),
+  /** Already on the mailing from an earlier batch: left unchanged. */
+  already_present: z5.number().int().min(0),
+  /** Items not added, by their index in the request. */
+  rejected: z5.array(z5.object({ index: z5.number().int().min(0), reason: z5.enum(RECIPIENT_REJECTIONS) }))
+});
+var RecipientListQuery = PageQuery.extend({
+  status: RecipientStatus.optional(),
+  skip_reason: SkipReason.optional()
+});
+var MESSAGE_OUTCOMES = ["sent", "failed"];
+var MessageOutcome = z5.enum(MESSAGE_OUTCOMES);
+var MessageSummary = z5.object({
+  id: Id,
+  mailing_id: Id.nullable(),
+  recipient_id: Id.nullable(),
+  contact_id: Id.nullable(),
+  to: Email,
+  subject: z5.string(),
+  provider_id: Id,
+  provider_message_id: z5.string().nullable(),
+  outcome: MessageOutcome,
+  error: z5.string().nullable(),
+  is_test: z5.boolean(),
+  recipient_count: z5.number().int().min(1),
+  created_at: Timestamp
+});
+var Message = MessageSummary.extend({ html: z5.string() });
+var MessageListQuery = PageQuery.extend({
+  mailing_id: Id.optional(),
+  outcome: MessageOutcome.optional()
+});
+
+// src/platform.ts
+var Tag = z6.object({
+  id: Id,
+  slug: Slug,
+  name: z6.string().min(1).max(120),
+  contact_count: z6.number().int().min(0),
+  created_at: Timestamp
+});
+var TagCreate = z6.object({ slug: Slug, name: z6.string().min(1).max(120) });
+var TagAssignment = z6.object({
+  contact_ids: z6.array(Id).min(1).max(1e3)
+});
+var CONTACT_PROPERTY_TYPES = ["string", "number", "boolean", "date"];
+var ContactPropertyType = z6.enum(CONTACT_PROPERTY_TYPES);
+var ContactPropertyKey = z6.string().regex(/^[A-Za-z0-9_.-]{1,64}$/, "letters, digits, dot, underscore and hyphen, 1 to 64");
+var ContactPropertyDefinition = z6.object({
+  key: ContactPropertyKey,
+  label: z6.string().min(1).max(120),
+  type: ContactPropertyType
+});
+var ContactPropertyParams = z6.object({ key: ContactPropertyKey });
+var FILTER_OPERATORS = [
+  "eq",
+  "neq",
+  "contains",
+  "not_contains",
+  "starts_with",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "exists",
+  "not_exists",
+  "in",
+  "not_in"
+];
+var FilterOperator = z6.enum(FILTER_OPERATORS);
+var FilterField = z6.string().regex(
+  /^(email|first_name|last_name|locale|created_at|tag|topic|engagement:(opened|clicked)|property:[A-Za-z0-9_.-]{1,64})$/,
+  "unknown filter field"
+);
+var FILTER_FIELD_OPERATORS = {
+  email: ["eq", "neq", "contains", "not_contains", "starts_with", "in", "not_in"],
+  first_name: ["eq", "neq", "contains", "not_contains", "starts_with", "exists", "not_exists", "in", "not_in"],
+  last_name: ["eq", "neq", "contains", "not_contains", "starts_with", "exists", "not_exists", "in", "not_in"],
+  locale: ["eq", "neq", "starts_with", "exists", "not_exists", "in", "not_in"],
+  created_at: ["gt", "gte", "lt", "lte"],
+  tag: ["eq", "neq", "in", "not_in"],
+  topic: ["eq", "neq", "in", "not_in"],
+  engagement: ["lte", "gt"],
+  property: FILTER_OPERATORS
+};
+var MAX_FILTER_DEPTH = 5;
+var FilterCondition = z6.object({ field: FilterField, op: FilterOperator, value: JsonValue.optional() }).strict().refine((c) => (c.op === "exists" || c.op === "not_exists") === (c.value === void 0), {
+  message: "exists and not_exists take no value; every other operator needs one",
+  path: ["value"]
+}).refine((c) => c.op !== "in" && c.op !== "not_in" || Array.isArray(c.value), {
+  message: "in and not_in take an array",
+  path: ["value"]
+});
+var SegmentFilter = z6.lazy(
+  () => z6.union([
+    z6.object({ and: z6.array(SegmentFilter).min(1).max(50) }).strict(),
+    z6.object({ or: z6.array(SegmentFilter).min(1).max(50) }).strict(),
+    z6.object({ not: SegmentFilter }).strict(),
+    FilterCondition
+  ])
+);
+function filterDepth(filter) {
+  if ("and" in filter) return 1 + Math.max(...filter.and.map(filterDepth));
+  if ("or" in filter) return 1 + Math.max(...filter.or.map(filterDepth));
+  if ("not" in filter) return 1 + filterDepth(filter.not);
+  return 1;
+}
+var BoundedSegmentFilter = SegmentFilter.refine((f) => filterDepth(f) <= MAX_FILTER_DEPTH, {
+  message: `nested deeper than ${MAX_FILTER_DEPTH} levels`
+});
+var MAX_IN_LIST = 500;
+var MAX_ENGAGEMENT_DAYS = 3650;
+function filterFieldFamily(field) {
+  const colon = field.indexOf(":");
+  return colon === -1 ? field : field.slice(0, colon);
+}
+var isScalar = (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean";
+var isFilterString = (v) => typeof v === "string";
+var isFilterNumber = (v) => typeof v === "number" && Number.isFinite(v);
+var DATE_VALUE_PREFIX = /^\d{4}-\d{2}-\d{2}/;
+function filterLeafProblem(c, types, operators = FILTER_FIELD_OPERATORS) {
+  const fam = filterFieldFamily(c.field);
+  const allowed = operators[fam];
+  if (!allowed || !allowed.includes(c.op)) {
+    return { at: "op", message: `${c.field} does not take ${c.op}; it takes ${(allowed ?? []).join(", ")}` };
+  }
+  if (c.op === "exists" || c.op === "not_exists") return null;
+  const list2 = c.op === "in" || c.op === "not_in";
+  const values = list2 ? c.value : [c.value];
+  if (list2 && (values.length === 0 || values.length > MAX_IN_LIST)) {
+    return { at: "value", message: `in and not_in take 1 to ${MAX_IN_LIST} values` };
+  }
+  const every = (ok, what) => values.every(ok) ? null : { at: "value", message: `${c.field} ${c.op} needs ${what}` };
+  switch (fam) {
+    case "email":
+    case "first_name":
+    case "last_name":
+    case "locale":
+      return every((v) => isFilterString(v) && v.length >= 1 && v.length <= 254, "strings of 1 to 254 characters");
+    case "created_at":
+      return every((v) => isFilterString(v) && Timestamp.safeParse(v).success, "an ISO 8601 timestamp with an offset");
+    case "tag":
+    case "topic":
+      return every((v) => Slug.safeParse(v).success, "slugs");
+    case "segment":
+      return every((v) => Id.safeParse(v).success, "segment ids");
+    case "engagement":
+      return every(
+        (v) => Number.isInteger(v) && v >= 1 && v <= MAX_ENGAGEMENT_DAYS,
+        `a whole number of days from 1 to ${MAX_ENGAGEMENT_DAYS}`
+      );
+    // An event's data is untyped, like a property with no definition.
+    case "event":
+      return untypedValueProblem(c, every);
+    case "property": {
+      const type = types.get(c.field.slice("property:".length));
+      const textOp = c.op === "contains" || c.op === "not_contains" || c.op === "starts_with";
+      const orderOp = c.op === "gt" || c.op === "gte" || c.op === "lt" || c.op === "lte";
+      switch (type) {
+        case "number":
+          if (textOp) return { at: "op", message: `${c.field} is a number; ${c.op} compares text` };
+          return every(isFilterNumber, "numbers");
+        case "boolean":
+          if (textOp || orderOp || list2) return { at: "op", message: `${c.field} is a boolean; it takes eq, neq, exists and not_exists` };
+          return every((v) => typeof v === "boolean", "true or false");
+        case "date":
+          if (textOp) return { at: "op", message: `${c.field} is a date; ${c.op} compares text` };
+          return every((v) => isFilterString(v) && DATE_VALUE_PREFIX.test(v) && !Number.isNaN(Date.parse(v.slice(0, 10))), "ISO 8601 dates");
+        case "string":
+          if (orderOp) return { at: "op", message: `${c.field} is a string; it cannot be ordered` };
+          return every((v) => isFilterString(v) && v.length <= 1e3, "strings of up to 1000 characters");
+        case void 0:
+          return untypedValueProblem(c, every);
+      }
+    }
+  }
+  return { at: "op", message: `unknown field ${c.field}` };
+}
+function untypedValueProblem(c, every) {
+  const textOp = c.op === "contains" || c.op === "not_contains" || c.op === "starts_with";
+  const orderOp = c.op === "gt" || c.op === "gte" || c.op === "lt" || c.op === "lte";
+  if (textOp) return every((v) => isFilterString(v) && v.length <= 1e3, "strings of up to 1000 characters");
+  if (orderOp) return every(isFilterNumber, "numbers (define the property to compare dates)");
+  return every((v) => isScalar(v) || v === null, "strings, numbers, booleans or null");
+}
+var Segment = z6.object({
+  id: Id,
+  name: z6.string().min(1).max(120),
+  filter: SegmentFilter,
+  /** Computed on read. */
+  contact_count: z6.number().int().min(0),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var SegmentCreate = z6.object({ name: z6.string().min(1).max(120), filter: BoundedSegmentFilter });
+var SegmentPreviewRequest = z6.object({ filter: BoundedSegmentFilter });
+var SegmentPreview = z6.object({
+  contact_count: z6.number().int().min(0),
+  /** Up to five matching contacts, for a human to sanity-check the filter. */
+  sample: z6.array(z6.object({ id: Id, email: Email })).max(5)
+});
+var MailingAudienceFromSegment = z6.object({ segment_id: Id });
+var SIGNUP_FORM_FIELDS = ["first_name", "last_name"];
+var HOSTED_PAGE_LOCALES = ["en", "de", "it", "fr", "es"];
+var SignupFormTranslation = z6.object({
+  title: z6.string().min(1).max(120),
+  consent_text: z6.string().min(1).max(2e3)
+});
+var SignupForm = z6.object({
+  id: Id,
+  name: z6.string().min(1).max(120),
+  /** The heading of the hosted page. */
+  title: z6.string().min(1).max(120),
+  /** What the person agrees to, shown above the button and recorded with the confirmation. */
+  consent_text: z6.string().min(1).max(2e3),
+  translations: z6.record(SignupFormTranslation),
+  topics: z6.array(Slug).min(1),
+  tags: z6.array(Slug),
+  /** Fields shown besides email. */
+  fields: z6.array(z6.enum(SIGNUP_FORM_FIELDS)),
+  double_opt_in: z6.literal(true),
+  /** The provider the confirmation mail is sent through. */
+  provider_id: Id,
+  /**
+   * A saved template for the confirmation mail; it must contain
+   * `{{confirm_url}}`. Null sends the built-in confirmation mail, localised.
+   */
+  confirmation_template_id: Id.nullable(),
+  /** Where the person lands after confirming. Null shows the hosted confirmation page. */
+  redirect_url: z6.string().url().nullable(),
+  /** Origins allowed to embed the form and call the submission route from a browser. */
+  allowed_origins: z6.array(z6.string().url()).max(20),
+  /** Bumped on every change; recorded with each confirmation. */
+  version: z6.number().int().min(1),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var SignupFormCreate = SignupForm.omit({
+  id: true,
+  created_at: true,
+  updated_at: true,
+  double_opt_in: true,
+  version: true
+}).extend({
+  translations: SignupForm.shape.translations.optional(),
+  tags: SignupForm.shape.tags.optional(),
+  fields: SignupForm.shape.fields.optional(),
+  confirmation_template_id: Id.nullable().optional(),
+  redirect_url: z6.string().url().nullable().optional(),
+  allowed_origins: SignupForm.shape.allowed_origins.optional()
+});
+var SignupFormEmbed = z6.object({
+  hosted_url: z6.string().url(),
+  /** A plain HTML form posting to the hosted page; works without JavaScript. */
+  html: z6.string(),
+  /** A small optional script that adds the time check and submits in place. */
+  script_url: z6.string().url(),
+  /** Where a browser fetches a fresh `form_token` from (GET, public, CORS for `allowed_origins`). */
+  token_url: z6.string().url()
+});
+var SignupSubmission = z6.object({
+  email: Email,
+  first_name: z6.string().max(200).optional(),
+  last_name: z6.string().max(200).optional(),
+  locale: z6.string().min(2).max(35).optional(),
+  /** Honeypot: must be empty. */
+  website: z6.string().max(0).optional(),
+  /**
+   * The signed render time from the form's token URL: a submission sooner than a
+   * human could fill the form, or long after, is refused.
+   */
+  form_token: z6.string().min(1).max(512)
+});
+var IMPORT_STATUSES = ["uploaded", "validating", "validated", "committing", "completed", "failed", "cancelled"];
+var ImportStatus = z6.enum(IMPORT_STATUSES);
+var IMPORT_TERMINAL_STATUSES = ["completed", "failed", "cancelled"];
+var ImportColumnMapping = z6.record(
+  z6.string().regex(/^(email|external_id|first_name|last_name|locale|property:[A-Za-z0-9_.-]{1,64}|ignore)$/)
+);
+var IMPORT_FILE_FIELD = "file";
+var MAX_IMPORT_BYTES = 50 * 1024 * 1024;
+var MAX_IMPORT_ROWS = 2e5;
+var ImportMappingRequest = z6.object({
+  /** CSV header -> contact field. Exactly one column maps to `email`. */
+  mapping: ImportColumnMapping.refine(
+    (m) => Object.values(m).filter((v) => v === "email").length === 1,
+    "exactly one column maps to email"
+  ),
+  topics: z6.array(Slug).max(100),
+  tags: z6.array(Slug).max(100),
+  /** Existing contacts get the mapped fields overwritten; false only adds topics, tags and missing fields. */
+  update_existing: z6.boolean().optional(),
+  /** The importer states the people consented; the service records who said so and when. */
+  consent_confirmed: z6.literal(true)
+});
+var ImportCommitRequest = z6.object({ mapping_version: z6.number().int().min(1) });
+var IMPORT_ROW_OUTCOMES = ["created", "updated", "unchanged", "suppressed", "skipped"];
+var ImportRowOutcome = z6.enum(IMPORT_ROW_OUTCOMES);
+var IMPORT_SKIP_REASONS = [
+  "missing_email",
+  "invalid_email",
+  "duplicate_in_file",
+  "invalid_value",
+  "external_id_conflict",
+  "wrong_column_count"
+];
+var ImportSkipReason = z6.enum(IMPORT_SKIP_REASONS);
+var ImportReport = z6.object({
+  created: z6.number().int().min(0),
+  updated: z6.number().int().min(0),
+  unchanged: z6.number().int().min(0),
+  suppressed: z6.number().int().min(0),
+  skipped: z6.number().int().min(0),
+  skipped_by_reason: z6.record(ImportSkipReason, z6.number().int().min(0)),
+  /** Rows whose contact was subscribed without some topic, because the address is blocked for it. */
+  topics_withheld: z6.number().int().min(0)
+});
+var ImportJob = z6.object({
+  id: Id,
+  status: ImportStatus,
+  file_name: z6.string().max(255).nullable(),
+  file_bytes: z6.number().int().min(0),
+  total_rows: z6.number().int().min(0),
+  /** The header row, as in the file. */
+  columns: z6.array(z6.string()),
+  /** The first rows, for the mapping screen. */
+  sample: z6.array(z6.array(z6.string())).max(5),
+  /** A mapping guessed from the headers, for the mapping screen to start from. */
+  suggested_mapping: ImportColumnMapping,
+  mapping: ImportColumnMapping.nullable(),
+  mapping_version: z6.number().int().min(0),
+  topics: z6.array(Slug),
+  tags: z6.array(Slug),
+  update_existing: z6.boolean(),
+  /** The dry run of the current mapping; null before one finished. */
+  dry_run: ImportReport.nullable(),
+  /** What the commit has written so far; null before it started. */
+  result: ImportReport.nullable(),
+  /** Rows the current phase (dry run or commit) has processed. */
+  processed_rows: z6.number().int().min(0),
+  /** Why a `failed` import failed. */
+  error: z6.string().nullable(),
+  created_at: Timestamp,
+  updated_at: Timestamp,
+  finished_at: Timestamp.nullable()
+});
+var ImportRow = z6.object({
+  /** The line in the file, 1 being the first line after the header. */
+  row: z6.number().int().min(1),
+  email: z6.string().nullable(),
+  outcome: ImportRowOutcome,
+  reason: ImportSkipReason.nullable(),
+  /** A human explanation for a skipped row (which value, which column). */
+  message: z6.string().nullable(),
+  contact_id: Id.nullable()
+});
+var ImportRowListQuery = PageQuery.extend({ outcome: ImportRowOutcome.optional() });
+var MailingScheduleRequest = z6.object({ send_at: Timestamp });
+var TrackingSettings = z6.object({ opens: z6.boolean(), clicks: z6.boolean() });
+var VariantAnalytics = z6.object({
+  key: z6.string(),
+  sent: z6.number().int().min(0),
+  unique_opens: z6.number().int().min(0).nullable(),
+  unique_clicks: z6.number().int().min(0).nullable()
+});
+var MailingAnalytics = z6.object({
+  mailing_id: Id,
+  counts: MailingCounts,
+  /** What was tracked for this mailing, fixed when it started; null before it started. */
+  tracking: TrackingSettings.nullable(),
+  /** Unique recipients with a human open. Null when opens were not tracked. */
+  unique_opens: z6.number().int().min(0).nullable(),
+  /**
+   * Recipients whose only opens came from Apple Mail Privacy Protection, which
+   * loads every image on delivery: counted apart, never as human opens.
+   */
+  apple_mpp_opens: z6.number().int().min(0).nullable(),
+  /** Opens and clicks from security scanners and prefetchers, filtered out of the unique counts. */
+  machine_events: z6.number().int().min(0).nullable(),
+  unique_clicks: z6.number().int().min(0).nullable(),
+  unsubscribes: z6.number().int().min(0),
+  bounces: z6.number().int().min(0),
+  complaints: z6.number().int().min(0),
+  links: z6.array(z6.object({ url: z6.string(), unique_clicks: z6.number().int().min(0) })).nullable(),
+  variants: z6.array(VariantAnalytics).nullable()
+});
+
+// src/automations.ts
+var AUTOMATION_FILTER_FIELD_PATTERN = /^(email|first_name|last_name|locale|created_at|tag|topic|segment|engagement:(opened|clicked)|step:(opened|clicked)|property:[A-Za-z0-9_.-]{1,64}|event:[A-Za-z0-9_.-]{1,64})$/;
+var AutomationFilterField = z7.string().regex(AUTOMATION_FILTER_FIELD_PATTERN, "unknown filter field");
+var AUTOMATION_FILTER_FIELD_OPERATORS = {
+  ...FILTER_FIELD_OPERATORS,
+  segment: ["eq", "neq", "in", "not_in"],
+  event: FILTER_FIELD_OPERATORS.property,
+  // Did they, or did they not. No `in`: naming several steps at once would be
+  // an "any of these" that the filter's own `or` already says more plainly.
+  step: ["eq", "neq"]
+};
+var automationFilterFamily = filterFieldFamily;
+var AutomationFilterCondition = z7.object({ field: AutomationFilterField, op: FilterOperator, value: JsonValue.optional() }).strict().refine((c) => (c.op === "exists" || c.op === "not_exists") === (c.value === void 0), {
+  message: "exists and not_exists take no value; every other operator needs one",
+  path: ["value"]
+}).refine((c) => c.op !== "in" && c.op !== "not_in" || Array.isArray(c.value), {
+  message: "in and not_in take an array",
+  path: ["value"]
+});
+var AutomationFilter = z7.lazy(
+  () => z7.union([
+    z7.object({ and: z7.array(AutomationFilter).min(1).max(50) }).strict(),
+    z7.object({ or: z7.array(AutomationFilter).min(1).max(50) }).strict(),
+    z7.object({ not: AutomationFilter }).strict(),
+    AutomationFilterCondition
+  ])
+);
+var BoundedAutomationFilter = AutomationFilter.refine((f) => filterDepth(f) <= MAX_FILTER_DEPTH, {
+  message: `nested deeper than ${MAX_FILTER_DEPTH} levels`
+});
+function filterConditions(filter) {
+  if ("and" in filter) return filter.and.flatMap(filterConditions);
+  if ("or" in filter) return filter.or.flatMap(filterConditions);
+  if ("not" in filter) return filterConditions(filter.not);
+  return [filter];
+}
+var StepId = z7.string().regex(/^[A-Za-z0-9_-]{1,64}$/, "letters, digits, underscore and hyphen, 1 to 64");
+var TimeOfDay = z7.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "HH:MM in 24 hours");
+var Weekday = z7.number().int().min(0).max(6);
+var TimezoneName = z7.string().min(1).max(64).regex(/^(UTC|[A-Za-z][A-Za-z0-9_+-]*(?:\/[A-Za-z0-9_+-]+)+)$/, "an IANA time zone name such as Europe/Berlin");
+var MAX_DELAY_SECONDS = 365 * 24 * 60 * 60;
+var DateOnly = z7.string().regex(/^\d{4}-\d{2}-\d{2}$/, "a calendar date such as 2026-09-20").refine((v) => {
+  const [y, m, d] = v.split("-").map(Number);
+  const t = new Date(Date.UTC(y, m - 1, d));
+  return t.getUTCFullYear() === y && t.getUTCMonth() + 1 === m && t.getUTCDate() === d;
+}, "a real calendar date");
+var OffsetDays = z7.number().int().min(-365).max(365);
+var DATE_PASSED_ANSWERS = ["skip", "stop", "continue"];
+var DatePassedAnswer = z7.enum(DATE_PASSED_ANSWERS);
+var EventName = z7.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/, "letters, digits, dot, colon, underscore and hyphen, 1 to 80");
+var AUTOMATION_TRIGGER_KINDS = [
+  "topic_subscribed",
+  "form_confirmed",
+  "tag_added",
+  "property_changed",
+  "event",
+  "manual",
+  "date_anniversary",
+  "exact_date",
+  "segment_entered",
+  "link_clicked"
+];
+var AutomationTriggerKind = z7.enum(AUTOMATION_TRIGGER_KINDS);
+var exclude = { exclude: BoundedAutomationFilter.nullish() };
+var AutomationTrigger = z7.discriminatedUnion("kind", [
+  z7.object({ kind: z7.literal("topic_subscribed"), topic: Slug, ...exclude }).strict(),
+  z7.object({ kind: z7.literal("form_confirmed"), form_id: Id, ...exclude }).strict(),
+  z7.object({ kind: z7.literal("tag_added"), tag: Slug, ...exclude }).strict(),
+  /** `to` given: only a change that lands on this value fires. Absent: any change of the key. */
+  z7.object({ kind: z7.literal("property_changed"), key: ContactPropertyKey, to: JsonValue.optional(), ...exclude }).strict(),
+  /** `where` filters the event's own data, so only `event:<key>` leaves belong in it. */
+  z7.object({ kind: z7.literal("event"), name: EventName, where: BoundedAutomationFilter.nullish(), ...exclude }).strict(),
+  z7.object({ kind: z7.literal("manual"), ...exclude }).strict(),
+  /**
+   * Every year on a date the contact carries: a birthday, a joining date, a
+   * renewal. `offset_days` moves it ("three days before"), `at` is the wall
+   * clock in the contact's own time zone. The property must be defined and of
+   * type `date`, which the validator checks.
+   *
+   * A 29 February date fires on 1 March in a year that has no 29 February, so
+   * nobody is skipped every fourth year.
+   */
+  z7.object({
+    kind: z7.literal("date_anniversary"),
+    key: ContactPropertyKey,
+    offset_days: OffsetDays,
+    at: TimeOfDay,
+    ...exclude
+  }).strict(),
+  /**
+   * Once, on one calendar day, for everyone `where` matches. `where` is read as
+   * a scan over the workspace's contacts rather than inside a run, so it may
+   * not ask about a segment or about an event's data: there is no event, and a
+   * segment is its own trigger kind.
+   */
+  z7.object({
+    kind: z7.literal("exact_date"),
+    on: DateOnly,
+    at: TimeOfDay,
+    where: BoundedAutomationFilter.nullish(),
+    ...exclude
+  }).strict(),
+  /**
+   * S4. When somebody starts matching a segment.
+   *
+   * The one trigger with no event behind it: a segment is evaluated when it is
+   * read, so nothing happens at the moment a contact begins to match one. A
+   * sweep keeps a membership snapshot per trigger and enters the difference, so
+   * "entered" means "was not a member when we last looked, and is now".
+   *
+   * That snapshot is seeded when the automation is published, which is what
+   * keeps publishing "when somebody joins VIPs" from mailing every VIP who
+   * already exists. Entering those people as well is the publish dialog's
+   * backfill question, answered by a person rather than by the sweep.
+   */
+  z7.object({ kind: z7.literal("segment_entered"), segment_id: Id, ...exclude }).strict(),
+  /**
+   * S4. When somebody clicks a link in a mailing that has already gone out.
+   *
+   * `url` narrows it to one link, matched exactly as the mailing stored it, and
+   * left out means any link in that mailing. It needs the workspace to record
+   * clicks, because it rides on the very rows that setting writes: with click
+   * tracking off there is no click to hear about, so the validator refuses it
+   * rather than leaving an automation that can never fire.
+   */
+  z7.object({ kind: z7.literal("link_clicked"), mailing_id: Id, url: z7.string().min(1).max(2048).optional(), ...exclude }).strict()
+]);
+var AUTOMATION_DATE_TRIGGER_KINDS = ["date_anniversary", "exact_date"];
+var MAX_TRIGGERS = 10;
+var AUTOMATION_STEP_KINDS = [
+  "email",
+  "delay",
+  "condition",
+  "add_tag",
+  "remove_tag",
+  "set_property",
+  "subscribe_topic",
+  "unsubscribe",
+  "exit",
+  "split",
+  "goto",
+  "webhook",
+  "notify"
+];
+var AutomationStepKind = z7.enum(AUTOMATION_STEP_KINDS);
+var next = { next: StepId.nullable() };
+var Unchosen = z7.literal("");
+var DraftSlug = z7.union([Slug, Unchosen]);
+var DraftPropertyKey = z7.union([ContactPropertyKey, Unchosen]);
+var label = { label: z7.string().max(120).nullish() };
+var EmailStep = z7.object({
+  kind: z7.literal("email"),
+  ...label,
+  ...next,
+  template_id: Id.nullish(),
+  document: TemplateDocument.nullish(),
+  /** Empty while the step is being written; `not_chosen` refuses to publish it. */
+  subject: z7.string().max(998),
+  preheader: z7.string().max(500).nullish()
+}).strict();
+var DelayStep = z7.object({
+  kind: z7.literal("delay"),
+  ...label,
+  ...next,
+  wait: z7.discriminatedUnion("mode", [
+    z7.object({ mode: z7.literal("duration"), seconds: z7.number().int().min(1).max(MAX_DELAY_SECONDS) }).strict(),
+    z7.object({ mode: z7.literal("time_of_day"), at: TimeOfDay }).strict(),
+    z7.object({ mode: z7.literal("weekday"), weekday: Weekday, at: TimeOfDay }).strict(),
+    /** A fixed day has no next occurrence, so `continue` is not one of its answers. */
+    z7.object({ mode: z7.literal("date"), on: DateOnly, at: TimeOfDay, passed: z7.enum(["skip", "stop"]) }).strict(),
+    z7.object({
+      mode: z7.literal("date_property"),
+      key: ContactPropertyKey,
+      offset_days: OffsetDays,
+      at: TimeOfDay,
+      passed: DatePassedAnswer
+    }).strict()
+  ])
+}).strict();
+var ConditionStep = z7.object({
+  kind: z7.literal("condition"),
+  ...label,
+  filter: BoundedAutomationFilter,
+  yes: StepId.nullable(),
+  no: StepId.nullable(),
+  /**
+   * How long to hold the run while the filter is false, and which branch it
+   * takes when that is up. One object rather than two loose fields, because
+   * neither half means anything without the other: a window with no answer
+   * for the end of it would be a silent decision.
+   */
+  wait_for: z7.object({ up_to_s: z7.number().int().min(1).max(MAX_DELAY_SECONDS), on_timeout: z7.enum(["yes", "no"]) }).strict().nullish()
+}).strict();
+var SplitBranchKey = z7.string().regex(/^[A-Za-z0-9_-]{1,32}$/, "letters, digits, underscore and hyphen, 1 to 32");
+var MIN_SPLIT_BRANCHES = 2;
+var MAX_SPLIT_BRANCHES = 4;
+var SplitStep = z7.object({
+  kind: z7.literal("split"),
+  ...label,
+  branches: z7.array(
+    z7.object({
+      key: SplitBranchKey,
+      /** A whole percentage. Zero is allowed: a branch kept in the flow but switched off. */
+      weight: z7.number().int().min(0).max(100),
+      next: StepId.nullable()
+    }).strict()
+  ).min(MIN_SPLIT_BRANCHES).max(MAX_SPLIT_BRANCHES).refine((bs) => new Set(bs.map((b) => b.key)).size === bs.length, "each branch needs its own key").refine((bs) => bs.reduce((sum, b) => sum + b.weight, 0) === 100, "the weights have to come to 100")
+}).strict();
+var GotoStep = z7.object({ kind: z7.literal("goto"), ...label, target: StepId.nullable() }).strict();
+var MAX_STEP_VISITS = 20;
+var WebhookStep = z7.object({ kind: z7.literal("webhook"), ...label, ...next, endpoint_id: Id.nullable(), payload: JsonValue.nullish() }).strict();
+var NotifyRecipients = z7.union([z7.literal("owner"), z7.literal("admins"), z7.object({ member_id: Id }).strict()]);
+var NotifyStep = z7.object({
+  kind: z7.literal("notify"),
+  ...label,
+  ...next,
+  to: NotifyRecipients,
+  /** Empty while the step is being written; `not_chosen` refuses to publish it. */
+  subject: z7.string().max(998),
+  body: z7.string().max(1e4)
+}).strict();
+var AutomationStep = z7.discriminatedUnion("kind", [
+  EmailStep,
+  DelayStep,
+  ConditionStep,
+  z7.object({ kind: z7.literal("add_tag"), ...label, ...next, tag: DraftSlug }).strict(),
+  z7.object({ kind: z7.literal("remove_tag"), ...label, ...next, tag: DraftSlug }).strict(),
+  /** `value` null clears the property, as a contact upsert does. */
+  z7.object({ kind: z7.literal("set_property"), ...label, ...next, key: DraftPropertyKey, value: JsonValue }).strict(),
+  /** Subscribing never lifts a suppression: the service checks that, not the flow. */
+  z7.object({ kind: z7.literal("subscribe_topic"), ...label, ...next, topic: DraftSlug }).strict(),
+  /** `topic` unsubscribes from the automation's own topic, `all` from every topic. */
+  z7.object({ kind: z7.literal("unsubscribe"), ...label, ...next, scope: z7.enum(["topic", "all"]) }).strict(),
+  z7.object({ kind: z7.literal("exit"), ...label }).strict(),
+  SplitStep,
+  GotoStep,
+  WebhookStep,
+  NotifyStep
+]);
+function stepTargets(step) {
+  switch (step.kind) {
+    case "exit":
+      return [];
+    case "condition":
+      return [
+        { to: step.yes, branch: "yes" },
+        { to: step.no, branch: "no" }
+      ];
+    case "split":
+      return step.branches.map((b) => ({ to: b.next, branch: b.key }));
+    case "goto":
+      return [{ to: step.target, jump: true }];
+    default:
+      return [{ to: step.next }];
+  }
+}
+var MAX_STEPS = 200;
+var AutomationFlow = z7.object({
+  triggers: z7.array(AutomationTrigger).max(MAX_TRIGGERS),
+  /** The first step. `null` is an empty flow. */
+  entry: StepId.nullable(),
+  steps: z7.record(StepId, AutomationStep)
+}).strict();
+var emptyFlow = () => ({ triggers: [], entry: null, steps: {} });
+var QuietHours = z7.object({
+  start: TimeOfDay,
+  end: TimeOfDay,
+  weekdays: z7.array(Weekday).min(1).max(7).nullish()
+}).strict();
+var RE_ENTRY_MODES = ["off", "after_exit"];
+var ReEntryMode = z7.enum(RE_ENTRY_MODES);
+var MAX_RE_ENTRY_COOLDOWN_SECONDS = 365 * 24 * 60 * 60;
+var AutomationSettings = z7.object({
+  re_entry: ReEntryMode,
+  /** Seconds a person must wait after leaving before entering again. Only with `after_exit`. */
+  re_entry_cooldown_s: z7.number().int().min(0).max(MAX_RE_ENTRY_COOLDOWN_SECONDS).nullish(),
+  quiet_hours: QuietHours.nullish(),
+  /** Checked before every step; when it matches, the run ends. */
+  exit_filter: BoundedAutomationFilter.nullish()
+}).strict();
+var defaultSettings = () => ({
+  re_entry: "off",
+  re_entry_cooldown_s: null,
+  quiet_hours: null,
+  exit_filter: null
+});
+var AUTOMATION_ISSUE_CODES = [
+  /** No trigger at all: nothing would ever enter. */
+  "missing_trigger",
+  /** Two triggers that would fire on exactly the same thing. */
+  "duplicate_trigger",
+  /** No entry step, or an entry step that is not in `steps`. */
+  "empty_flow",
+  /** A `next`, `yes` or `no` naming a step that does not exist. */
+  "dangling_next",
+  /** A step no run can reach from the entry. */
+  "unreachable_step",
+  /**
+   * A loop with nothing in it that waits. Loops themselves are legal once a
+   * flow has a `goto`; a loop that can go round without ever waiting is not,
+   * because it would spend a worker's whole tick budget on one person.
+   */
+  "tight_loop",
+  /** An email step with neither a template nor a document. */
+  "empty_email",
+  /**
+   * A step still missing something it needs before it can run: a subject, a
+   * tag, a topic, a property. A draft is allowed to hold one; publishing is not.
+   */
+  "not_chosen",
+  /** An engagement field while the workspace has tracking off. */
+  "tracking_disabled",
+  /** A template, tag, topic, segment, form or property the workspace does not have. */
+  "unknown_reference",
+  /** More steps than the plan or the flow allows. */
+  "too_many_steps",
+  /** A filter nested deeper than the service evaluates. */
+  "filter_too_deep",
+  /** A field that does not belong where it is used (`event:` outside a run, `segment` in an event filter). */
+  "unsupported_field",
+  /** An operator the field does not take. */
+  "unsupported_operator",
+  /** A value the field's type cannot hold: a tag compared to a number, a date that is not one. */
+  "invalid_value",
+  /** A cool-down with re-entry off, which would never apply. */
+  "cooldown_without_reentry",
+  /** A window that is always or never open. */
+  "invalid_quiet_hours",
+  /** A date trigger or a date delay reading a property that is not defined as a date. */
+  "not_a_date_property",
+  /** A one-off date that is already over everywhere on earth, so it would fire for nobody. */
+  "date_in_the_past"
+];
+var AutomationIssueCode = z7.enum(AUTOMATION_ISSUE_CODES);
+var AutomationIssue = z7.object({
+  code: AutomationIssueCode,
+  /** The step the issue is about, when it is about one. */
+  step_id: StepId.nullable(),
+  /** Where inside the document, for the canvas to point at a field. */
+  path: z7.array(z7.union([z7.string(), z7.number()])),
+  message: z7.string()
+});
+var AutomationValidation = z7.object({
+  ok: z7.boolean(),
+  issues: z7.array(AutomationIssue)
+});
+function validateAutomation(flow, settings, ctx) {
+  const issues = [];
+  const add = (i) => issues.push(i);
+  const known = ctx.known ?? {};
+  const emailSteps = new Set(
+    Object.entries(flow.steps).filter(([, step]) => step.kind === "email").map(([id]) => id)
+  );
+  if (settings.re_entry === "off" && settings.re_entry_cooldown_s != null && settings.re_entry_cooldown_s > 0) {
+    add({
+      code: "cooldown_without_reentry",
+      path: ["settings", "re_entry_cooldown_s"],
+      message: "A cool-down only applies when re-entry is on."
+    });
+  }
+  if (settings.quiet_hours && settings.quiet_hours.start === settings.quiet_hours.end) {
+    add({
+      code: "invalid_quiet_hours",
+      path: ["settings", "quiet_hours"],
+      message: "A window that starts and ends at the same time is either always or never open."
+    });
+  }
+  if (settings.exit_filter) checkFilter(settings.exit_filter, "contact", ["settings", "exit_filter"], null, ctx, known, emailSteps, add);
+  if (flow.triggers.length === 0) {
+    add({ code: "missing_trigger", path: ["triggers"], message: "An automation needs at least one trigger." });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  flow.triggers.forEach((trigger, i) => {
+    const key = triggerKey(trigger);
+    if (seen.has(key)) {
+      add({ code: "duplicate_trigger", path: ["triggers", i], message: "Another trigger already fires on exactly this." });
+    }
+    seen.add(key);
+    if (trigger.kind === "topic_subscribed") checkRef(known.topics, trigger.topic, "topic", ["triggers", i, "topic"], add);
+    if (trigger.kind === "tag_added") checkRef(known.tags, trigger.tag, "tag", ["triggers", i, "tag"], add);
+    if (trigger.kind === "form_confirmed") checkRef(known.forms, trigger.form_id, "signup form", ["triggers", i, "form_id"], add);
+    if (trigger.kind === "event" && trigger.where) {
+      checkFilter(trigger.where, "event", ["triggers", i, "where"], null, ctx, known, emailSteps, add);
+    }
+    if (trigger.kind === "date_anniversary") {
+      checkDateProperty(ctx, trigger.key, ["triggers", i, "key"], null, add);
+    }
+    if (trigger.kind === "exact_date") {
+      if (trigger.where) checkFilter(trigger.where, "scan", ["triggers", i, "where"], null, ctx, known, emailSteps, add);
+      if (ctx.now && isDayEntirelyPast(trigger.on, ctx.now)) {
+        add({
+          code: "date_in_the_past",
+          path: ["triggers", i, "on"],
+          message: `${trigger.on} is already over everywhere, so this trigger would never fire. Pick a day still to come.`
+        });
+      }
+    }
+    if (trigger.kind === "segment_entered") {
+      checkRef(known.segments, trigger.segment_id, "segment", ["triggers", i, "segment_id"], add);
+    }
+    if (trigger.kind === "link_clicked") {
+      checkRef(known.mailings, trigger.mailing_id, "sent mailing", ["triggers", i, "mailing_id"], add);
+      if (!ctx.tracking.clicks) {
+        add({
+          code: "tracking_disabled",
+          path: ["triggers", i],
+          message: "This workspace does not record clicks, so nothing would ever tell this automation somebody clicked."
+        });
+      }
+    }
+    if (trigger.exclude) checkFilter(trigger.exclude, "entry", ["triggers", i, "exclude"], null, ctx, known, emailSteps, add);
+  });
+  const ids = Object.keys(flow.steps);
+  const cap = ctx.max_steps == null ? MAX_STEPS : Math.min(ctx.max_steps, MAX_STEPS);
+  if (ids.length > cap) {
+    add({ code: "too_many_steps", path: ["steps"], message: `This automation may have at most ${cap} steps; it has ${ids.length}.` });
+  }
+  if (flow.entry === null) {
+    add({ code: "empty_flow", path: ["entry"], message: "An automation needs a first step." });
+  } else if (!flow.steps[flow.entry]) {
+    add({ code: "empty_flow", path: ["entry"], message: `The first step "${flow.entry}" is not in the flow.` });
+  }
+  const order = reachable(flow);
+  for (const id of ids) {
+    if (!order.includes(id)) {
+      add({ code: "unreachable_step", step_id: id, path: ["steps", id], message: "No run can reach this step." });
+    }
+  }
+  for (const id of tightLoops(flow)) {
+    add({
+      code: "tight_loop",
+      step_id: id,
+      path: ["steps", id],
+      message: "This step is in a loop that never waits, so a run would go round it without stopping. Put a wait in the loop."
+    });
+  }
+  for (const id of [...order, ...ids.filter((i) => !order.includes(i))]) {
+    const step = flow.steps[id];
+    if (!step) continue;
+    const path = ["steps", id];
+    for (const { to, branch, jump } of stepTargets(step)) {
+      if (to === null && jump) {
+        add({
+          code: "dangling_next",
+          step_id: id,
+          path: [...path, "target"],
+          message: "This step has nowhere to move the run to. Choose the step it should go to."
+        });
+        continue;
+      }
+      if (to !== null && !flow.steps[to]) {
+        add({
+          code: "dangling_next",
+          step_id: id,
+          path: [...path, jump ? "target" : branch ?? "next"],
+          message: `This step points at "${to}", which is not in the flow.`
+        });
+      }
+    }
+    switch (step.kind) {
+      case "email":
+        if (!step.template_id && !step.document) {
+          add({ code: "empty_email", step_id: id, path: [...path, "template_id"], message: "This email has neither a template nor content." });
+        }
+        if (step.subject.trim() === "") {
+          add({ code: "not_chosen", step_id: id, path: [...path, "subject"], message: "This email has no subject line." });
+        }
+        if (step.template_id) checkRef(known.templates, step.template_id, "template", [...path, "template_id"], add, id);
+        break;
+      case "delay":
+        if (step.wait.mode === "date_property") checkDateProperty(ctx, step.wait.key, [...path, "wait", "key"], id, add);
+        break;
+      case "condition":
+        checkFilter(step.filter, "contact", [...path, "filter"], id, ctx, known, emailSteps, add);
+        break;
+      case "add_tag":
+      case "remove_tag":
+        if (!chosen(step.tag, "tag", [...path, "tag"], id, add)) checkRef(known.tags, step.tag, "tag", [...path, "tag"], add, id);
+        break;
+      case "subscribe_topic":
+        if (!chosen(step.topic, "topic", [...path, "topic"], id, add)) checkRef(known.topics, step.topic, "topic", [...path, "topic"], add, id);
+        break;
+      case "set_property":
+        chosen(step.key, "property", [...path, "key"], id, add);
+        break;
+      case "webhook":
+        if (step.endpoint_id === null) {
+          add({ code: "not_chosen", step_id: id, path: [...path, "endpoint_id"], message: "This step needs a webhook endpoint. Choose one." });
+        } else {
+          checkRef(known.webhook_endpoints, step.endpoint_id, "webhook endpoint", [...path, "endpoint_id"], add, id);
+        }
+        break;
+      case "notify":
+        if (step.subject.trim() === "") {
+          add({ code: "not_chosen", step_id: id, path: [...path, "subject"], message: "This notification has no subject line." });
+        }
+        if (step.body.trim() === "") {
+          add({ code: "not_chosen", step_id: id, path: [...path, "body"], message: "This notification has nothing to say. Write the note." });
+        }
+        if (typeof step.to === "object") checkRef(known.members, step.to.member_id, "member", [...path, "to"], add, id);
+        break;
+      default:
+        break;
+    }
+  }
+  return issues.map((i) => ({ code: i.code, step_id: i.step_id ?? null, path: i.path, message: i.message }));
+}
+function isPublishable(flow, settings, ctx) {
+  return validateAutomation(flow, settings, ctx).length === 0;
+}
+function isDayEntirelyPast(day, now) {
+  const [y, m, d] = day.split("-").map(Number);
+  return now.getTime() > Date.UTC(y, m - 1, d) + 36 * 60 * 60 * 1e3;
+}
+function checkDateProperty(ctx, key, path, stepId, add) {
+  if (!ctx.property_types) return;
+  const type = ctx.property_types.get(key);
+  if (type === "date") return;
+  add({
+    code: "not_a_date_property",
+    step_id: stepId,
+    path,
+    message: type === void 0 ? `This workspace has no property "${key}". A date needs one defined as a date.` : `"${key}" is a ${type}, and a date is needed here. Change the property's type or pick another one.`
+  });
+}
+function triggerKey(trigger) {
+  switch (trigger.kind) {
+    case "topic_subscribed":
+      return `topic_subscribed:${trigger.topic}`;
+    case "form_confirmed":
+      return `form_confirmed:${trigger.form_id}`;
+    case "tag_added":
+      return `tag_added:${trigger.tag}`;
+    case "property_changed":
+      return `property_changed:${trigger.key}:${JSON.stringify(trigger.to ?? null)}`;
+    case "event":
+      return `event:${trigger.name}`;
+    case "manual":
+      return "manual";
+    case "date_anniversary":
+      return `date_anniversary:${trigger.key}:${trigger.offset_days}:${trigger.at}`;
+    case "exact_date":
+      return `exact_date:${trigger.on}:${trigger.at}:${JSON.stringify(trigger.where ?? null)}`;
+    case "segment_entered":
+      return `segment_entered:${trigger.segment_id}`;
+    // The url belongs in the identity. Two triggers on the same mailing and
+    // different links are two different things to wait for, and the click path
+    // finds them by mailing alone, so this is what tells them apart afterwards.
+    case "link_clicked":
+      return `link_clicked:${trigger.mailing_id}:${trigger.url ?? ""}`;
+  }
+}
+function chosen(value, what, path, stepId, add) {
+  if (value !== "") return false;
+  add({ code: "not_chosen", step_id: stepId, path, message: `This step needs a ${what}. Choose one.` });
+  return true;
+}
+function checkRef(known, value, what, path, add, stepId) {
+  if (!known || known.has(value)) return;
+  add({ code: "unknown_reference", step_id: stepId ?? null, path, message: `This workspace has no ${what} "${value}".` });
+}
+function checkFilter(filter, place, path, stepId, ctx, known, emailSteps, add) {
+  if (filterDepth(filter) > MAX_FILTER_DEPTH) {
+    add({ code: "filter_too_deep", step_id: stepId, path, message: `This filter is nested deeper than ${MAX_FILTER_DEPTH} levels.` });
+  }
+  for (const leaf of filterConditions(filter)) {
+    const family = automationFilterFamily(leaf.field);
+    if (place === "event" && family !== "event") {
+      add({ code: "unsupported_field", step_id: stepId, path, message: `An event filter compares the event's own data; "${leaf.field}" is not part of it.` });
+      continue;
+    }
+    if (place === "scan" && (family === "event" || family === "segment")) {
+      add({
+        code: "unsupported_field",
+        step_id: stepId,
+        path,
+        message: family === "event" ? `Nothing happened here to compare against, so "${leaf.field}" cannot be used. A date trigger fires from the calendar.` : "This is read as a sweep over your contacts, which cannot ask about a segment. Compare the properties, tags or topics the segment is built from instead."
+      });
+      continue;
+    }
+    if (family === "step" && place !== "contact") {
+      add({
+        code: "unsupported_field",
+        step_id: stepId,
+        path,
+        message: place === "entry" ? `"${leaf.field}" asks about a mail this automation sent, and nobody has been through it yet at this point. Ask it in a condition instead.` : `"${leaf.field}" asks about a mail this automation sent, which only exists inside a run.`
+      });
+      continue;
+    }
+    if (!AUTOMATION_FILTER_FIELD_OPERATORS[family]) {
+      add({ code: "unsupported_field", step_id: stepId, path, message: `Unknown field "${leaf.field}".` });
+      continue;
+    }
+    const problem = filterLeafProblem(leaf, ctx.property_types ?? /* @__PURE__ */ new Map(), AUTOMATION_FILTER_FIELD_OPERATORS);
+    if (problem) {
+      add({
+        code: problem.at === "op" ? "unsupported_operator" : "invalid_value",
+        step_id: stepId,
+        path,
+        message: `${problem.message}.`
+      });
+    }
+    if (family === "engagement" || family === "step") {
+      const asks = leaf.field.endsWith(":clicked") ? "clicks" : "opens";
+      if (!ctx.tracking[asks]) {
+        add({
+          code: "tracking_disabled",
+          step_id: stepId,
+          path,
+          message: `This workspace does not record ${asks}, so a filter cannot ask about them.`
+        });
+      }
+    }
+    if (family === "step" && typeof leaf.value === "string") {
+      if (leaf.value === stepId) {
+        add({ code: "invalid_value", step_id: stepId, path, message: "A step cannot ask whether its own mail was opened." });
+      } else if (!emailSteps.has(leaf.value)) {
+        add({
+          code: "unknown_reference",
+          step_id: stepId,
+          path,
+          message: "This names a step that is not an email in this automation."
+        });
+      }
+    }
+    if (family === "segment" && typeof leaf.value === "string") {
+      checkRef(known.segments, leaf.value, "segment", path, add, stepId ?? void 0);
+    }
+    if (family === "tag" && typeof leaf.value === "string") checkRef(known.tags, leaf.value, "tag", path, add, stepId ?? void 0);
+    if (family === "topic" && typeof leaf.value === "string") checkRef(known.topics, leaf.value, "topic", path, add, stepId ?? void 0);
+  }
+}
+function reachable(flow) {
+  const out = [];
+  if (flow.entry === null || !flow.steps[flow.entry]) return out;
+  const queue = [flow.entry];
+  const seen = new Set(queue);
+  while (queue.length > 0) {
+    const id = queue.shift();
+    out.push(id);
+    const step = flow.steps[id];
+    if (!step) continue;
+    for (const { to } of stepTargets(step)) {
+      if (to === null || seen.has(to) || !flow.steps[to]) continue;
+      seen.add(to);
+      queue.push(to);
+    }
+  }
+  return out;
+}
+function alwaysWaits(step) {
+  if (step.kind === "email") return true;
+  if (step.kind === "condition") return step.wait_for != null;
+  if (step.kind !== "delay") return false;
+  return step.wait.mode === "duration" || step.wait.mode === "time_of_day" || step.wait.mode === "weekday";
+}
+function tightLoops(flow) {
+  const out = [];
+  for (const component of stronglyConnected(flow)) {
+    const loops = component.length > 1 || stepTargets(flow.steps[component[0]]).some((t) => t.to === component[0]);
+    if (!loops) continue;
+    if (component.some((id) => alwaysWaits(flow.steps[id]))) continue;
+    out.push(...component);
+  }
+  return out.sort();
+}
+function stronglyConnected(flow) {
+  const index = /* @__PURE__ */ new Map();
+  const low = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const out = [];
+  let next2 = 0;
+  for (const root of Object.keys(flow.steps)) {
+    if (index.has(root)) continue;
+    const work = [{ id: root, edge: 0 }];
+    index.set(root, next2);
+    low.set(root, next2);
+    next2 += 1;
+    stack.push(root);
+    onStack.add(root);
+    while (work.length > 0) {
+      const frame = work[work.length - 1];
+      const targets = stepTargets(flow.steps[frame.id]).filter((t) => t.to !== null && flow.steps[t.to]);
+      if (frame.edge < targets.length) {
+        const to = targets[frame.edge].to;
+        frame.edge += 1;
+        if (!index.has(to)) {
+          index.set(to, next2);
+          low.set(to, next2);
+          next2 += 1;
+          stack.push(to);
+          onStack.add(to);
+          work.push({ id: to, edge: 0 });
+        } else if (onStack.has(to)) {
+          low.set(frame.id, Math.min(low.get(frame.id), index.get(to)));
+        }
+        continue;
+      }
+      work.pop();
+      const parent = work[work.length - 1];
+      if (parent) low.set(parent.id, Math.min(low.get(parent.id), low.get(frame.id)));
+      if (low.get(frame.id) === index.get(frame.id)) {
+        const component = [];
+        for (; ; ) {
+          const id = stack.pop();
+          onStack.delete(id);
+          component.push(id);
+          if (id === frame.id) break;
+        }
+        out.push(component);
+      }
+    }
+  }
+  return out;
+}
+function cycles(flow) {
+  const ids = Object.keys(flow.steps);
+  const out = [];
+  for (const id of ids) {
+    const seen = /* @__PURE__ */ new Set();
+    const queue = stepTargets(flow.steps[id]).map((t) => t.to);
+    while (queue.length > 0) {
+      const to = queue.shift();
+      if (to === null || seen.has(to)) continue;
+      seen.add(to);
+      const step = flow.steps[to];
+      if (!step) continue;
+      for (const t of stepTargets(step)) queue.push(t.to);
+    }
+    if (seen.has(id)) out.push(id);
+  }
+  return out.sort();
+}
+var AUTOMATION_STATUSES = ["draft", "active", "paused", "archived"];
+var AutomationStatus = z7.enum(AUTOMATION_STATUSES);
+var AUTOMATION_END_REASONS = [
+  "completed",
+  "exit_filter",
+  "exit_step",
+  "unsubscribed",
+  /** The send worker found the person not subscribed to the automation's topic. */
+  "not_subscribed",
+  "suppressed",
+  "erased",
+  "step_removed",
+  /** A date delay's date was already behind the run, and its answer was to stop. */
+  "date_passed",
+  /** The run reached one step more times than `MAX_STEP_VISITS` allows: a loop that never let go. */
+  "loop_guard",
+  "automation_archived",
+  "ended_by_hand",
+  "failed"
+];
+var AutomationEndReason = z7.enum(AUTOMATION_END_REASONS);
+var AUTOMATION_WAIT_REASONS = ["delay", "quiet_hours", "plan_limit", "sending", "condition"];
+var AutomationWaitReason = z7.enum(AUTOMATION_WAIT_REASONS);
+var AUTOMATION_ENTRY_REFUSALS = [
+  "already_inside",
+  "re_entry_off",
+  "in_cooldown",
+  "excluded",
+  "not_subscribed",
+  "suppressed",
+  "not_active",
+  "unknown_contact"
+];
+var AutomationEntryRefusal = z7.enum(AUTOMATION_ENTRY_REFUSALS);
+var AutomationCounts = z7.object({
+  started: z7.number().int().min(0),
+  in_progress: z7.number().int().min(0),
+  completed: z7.number().int().min(0),
+  exited: z7.number().int().min(0),
+  failed: z7.number().int().min(0)
+});
+var Automation = z7.object({
+  id: Id,
+  name: z7.string().min(1).max(200),
+  status: AutomationStatus,
+  /** Every automation sends under one topic; there are no transactional automations. */
+  topic: Slug,
+  provider_id: Id.nullable(),
+  settings: AutomationSettings,
+  /** The flow people are running through, null while the automation has never been published. */
+  published_version: z7.number().int().min(1).nullable(),
+  /** The flow being edited. Increments on every save, like a template's version. */
+  draft_version: z7.number().int().min(1),
+  counts: AutomationCounts,
+  created_at: Timestamp,
+  updated_at: Timestamp,
+  published_at: Timestamp.nullable()
+});
+var AutomationWithFlow = Automation.extend({
+  /** The draft, always present: a new automation starts with an empty one. */
+  flow: AutomationFlow,
+  /** The flow people are running through, null until the first publish. */
+  published_flow: AutomationFlow.nullable()
+});
+var AutomationSummary = Automation;
+var AutomationCreate = z7.object({
+  name: z7.string().min(1).max(200),
+  topic: Slug,
+  provider_id: Id.optional(),
+  flow: AutomationFlow.optional(),
+  settings: AutomationSettings.partial().optional()
+});
+var AutomationUpdate = z7.object({
+  base_version: z7.number().int().min(1),
+  name: z7.string().min(1).max(200).optional(),
+  topic: Slug.optional(),
+  provider_id: Id.optional(),
+  flow: AutomationFlow.optional(),
+  settings: AutomationSettings.partial().optional()
+}).refine(
+  (v) => v.name !== void 0 || v.topic !== void 0 || v.provider_id !== void 0 || v.flow !== void 0 || v.settings !== void 0,
+  "at least one field besides base_version"
+);
+var AutomationListQuery = PageQuery.extend({
+  status: AutomationStatus.optional(),
+  topic: Slug.optional()
+});
+var AutomationPublishRequest = z7.object({
+  /**
+   * Answer what this publish would do and change nothing, whatever the flow
+   * looks like. Without it a publish that has no issues and moves nobody
+   * simply goes ahead, which is right for an API caller and wrong for a
+   * dialog that is only showing somebody what they are about to do.
+   */
+  dry_run: z7.boolean().optional(),
+  confirm: z7.boolean().optional(),
+  /** Per removed step: the step its waiting runs move to, or null to end them. */
+  moves: z7.record(StepId, StepId.nullable()).optional(),
+  /** Also enter everyone who matches a trigger's condition right now. */
+  backfill: z7.boolean().optional()
+}).strict();
+var AutomationPublishMove = z7.object({
+  step_id: StepId,
+  /** Why the step's people have to move: it is gone, or its delay changed. */
+  change: z7.enum(["removed", "delay_changed", "kind_changed"]),
+  waiting: z7.number().int().min(0),
+  /** Where they go: a step id, or null to end their runs with `step_removed`. */
+  destination: StepId.nullable()
+});
+var AutomationPublishResult = z7.object({
+  published: z7.boolean(),
+  automation: Automation,
+  /** Empty when nothing has to move; non-empty and `published` false asks for a confirmation. */
+  moves: z7.array(AutomationPublishMove),
+  /** How many people the backfill entered, or would enter when it is not confirmed. */
+  backfill: z7.number().int().min(0),
+  issues: z7.array(AutomationIssue)
+});
+var AutomationDuplicateRequest = z7.object({ name: z7.string().min(1).max(200).optional() }).strict();
+var AutomationEnrollRequest = z7.object({
+  contact_ids: z7.array(Id).min(1).max(1e3).optional(),
+  external_ids: z7.array(z7.string().min(1).max(255)).min(1).max(1e3).optional(),
+  emails: z7.array(Email).min(1).max(1e3).optional(),
+  segment_id: Id.optional(),
+  /** Where to start them; the flow's entry step by default. */
+  step_id: StepId.optional()
+}).strict().refine(
+  (v) => [v.contact_ids, v.external_ids, v.emails, v.segment_id].filter((x) => x !== void 0).length === 1,
+  "name the people exactly one way: contact_ids, external_ids, emails or segment_id"
+);
+var AutomationEnrollment = z7.object({
+  contact_id: Id.nullable(),
+  email: Email.nullable(),
+  external_id: z7.string().nullable(),
+  entered: z7.boolean(),
+  run_id: Id.nullable(),
+  reason: AutomationEntryRefusal.nullable()
+});
+var AutomationEnrollResult = z7.object({
+  entered: z7.number().int().min(0),
+  refused: z7.number().int().min(0),
+  results: z7.array(AutomationEnrollment)
+});
+var AutomationRunStatus = z7.enum(["active", "waiting", "completed", "exited", "failed"]);
+var AutomationRun = z7.object({
+  id: Id,
+  automation_id: Id,
+  contact_id: Id,
+  email: Email,
+  external_id: z7.string().nullable(),
+  version: z7.number().int().min(1),
+  status: AutomationRunStatus,
+  current_step_id: StepId.nullable(),
+  next_action_at: Timestamp.nullable(),
+  wait_reason: AutomationWaitReason.nullable(),
+  end_reason: z7.string().nullable(),
+  /** What went wrong the last time this run tried to take its step, null otherwise. */
+  last_error: z7.string().nullable(),
+  entered_at: Timestamp,
+  ended_at: Timestamp.nullable()
+});
+var AutomationRunListQuery = PageQuery.extend({
+  status: AutomationRunStatus.optional(),
+  step_id: StepId.optional(),
+  contact_id: Id.optional()
+});
+var ContactAutomationRun = AutomationRun.extend({
+  automation: z7.object({ id: Id, name: z7.string(), status: AutomationStatus })
+});
+var ContactAutomationListQuery = PageQuery.extend({ status: AutomationRunStatus.optional() });
+var AutomationStepExecution = z7.object({
+  step_id: StepId,
+  step_kind: AutomationStepKind,
+  visit: z7.number().int().min(1),
+  started_at: Timestamp,
+  finished_at: Timestamp.nullable(),
+  /**
+   * What happened, by step kind: `branch` for a condition, `recipient_id`,
+   * `recipient_status` and `skip_reason` for an email, `reason` for a step that
+   * did nothing, and `skipped` for a wait that was not waited (`no_date` when
+   * the contact carries no date, `date_passed` when the date was already behind
+   * them). The journey renders each of these in words.
+   */
+  outcome: Properties
+});
+var AutomationJourney = z7.object({
+  run: AutomationRun,
+  steps: z7.array(AutomationStepExecution)
+});
+var AutomationStepReport = z7.object({
+  step_id: StepId,
+  step_kind: AutomationStepKind,
+  reached: z7.number().int().min(0),
+  waiting: z7.number().int().min(0),
+  passed: z7.number().int().min(0),
+  /** Per branch, for a condition: how many took `yes` and how many `no`. */
+  branches: z7.record(z7.number().int().min(0)),
+  /** The step mailing's id, for an email step of the published version. */
+  mailing_id: Id.nullable()
+});
+var AutomationReport = z7.object({
+  counts: AutomationCounts,
+  /** Why the people who left did: `AutomationEndReason` to a count. */
+  end_reasons: z7.record(z7.number().int().min(0)),
+  /**
+   * Why people a trigger named did not enter: `AutomationEntryRefusal` to a
+   * count. Without it a pause, an exclusion or a missing subscription would
+   * turn people away invisibly.
+   */
+  refusals: z7.record(z7.number().int().min(0)),
+  steps: z7.array(AutomationStepReport)
+});
+var AutomationExitRunRequest = z7.object({ reason: z7.string().max(200).optional() }).strict();
+var AutomationRunParams = z7.object({ id: Id, run_id: Id });
+var AutomationStepParams = z7.object({ id: Id, step_id: StepId });
+var AutomationTestEmailRequest = z7.object({ to: Email, merge: Properties.optional() }).strict();
+var AutomationValidateRequest = z7.object({ flow: AutomationFlow.optional(), settings: AutomationSettings.partial().optional() }).strict();
+var EventCreate = z7.object({
+  name: EventName,
+  contact: z7.object({ external_id: z7.string().min(1).max(255).optional(), email: Email.optional(), id: Id.optional() }).refine((c) => [c.external_id, c.email, c.id].filter((x) => x !== void 0).length === 1, "name the contact exactly one way"),
+  data: Properties.optional(),
+  occurred_at: Timestamp.optional(),
+  id: z7.string().min(1).max(128).optional()
+}).strict();
+var Event = z7.object({
+  id: Id,
+  client_event_id: z7.string().nullable(),
+  name: EventName,
+  contact_id: Id,
+  data: Properties,
+  occurred_at: Timestamp,
+  received_at: Timestamp,
+  /**
+   * How many automations were waiting for this event and took the person in
+   * hand. Each is then admitted or refused by the runtime on its own rules
+   * (consent, exclusions, re-entry), which `automations.report` counts.
+   */
+  entered: z7.number().int().min(0)
+});
+var EventListQuery = PageQuery.extend({
+  name: EventName.optional(),
+  contact_id: Id.optional()
+});
+
+// src/workspace.ts
+var CompanyId = z8.string().min(1).max(64);
+var ASSET_POLICIES = ["any", "service_only"];
+var AssetPolicy = z8.enum(ASSET_POLICIES);
+var WorkspaceSettings = z8.object({
+  /** Default language of the hosted unsubscribe page (BCP 47 tag, e.g. "de"). */
+  default_locale: z8.string().min(2).max(35),
+  /** Languages the hosted pages are offered in. Includes `default_locale`. */
+  locales: z8.array(z8.string().min(2).max(35)).min(1).max(20),
+  /** Open and click tracking. Off by default, opt-in per workspace. */
+  tracking_enabled: z8.boolean(),
+  /** Where images, stylesheets and fonts in a mail may load from. `any` by default. */
+  asset_policy: AssetPolicy,
+  /**
+   * The time zone an automation reads a wall clock in for a contact who has
+   * none of their own (A1). Null falls back to UTC.
+   */
+  default_timezone: TimezoneName.nullable()
+});
+var Workspace = z8.object({
+  id: Id,
+  slug: Slug,
+  name: z8.string().min(1).max(120),
+  settings: WorkspaceSettings,
+  /**
+   * The auth-brain company (tenant) the workspace was created for, or null for
+   * a workspace created without one. When auth-brain erases that company, every
+   * workspace carrying its id is erased with it.
+   */
+  company_id: CompanyId.nullable(),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var WorkspaceCreate = z8.object({
+  slug: Slug,
+  name: z8.string().min(1).max(120),
+  settings: WorkspaceSettings.partial().optional(),
+  owner: z8.object({
+    email: Email,
+    name: z8.string().max(200).nullable().optional()
+  }),
+  /**
+   * The signed-in person's active auth-brain company. The dashboard always
+   * sends it, which is what links the workspace to auth-brain's company
+   * erasure; omitted, the workspace belongs to no company and no company
+   * erasure reaches it.
+   */
+  company_id: CompanyId.optional()
+});
+var WorkspaceUpdate = z8.object({
+  name: z8.string().min(1).max(120),
+  settings: WorkspaceSettings.partial()
+}).partial().refine((v) => Object.keys(v).length > 0, "at least one field");
+var WorkspaceMove = z8.object({ company_id: CompanyId });
+var MEMBER_ROLES = ["owner", "admin", "editor", "viewer"];
+var MemberRole = z8.enum(MEMBER_ROLES);
+var WorkspaceMembership = Workspace.extend({ role: MemberRole });
+var Member = z8.object({
+  id: Id,
+  /** The person's auth-brain subject. */
+  subject: z8.string().min(1).max(255),
+  email: Email,
+  name: z8.string().max(200).nullable(),
+  role: MemberRole,
+  created_at: Timestamp
+});
+var MemberCreate = z8.object({
+  subject: z8.string().min(1).max(255),
+  email: Email,
+  name: z8.string().max(200).nullable().optional(),
+  role: MemberRole
+});
+var MemberUpdate = z8.object({ role: MemberRole });
+var API_KEY_SCOPES = ["full", "read", "send"];
+var ApiKeyScope = z8.enum(API_KEY_SCOPES);
+var ApiKey = z8.object({
+  id: Id,
+  name: z8.string().min(1).max(120),
+  /** The first characters of the key, for recognising it in a list. */
+  prefix: z8.string().min(4).max(32),
+  scope: ApiKeyScope,
+  last_used_at: Timestamp.nullable(),
+  revoked_at: Timestamp.nullable(),
+  created_at: Timestamp
+});
+var ApiKeyCreate = z8.object({
+  name: z8.string().min(1).max(120),
+  /** Omitted means `full`. */
+  scope: ApiKeyScope.optional()
+});
+var ApiKeyCreated = z8.object({
+  key: z8.string().min(20),
+  api_key: ApiKey
+});
+var AUDIT_ACTIONS = [
+  "workspace.created",
+  "workspace.updated",
+  "workspace.company_changed",
+  "member.added",
+  "member.role_changed",
+  "member.removed",
+  "member.invited",
+  "invite.revoked",
+  "api_key.created",
+  "api_key.revoked",
+  "provider.created",
+  "provider.updated",
+  "provider.deleted",
+  "provider.events_registered",
+  "provider.events_secret_set",
+  "provider.bounces_halted",
+  "provider.anomaly_cleared",
+  "topic.created",
+  "topic.updated",
+  "template.created",
+  "template.updated",
+  "template.deleted",
+  "saved_section.created",
+  "saved_section.updated",
+  "saved_section.deleted",
+  "asset.uploaded",
+  "asset.imported",
+  "contact.erased",
+  "suppression.created",
+  "suppression.deleted",
+  "mailing.created",
+  "mailing.sent",
+  "mailing.paused",
+  "mailing.resumed",
+  "mailing.cancelled",
+  "mailing.retried",
+  "webhook.created",
+  "webhook.updated",
+  "webhook.deleted",
+  "webhook.secret_rotated",
+  "webhook.redelivered",
+  "contact.unsubscribed",
+  // S4: the platform features
+  "tag.created",
+  "tag.deleted",
+  "tag.assigned",
+  "tag.unassigned",
+  "contact_property.created",
+  "contact_property.deleted",
+  "segment.created",
+  "segment.updated",
+  "segment.deleted",
+  "signup_form.created",
+  "signup_form.updated",
+  "signup_form.deleted",
+  "contact.subscribed",
+  "import.created",
+  "import.mapped",
+  "import.committed",
+  "import.cancelled",
+  "import.finished",
+  "mailing.scheduled",
+  "mailing.unscheduled",
+  "mailing.schedule_failed",
+  "mailing.ab_test_updated",
+  "mailing.ab_winner_selected",
+  "tracking.updated",
+  "billing.checkout_started",
+  "billing.subscription_changed",
+  "billing.exemption_changed",
+  // A1: automations
+  "automation.created",
+  "automation.updated",
+  "automation.published",
+  "automation.paused",
+  "automation.resumed",
+  "automation.archived",
+  "automation.deleted",
+  "automation.duplicated",
+  "automation.enrolled",
+  "automation.run_ended",
+  "event.recorded"
+];
+var AuditAction = z8.enum(AUDIT_ACTIONS);
+var AuditActor = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("member"), member_id: Id, subject: z8.string().min(1) }),
+  z8.object({ type: z8.literal("api_key"), api_key_id: Id }),
+  /** The service itself (the worker, a bounce, the hosted unsubscribe page). */
+  z8.object({ type: z8.literal("system"), reason: z8.string().min(1).max(200) })
+]);
+var AuditEntry = z8.object({
+  id: Id,
+  action: AuditAction,
+  actor: AuditActor,
+  target_type: z8.string().min(1).max(64),
+  target_id: Id.nullable(),
+  details: z8.record(z8.unknown()),
+  created_at: Timestamp
+});
+var AuditQuery = PageQuery.extend({
+  action: AuditAction.optional(),
+  target_id: Id.optional()
+});
+
+// src/invites.ts
+import { z as z9 } from "zod";
+var INVITE_STATUSES = ["pending", "accepted", "revoked", "expired"];
+var InviteStatus = z9.enum(INVITE_STATUSES);
+var DEFAULT_INVITE_TTL_DAYS = 7;
+var MAX_INVITE_TTL_DAYS = 30;
+var Invite = z9.object({
+  id: Id,
+  /** Stored lowercased; only a person signed in with this address can accept. */
+  email: Email,
+  role: MemberRole,
+  /** Derived from the timestamps below, never stored. */
+  status: InviteStatus,
+  /** The member who invited, while they are still one (null after they left). */
+  invited_by: z9.object({ member_id: Id.nullable(), email: Email.nullable() }),
+  expires_at: Timestamp,
+  accepted_at: Timestamp.nullable(),
+  revoked_at: Timestamp.nullable(),
+  created_at: Timestamp
+});
+var InviteCreate = z9.object({
+  email: Email,
+  role: MemberRole,
+  expires_in_days: z9.number().int().min(1).max(MAX_INVITE_TTL_DAYS).optional()
+});
+var InviteCreated = z9.object({
+  invite: Invite,
+  token: z9.string().min(32).max(128)
+});
+var InviteListQuery = PageQuery.extend({
+  status: InviteStatus.optional()
+});
+var InviteAccept = z9.object({
+  token: z9.string().min(32).max(128),
+  email: Email,
+  name: z9.string().max(200).nullable().optional()
+});
+var InviteAccepted = z9.object({
+  workspace: WorkspaceMembership,
+  already_member: z9.boolean()
+});
+var INVITE_REFUSAL_REASONS = ["email_mismatch", "inviter_lacks_role", "expired", "revoked", "accepted"];
+
+// src/providers.ts
+import { z as z10 } from "zod";
+var PROVIDER_KINDS = ["smtp", "resend"];
+var ProviderKind = z10.enum(PROVIDER_KINDS);
+var ProviderPolicy = z10.object({
+  daily_recipient_budget: z10.number().int().min(1).max(1e7),
+  min_interval_ms: z10.number().int().min(0).max(36e5),
+  max_recipients_per_message: z10.number().int().min(1).max(1e3)
+});
+var ICLOUD_SMTP_POLICY = {
+  daily_recipient_budget: 800,
+  min_interval_ms: 3e3,
+  max_recipients_per_message: 1
+};
+var SMTP_SECURITY = ["tls", "starttls"];
+var SmtpConfigBase = z10.object({
+  host: z10.string().min(1).max(255),
+  port: z10.number().int().min(1).max(65535),
+  /** `tls` connects encrypted (465), `starttls` upgrades (587). Never plaintext. */
+  security: z10.enum(SMTP_SECURITY),
+  username: z10.string().min(1).max(255)
+});
+var ResendConfigBase = z10.object({});
+var ProviderRejections = z10.object({
+  count: z10.number().int().min(0),
+  last_error: z10.string().nullable(),
+  last_at: Timestamp.nullable(),
+  /**
+   * The last time the bounce circuit breaker tripped on one of this provider's
+   * mailings: too many recipients of one run were refused as dead addresses
+   * (five in a row with the same reply, or more than 20 percent of the first
+   * 50), which points at the provider or the setup rather than the list. The
+   * run's bounce blocks were undone and the mailing paused. `sample` is the
+   * reply that tripped it.
+   */
+  anomaly: z10.object({
+    at: Timestamp,
+    /** `mailing`: one mailing was paused. `provider`: 5 refusals in a row with the same reply across the provider's sends (test sends and one-recipient mailings included) within 24 hours. */
+    scope: z10.enum(["mailing", "provider"]),
+    /**
+     * True while the provider-wide breaker is open: no bounce blocks through
+     * this provider, test sends refused and mailings not started or resumed
+     * (`provider_anomaly`), until an admin clears it (`providers.clearAnomaly`).
+     */
+    blocking: z10.boolean(),
+    mailing_id: Id.nullable(),
+    reason: z10.string(),
+    sample: z10.string()
+  }).nullable()
+});
+var ProviderEvents = z10.object({
+  status: z10.enum(["active", "needs_secret"]),
+  source: z10.enum(["automatic", "manual"]).nullable(),
+  url: z10.string().url(),
+  error: z10.string().nullable(),
+  /**
+   * Events that named an email this provider never sent through the service
+   * (another workspace or system sharing the Resend account): counted, never
+   * acted on.
+   */
+  unmatched: z10.number().int().min(0)
+});
+var RESEND_EVENT_TYPES = ["email.bounced", "email.complained", "email.delivery_delayed"];
+var ResendSigningSecret = z10.string().max(200).regex(/^whsec_[A-Za-z0-9+/]{16,}={0,2}$/, "must be the signing secret Resend shows, starting with whsec_");
+var ProviderEventsSecret = z10.object({ signing_secret: ResendSigningSecret });
+var ProviderFields = {
+  name: z10.string().min(1).max(120),
+  from_name: z10.string().min(1).max(120),
+  from_email: Email,
+  reply_to: Email.nullable(),
+  policy: ProviderPolicy
+};
+var Provider = z10.discriminatedUnion("kind", [
+  z10.object({
+    id: Id,
+    kind: z10.literal("smtp"),
+    config: SmtpConfigBase,
+    has_secret: z10.boolean(),
+    ...ProviderFields,
+    rejections: ProviderRejections,
+    created_at: Timestamp,
+    updated_at: Timestamp
+  }),
+  z10.object({
+    id: Id,
+    kind: z10.literal("resend"),
+    config: ResendConfigBase,
+    has_secret: z10.boolean(),
+    ...ProviderFields,
+    rejections: ProviderRejections,
+    events: ProviderEvents,
+    created_at: Timestamp,
+    updated_at: Timestamp
+  })
+]);
+var ProviderCreate = z10.discriminatedUnion("kind", [
+  z10.object({
+    kind: z10.literal("smtp"),
+    config: SmtpConfigBase.extend({ password: z10.string().min(1).max(1024) }),
+    ...ProviderFields
+  }),
+  z10.object({
+    kind: z10.literal("resend"),
+    config: ResendConfigBase.extend({ api_key: z10.string().min(1).max(1024) }),
+    ...ProviderFields
+  })
+]);
+var ProviderUpdate = z10.discriminatedUnion("kind", [
+  z10.object({
+    kind: z10.literal("smtp"),
+    config: SmtpConfigBase.extend({ password: z10.string().min(1).max(1024).optional() }).partial().optional(),
+    name: ProviderFields.name.optional(),
+    from_name: ProviderFields.from_name.optional(),
+    from_email: ProviderFields.from_email.optional(),
+    reply_to: ProviderFields.reply_to.optional(),
+    policy: ProviderPolicy.partial().optional()
+  }),
+  z10.object({
+    kind: z10.literal("resend"),
+    config: ResendConfigBase.extend({ api_key: z10.string().min(1).max(1024).optional() }).optional(),
+    name: ProviderFields.name.optional(),
+    from_name: ProviderFields.from_name.optional(),
+    from_email: ProviderFields.from_email.optional(),
+    reply_to: ProviderFields.reply_to.optional(),
+    policy: ProviderPolicy.partial().optional()
+  })
+]);
+var ProviderUsage = z10.object({
+  provider_id: Id,
+  recipients_last_24h: z10.number().int().min(0),
+  remaining_budget: z10.number().int().min(0),
+  /** When enough of the rolling window frees up to send again, if exhausted. */
+  next_capacity_at: Timestamp.nullable()
+});
+var ProviderVerifyResult = z10.object({
+  ok: z10.boolean(),
+  error: z10.string().nullable()
+});
+
+// src/contacts.ts
+import { z as z11 } from "zod";
+var Topic = z11.object({
+  id: Id,
+  slug: Slug,
+  name: z11.string().min(1).max(120),
+  /** Shown on the hosted preference page. */
+  description: z11.string().max(1e3).nullable(),
+  /** Translations of `name` and `description` per locale, for the hosted page. */
+  translations: z11.record(
+    z11.object({ name: z11.string().min(1).max(120), description: z11.string().max(1e3).nullable() })
+  ),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var TopicCreate = z11.object({
+  slug: Slug,
+  name: z11.string().min(1).max(120),
+  description: z11.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 = z11.object({
+  id: Id,
+  external_id: z11.string().min(1).max(255).nullable(),
+  /** Stored lowercased, unique per workspace. */
+  email: Email,
+  first_name: z11.string().max(200).nullable(),
+  last_name: z11.string().max(200).nullable(),
+  locale: z11.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
+   * workspace's `settings.default_timezone` and then to UTC.
+   */
+  timezone: TimezoneName.nullable(),
+  properties: Properties,
+  topics: z11.array(Slug),
+  /** The slugs of the contact's tags (S4). */
+  tags: z11.array(Slug),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var ContactUpsert = z11.object({
+  external_id: z11.string().min(1).max(255).optional(),
+  email: Email.optional(),
+  first_name: z11.string().max(200).nullable().optional(),
+  last_name: z11.string().max(200).nullable().optional(),
+  locale: z11.string().min(2).max(35).nullable().optional(),
+  timezone: TimezoneName.nullable().optional(),
+  properties: Properties.optional(),
+  topics: z11.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 = z11.object({
+  contact: Contact,
+  created: z11.boolean()
+});
+var ContactListQuery = PageQuery.extend({
+  email: z11.string().min(1).max(254).optional(),
+  external_id: z11.string().min(1).max(255).optional(),
+  topic: Slug.optional()
+});
+var ContactErased = z11.object({
+  ok: z11.literal(true),
+  erased_messages: z11.number().int().min(0),
+  erased_recipients: z11.number().int().min(0),
+  suppressions_kept: z11.number().int().min(0)
+});
+var SUPPRESSION_REASONS = ["unsubscribed", "bounced", "complained", "manual"];
+var SuppressionReason = z11.enum(SUPPRESSION_REASONS);
+var Suppression = z11.object({
+  id: Id,
+  email: Email,
+  reason: SuppressionReason,
+  topic: Slug.nullable(),
+  source_message_id: Id.nullable(),
+  note: z11.string().max(1e3).nullable(),
+  created_at: Timestamp
+});
+var SuppressionCreate = z11.object({
+  email: Email,
+  reason: z11.enum(["manual", "unsubscribed"]),
+  topic: Slug.nullable().optional(),
+  note: z11.string().max(1e3).optional()
+});
+var SuppressionListQuery = PageQuery.extend({
+  email: z11.string().min(1).max(254).optional(),
+  reason: SuppressionReason.optional(),
+  topic: Slug.optional()
+});
+
+// src/webhooks.ts
+import { z as z12 } from "zod";
+var WEBHOOK_EVENT_TYPES = [
+  "message.sent",
+  "message.failed",
+  "contact.unsubscribed",
+  "contact.resubscribed",
+  "contact.bounced",
+  "mailing.finished",
+  // S4: the platform features
+  "contact.subscribed",
+  "import.finished",
+  "mailing.scheduled",
+  "mailing.started",
+  "mailing.schedule_failed",
+  "mailing.ab_winner_selected",
+  // A1: automations. The first two are what the `tag_added` and
+  // `property_changed` triggers hang on, so a client sees the same change the
+  // automations do.
+  "contact.tagged",
+  "contact.updated",
+  "automation.run_started",
+  "automation.run_completed",
+  "automation.run_exited",
+  "automation.run_failed",
+  /**
+   * A3 S3: a flow's webhook step fired.
+   *
+   * Never fanned out. Every other type here goes to every enabled endpoint that
+   * subscribes to it; this one goes only to the endpoint the step names, because
+   * the step means that endpoint and no other. It is in this list because
+   * `webhook_events.type` is checked against it, not because an endpoint can ask
+   * to receive everybody's.
+   */
+  "automation.webhook"
+];
+var WebhookEventType = z12.enum(WEBHOOK_EVENT_TYPES);
+var MessageEventBase = z12.object({
+  message_id: Id,
+  mailing_id: Id.nullable(),
+  mailing_metadata: MailingMetadata.nullable(),
+  recipient_id: Id.nullable(),
+  contact_id: Id.nullable(),
+  external_id: z12.string().nullable(),
+  email: Email,
+  subject: z12.string(),
+  topic: Slug.nullable(),
+  provider_message_id: z12.string().nullable(),
+  is_test: z12.boolean()
+});
+var MessageSentData = MessageEventBase.extend({
+  /** The final HTML as sent, so the client can archive it beside its own records. */
+  html: z12.string(),
+  sent_at: Timestamp
+});
+var MessageFailedData = MessageEventBase.extend({
+  error: z12.string(),
+  /** False when the provider rejected permanently; the recipient will not be retried. */
+  retryable: z12.boolean(),
+  failed_at: Timestamp
+});
+var UNSUBSCRIBE_SOURCES = ["hosted_page", "one_click", "api", "dashboard", "signup_form"];
+var ContactUnsubscribedData = z12.object({
+  contact_id: Id.nullable(),
+  external_id: z12.string().nullable(),
+  email: Email,
+  /** The topic unsubscribed from; null means every topic. */
+  topic: Slug.nullable(),
+  mailing_id: Id.nullable(),
+  source: z12.enum(UNSUBSCRIBE_SOURCES),
+  unsubscribed_at: Timestamp
+});
+var ContactResubscribedData = ContactUnsubscribedData.omit({ unsubscribed_at: true }).extend({
+  /**
+   * As on `contact.unsubscribed`, plus `bounce_reverted`: the bounce circuit
+   * breaker undid a `bounced` block it judged false (a `contact.bounced` for the
+   * same address and mailing went out before); `topic` is null.
+   */
+  source: z12.enum([...UNSUBSCRIBE_SOURCES, "bounce_reverted"]),
+  resubscribed_at: Timestamp
+});
+var ContactBouncedData = z12.object({
+  contact_id: Id.nullable(),
+  external_id: z12.string().nullable(),
+  email: Email,
+  /** `bounced` for a hard bounce, `complained` for a spam complaint. */
+  reason: z12.enum(["bounced", "complained"]),
+  message_id: Id.nullable(),
+  diagnostic: z12.string().nullable(),
+  bounced_at: Timestamp
+});
+var MailingFinishedData = z12.object({
+  mailing_id: Id,
+  mailing_metadata: MailingMetadata,
+  status: z12.enum(["sent", "partially_failed", "cancelled"]),
+  counts: MailingCounts,
+  finished_at: Timestamp
+});
+var ContactSubscribedData = z12.object({
+  contact_id: Id,
+  external_id: z12.string().nullable(),
+  email: Email,
+  topics: z12.array(Slug),
+  source: z12.enum(["signup_form", "api", "dashboard", "automation"]),
+  signup_form_id: Id.nullable(),
+  signup_form_version: z12.number().int().min(1).nullable(),
+  subscribed_at: Timestamp
+});
+var ImportFinishedData = z12.object({
+  import_id: Id,
+  status: z12.enum(["completed", "cancelled", "failed"]),
+  result: ImportReport.nullable(),
+  error: z12.string().nullable(),
+  finished_at: Timestamp
+});
+var MailingScheduledData = z12.object({
+  mailing_id: Id,
+  mailing_metadata: MailingMetadata,
+  scheduled_at: Timestamp.nullable()
+});
+var MailingStartedData = z12.object({
+  mailing_id: Id,
+  mailing_metadata: MailingMetadata,
+  trigger: z12.enum(["send", "schedule"]),
+  recipients: z12.number().int().min(0),
+  started_at: Timestamp
+});
+var MailingScheduleFailedData = z12.object({
+  mailing_id: Id,
+  mailing_metadata: MailingMetadata,
+  code: z12.string(),
+  message: z12.string(),
+  failed_at: Timestamp
+});
+var MailingAbWinnerSelectedData = z12.object({
+  mailing_id: Id,
+  mailing_metadata: MailingMetadata,
+  winner: z12.string(),
+  decided_by: z12.enum(["metric", "manual"]),
+  variants: z12.array(VariantAnalytics),
+  decided_at: Timestamp
+});
+var ContactTaggedData = z12.object({
+  contact_id: Id,
+  external_id: z12.string().nullable(),
+  email: Email,
+  /** Only the tags the contact did not already have. */
+  tags: z12.array(Slug).min(1),
+  source: z12.enum(["api", "dashboard", "signup_form", "import", "automation"]),
+  tagged_at: Timestamp
+});
+var ContactUpdatedData = z12.object({
+  contact_id: Id,
+  external_id: z12.string().nullable(),
+  email: Email,
+  changed: z12.array(z12.string()).min(1),
+  properties: Properties,
+  source: z12.enum(["api", "dashboard", "signup_form", "import", "automation"]),
+  updated_at: Timestamp
+});
+var AutomationRunEventBase = z12.object({
+  automation_id: Id,
+  automation_name: z12.string(),
+  run_id: Id,
+  version: z12.number().int().min(1),
+  contact_id: Id,
+  external_id: z12.string().nullable(),
+  email: Email
+});
+var AutomationRunStartedData = AutomationRunEventBase.extend({
+  /** What let them in: a trigger kind, or `manual` for an explicit enrolment. */
+  trigger_kind: z12.string(),
+  entered_at: Timestamp
+});
+var AutomationRunCompletedData = AutomationRunEventBase.extend({
+  last_step_id: z12.string().nullable(),
+  completed_at: Timestamp
+});
+var AutomationRunExitedData = AutomationRunEventBase.extend({
+  reason: AutomationEndReason,
+  step_id: z12.string().nullable(),
+  exited_at: Timestamp
+});
+var AutomationRunFailedData = AutomationRunEventBase.extend({
+  reason: z12.string(),
+  step_id: z12.string().nullable(),
+  failed_at: Timestamp
+});
+var AutomationWebhookData = AutomationRunEventBase.extend({
+  step_id: z12.string(),
+  /** The step's own label, when it was given one, so a receiver can branch on a name. */
+  step_label: z12.string().nullable(),
+  /** Whatever the step carries, verbatim. Null when it carries nothing. */
+  payload: JsonValue.nullable(),
+  fired_at: Timestamp
+});
+var envelope = (type, data) => z12.object({
+  /** Unique per event: a receiver deduplicates on it (deliveries may repeat). */
+  id: Id,
+  type: z12.literal(type),
+  created_at: Timestamp,
+  workspace_id: Id,
+  data
+});
+var WebhookEvent = z12.discriminatedUnion("type", [
+  envelope("message.sent", MessageSentData),
+  envelope("message.failed", MessageFailedData),
+  envelope("contact.unsubscribed", ContactUnsubscribedData),
+  envelope("contact.resubscribed", ContactResubscribedData),
+  envelope("contact.bounced", ContactBouncedData),
+  envelope("mailing.finished", MailingFinishedData),
+  envelope("contact.subscribed", ContactSubscribedData),
+  envelope("import.finished", ImportFinishedData),
+  envelope("mailing.scheduled", MailingScheduledData),
+  envelope("mailing.started", MailingStartedData),
+  envelope("mailing.schedule_failed", MailingScheduleFailedData),
+  envelope("mailing.ab_winner_selected", MailingAbWinnerSelectedData),
+  envelope("contact.tagged", ContactTaggedData),
+  envelope("contact.updated", ContactUpdatedData),
+  envelope("automation.run_started", AutomationRunStartedData),
+  envelope("automation.run_completed", AutomationRunCompletedData),
+  envelope("automation.run_exited", AutomationRunExitedData),
+  envelope("automation.run_failed", AutomationRunFailedData),
+  envelope("automation.webhook", AutomationWebhookData)
+]);
+var WebhookEndpoint = z12.object({
+  id: Id,
+  url: z12.string().url(),
+  description: z12.string().max(500).nullable(),
+  events: z12.array(WebhookEventType).min(1),
+  enabled: z12.boolean(),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var WebhookUrl = z12.string().url().refine((u) => {
+  try {
+    const url = new URL(u);
+    if (url.protocol === "https:") return true;
+    return url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1");
+  } catch {
+    return false;
+  }
+}, "must be https (http only for localhost)");
+var WebhookEndpointCreate = z12.object({
+  url: WebhookUrl,
+  description: z12.string().max(500).optional(),
+  events: z12.array(WebhookEventType).min(1),
+  enabled: z12.boolean().optional()
+});
+var WebhookEndpointUpdate = z12.object({
+  url: WebhookUrl,
+  description: z12.string().max(500).nullable(),
+  events: z12.array(WebhookEventType).min(1),
+  enabled: z12.boolean()
+}).partial().refine((v) => Object.keys(v).length > 0, "at least one field");
+var WebhookEndpointWithSecret = z12.object({
+  endpoint: WebhookEndpoint,
+  secret: z12.string().min(32)
+});
+var WEBHOOK_DELIVERY_STATUSES = ["pending", "succeeded", "failed"];
+var WebhookDeliveryStatus = z12.enum(WEBHOOK_DELIVERY_STATUSES);
+var WEBHOOK_MAX_ATTEMPTS = 8;
+var WEBHOOK_RETRY_DELAYS_SECONDS = [30, 120, 600, 1800, 3600, 7200, 21600];
+var WebhookDelivery = z12.object({
+  id: Id,
+  endpoint_id: Id,
+  event_id: Id,
+  event_type: WebhookEventType,
+  status: WebhookDeliveryStatus,
+  attempts: z12.number().int().min(0),
+  last_status_code: z12.number().int().min(100).max(599).nullable(),
+  last_error: z12.string().nullable(),
+  next_attempt_at: Timestamp.nullable(),
+  delivered_at: Timestamp.nullable(),
+  created_at: Timestamp
+});
+var WebhookDeliveryListQuery = PageQuery.extend({
+  status: WebhookDeliveryStatus.optional(),
+  event_type: WebhookEventType.optional()
+});
+var WebhookDeliveryParams = z12.object({ id: Id, delivery_id: Id });
+
+// src/webhook-signing.ts
+var WEBHOOK_SIGNATURE_HEADER = "x-mail-signature";
+var WEBHOOK_TIMESTAMP_HEADER = "x-mail-timestamp";
+var WEBHOOK_EVENT_ID_HEADER = "x-mail-event-id";
+var WEBHOOK_SIGNATURE_VERSION = "v1";
+var WEBHOOK_TOLERANCE_SECONDS = 300;
+var WEBHOOK_SECRET_PREFIX = "whsec_";
+var encoder = new TextEncoder();
+function subtle() {
+  const c = globalThis.crypto;
+  if (!c?.subtle) {
+    throw new Error("Web Crypto (globalThis.crypto.subtle) is not available in this runtime");
+  }
+  return c.subtle;
+}
+function toHex(buffer) {
+  return Array.from(new Uint8Array(buffer), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function hmacHex(secret, message) {
+  if (secret.length === 0) throw new Error("webhook secret must not be empty");
+  const key = await subtle().importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, [
+    "sign"
+  ]);
+  return toHex(await subtle().sign("HMAC", key, encoder.encode(message)));
+}
+function timingSafeEqualString(a, b) {
+  const ab = encoder.encode(a);
+  const bb = encoder.encode(b);
+  let diff = ab.length ^ bb.length;
+  const n = Math.max(ab.length, bb.length);
+  for (let i = 0; i < n; i++) diff |= (ab[i] ?? 0) ^ (bb[i] ?? 0);
+  return diff === 0;
+}
+function nowSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+async function signWebhook(secret, rawBody, timestamp = nowSeconds()) {
+  if (!Number.isSafeInteger(timestamp) || timestamp < 0) throw new Error("timestamp must be a non-negative integer");
+  const hex = await hmacHex(secret, `${timestamp}.${rawBody}`);
+  return { signature: `${WEBHOOK_SIGNATURE_VERSION}=${hex}`, timestamp: String(timestamp) };
+}
+async function verifyWebhook(input) {
+  const { rawBody, signatureHeader, timestampHeader } = input;
+  if (!signatureHeader) return { ok: false, reason: "missing_signature" };
+  if (!timestampHeader) return { ok: false, reason: "missing_timestamp" };
+  if (!/^\d{1,12}$/.test(timestampHeader)) return { ok: false, reason: "invalid_timestamp" };
+  const timestamp = Number(timestampHeader);
+  const now = input.now ?? nowSeconds();
+  const tolerance = input.toleranceSeconds ?? WEBHOOK_TOLERANCE_SECONDS;
+  if (Math.abs(now - timestamp) > tolerance) return { ok: false, reason: "timestamp_out_of_tolerance" };
+  const candidates = signatureHeader.split(",").map((part) => part.trim()).filter((part) => part.startsWith(`${WEBHOOK_SIGNATURE_VERSION}=`)).map((part) => part.slice(WEBHOOK_SIGNATURE_VERSION.length + 1));
+  if (candidates.length === 0) return { ok: false, reason: "missing_signature" };
+  const secrets = typeof input.secret === "string" ? [input.secret] : input.secret;
+  let matched = false;
+  for (const secret of secrets) {
+    if (secret.length === 0) continue;
+    const expected = await hmacHex(secret, `${timestampHeader}.${rawBody}`);
+    for (const candidate of candidates) {
+      if (timingSafeEqualString(expected, candidate)) matched = true;
+    }
+  }
+  return matched ? { ok: true, timestamp } : { ok: false, reason: "signature_mismatch" };
+}
+
+// src/unsubscribe.ts
+var UNSUBSCRIBE_PATH_PREFIX = "/u/";
+var LIST_UNSUBSCRIBE_POST_VALUE = "List-Unsubscribe=One-Click";
+var RESERVED_MERGE_FIELDS = {
+  /** From the recipient's merge values, else the contact. Supports a fallback. */
+  first_name: { source: "contact", fallback: true, required_for_broadcast: false },
+  last_name: { source: "contact", fallback: true, required_for_broadcast: false },
+  email: { source: "contact", fallback: false, required_for_broadcast: false },
+  /** The hosted unsubscribe page for this recipient. A broadcast without it is refused. */
+  unsubscribe_url: { source: "service", fallback: false, required_for_broadcast: true }
+};
+var MERGE_FIELD_PATTERN = /\{\{\s*([a-z][a-z0-9_]*)\s*(?:\|([^}]*))?\}\}/g;
+function findMergeFields(html) {
+  const uses = [];
+  for (const match of html.matchAll(MERGE_FIELD_PATTERN)) {
+    uses.push({ name: match[1], fallback: match[2] === void 0 ? null : match[2].trim() });
+  }
+  return uses;
+}
+function missingRequiredMergeFields(html) {
+  const used = new Set(findMergeFields(html).map((u) => u.name));
+  return Object.keys(RESERVED_MERGE_FIELDS).filter(
+    (name) => RESERVED_MERGE_FIELDS[name].required_for_broadcast && !used.has(name)
+  );
+}
+
+// src/billing.ts
+import { z as z13 } from "zod";
+var PLAN_IDS = ["free", "starter", "growth", "design_partner"];
+var PlanId = z13.enum(PLAN_IDS);
+var PlanLimits = z13.object({
+  monthly_messages: z13.number().int().min(0).nullable(),
+  contacts: z13.number().int().min(0).nullable(),
+  members: z13.number().int().min(1).nullable(),
+  providers: z13.number().int().min(1).nullable(),
+  webhook_endpoints: z13.number().int().min(0).nullable(),
+  /** Automations that may be live (active or paused) at once (A1). */
+  active_automations: z13.number().int().min(0).nullable(),
+  /** Steps one automation may hold. Null is the flow's own cap, not unlimited. */
+  automation_steps: z13.number().int().min(1).nullable()
+});
+var PlanFeatures = z13.object({
+  /** A/B tests of subject and content on a mailing (S4). */
+  ab_testing: z13.boolean(),
+  /** Open and click tracking, still off until a workspace turns it on (`settings.tracking_enabled`). */
+  tracking: z13.boolean(),
+  /** Sending and hosting pages on the workspace's own domain (a later phase). */
+  custom_domains: z13.boolean(),
+  /** Automations: flows a person walks through step by step (A1). */
+  automations: z13.boolean()
+});
+var PLAN_FEATURES = ["ab_testing", "tracking", "custom_domains", "automations"];
+var Plan = z13.object({
+  id: PlanId,
+  name: z13.string().min(1),
+  /** Price in the smallest currency unit per month; null for plans not sold. */
+  monthly_price_cents: z13.number().int().min(0).nullable(),
+  currency: z13.string().length(3),
+  limits: PlanLimits,
+  features: PlanFeatures
+});
+var CatalogPlan = Plan.extend({ sellable: z13.boolean() });
+var Subscription = z13.object({
+  workspace_id: Id,
+  plan: PlanId,
+  status: z13.enum(["active", "trialing", "past_due", "cancelled"]),
+  current_period_start: Timestamp,
+  current_period_end: Timestamp,
+  cancel_at_period_end: z13.boolean(),
+  /**
+   * A design partner outside billing (plan `design_partner`, no limits, no
+   * checkout). Set only by an operator, never through the API.
+   */
+  billing_exempt: z13.boolean()
+});
+var USAGE_METRICS = ["messages", "contacts", "members", "providers", "webhook_endpoints", "active_automations"];
+var UsageMetric = z13.enum(USAGE_METRICS);
+var USAGE_WARNING_RATIO = 0.8;
+var UsageWarning = z13.object({
+  metric: UsageMetric,
+  used: z13.number().int().min(0),
+  limit: z13.number().int().min(0),
+  /** `approaching`: at or above USAGE_WARNING_RATIO of the limit; `reached`: at or above the limit. */
+  level: z13.enum(["approaching", "reached"])
+});
+var Usage = z13.object({
+  plan: PlanId,
+  period_start: Timestamp,
+  period_end: Timestamp,
+  metrics: z13.record(UsageMetric, z13.object({ used: z13.number().int().min(0), limit: z13.number().int().min(0).nullable() })),
+  warnings: z13.array(UsageWarning)
+});
+var CheckoutRequest = z13.object({
+  plan: z13.enum(["starter", "growth"]),
+  success_url: z13.string().url(),
+  cancel_url: z13.string().url()
+});
+var CheckoutSession = z13.object({ url: z13.string().url() });
+var PortalRequest = z13.object({ return_url: z13.string().url() });
+var PortalSession = z13.object({ url: z13.string().url() });
+var USAGE_WARNING_HEADER = "x-mail-usage-warning";
+function formatUsageWarningHeader(warnings) {
+  if (warnings.length === 0) return null;
+  return warnings.map((w) => `${w.metric}=${w.used}/${w.limit}`).join(",");
+}
+function parseUsageWarningHeader(value) {
+  if (!value) return [];
+  const out = [];
+  for (const part of value.split(",")) {
+    const match = /^\s*([a-z_]+)=(\d+)\/(\d+)\s*$/.exec(part);
+    if (!match) continue;
+    const metric = UsageMetric.safeParse(match[1]);
+    if (!metric.success) continue;
+    out.push({ metric: metric.data, used: Number(match[2]), limit: Number(match[3]) });
+  }
+  return out;
+}
+
+// src/routes.ts
+import { z as z14 } from "zod";
+var list = (item) => page(item);
+var foundationRoutes = {
+  "workspaces.create": {
+    method: "POST",
+    path: "/v1/workspaces",
+    body: WorkspaceCreate,
+    response: Workspace,
+    status: 201,
+    access: "dashboard",
+    phase: "S0"
+  },
+  "workspaces.list": {
+    method: "GET",
+    path: "/v1/workspaces",
+    query: PageQuery,
+    response: list(WorkspaceMembership),
+    status: 200,
+    access: "dashboard",
+    phase: "S0"
+  },
+  "workspace.get": { method: "GET", path: "/v1/workspace", response: Workspace, status: 200, access: "read", phase: "S0" },
+  "workspace.update": {
+    method: "PATCH",
+    path: "/v1/workspace",
+    body: WorkspaceUpdate,
+    response: Workspace,
+    status: 200,
+    access: "admin",
+    phase: "S0"
+  },
+  /**
+   * Hands the workspace to another auth-brain company. Its own route rather
+   * than a field on `workspace.update`, because that one is `admin` and this is
+   * not an ordinary setting: it decides whose erasure removes the workspace.
+   */
+  "workspace.move": {
+    method: "POST",
+    path: "/v1/workspace/company",
+    body: WorkspaceMove,
+    response: Workspace,
+    status: 200,
+    access: "owner",
+    phase: "S0"
+  },
+  "members.list": {
+    method: "GET",
+    path: "/v1/members",
+    query: PageQuery,
+    response: list(Member),
+    status: 200,
+    access: "read",
+    phase: "S0"
+  },
+  "members.add": {
+    method: "POST",
+    path: "/v1/members",
+    body: MemberCreate,
+    response: Member,
+    status: 201,
+    access: "admin",
+    phase: "S0"
+  },
+  "members.update": {
+    method: "PATCH",
+    path: "/v1/members/:id",
+    params: IdParams,
+    body: MemberUpdate,
+    response: Member,
+    status: 200,
+    access: "admin",
+    phase: "S0"
+  },
+  "members.remove": {
+    method: "DELETE",
+    path: "/v1/members/:id",
+    params: IdParams,
+    response: Ok,
+    status: 200,
+    access: "admin",
+    phase: "S0"
+  },
+  "apiKeys.list": {
+    method: "GET",
+    path: "/v1/api-keys",
+    query: PageQuery,
+    response: list(ApiKey),
+    status: 200,
+    access: "admin",
+    phase: "S0"
+  },
+  "apiKeys.create": {
+    method: "POST",
+    path: "/v1/api-keys",
+    body: ApiKeyCreate,
+    response: ApiKeyCreated,
+    status: 201,
+    access: "admin",
+    phase: "S0"
+  },
+  "apiKeys.revoke": {
+    method: "DELETE",
+    path: "/v1/api-keys/:id",
+    params: IdParams,
+    response: ApiKey,
+    status: 200,
+    access: "admin",
+    phase: "S0"
+  },
+  "audit.list": {
+    method: "GET",
+    path: "/v1/audit-log",
+    query: AuditQuery,
+    response: list(AuditEntry),
+    status: 200,
+    access: "admin",
+    phase: "S0"
+  }
+};
+var templateRoutes = {
+  "templates.list": {
+    method: "GET",
+    path: "/v1/templates",
+    query: TemplateListQuery,
+    response: list(TemplateSummary),
+    status: 200,
+    access: "read",
+    phase: "S1"
+  },
+  "templates.create": {
+    method: "POST",
+    path: "/v1/templates",
+    body: TemplateCreate,
+    response: Template,
+    status: 201,
+    access: "write",
+    phase: "S1"
+  },
+  "templates.get": {
+    method: "GET",
+    path: "/v1/templates/:id",
+    params: IdParams,
+    response: Template,
+    status: 200,
+    access: "read",
+    phase: "S1"
+  },
+  "templates.update": {
+    method: "PUT",
+    path: "/v1/templates/:id",
+    params: IdParams,
+    body: TemplateUpdate,
+    response: Template,
+    status: 200,
+    access: "write",
+    phase: "S1"
+  },
+  "templates.delete": {
+    method: "DELETE",
+    path: "/v1/templates/:id",
+    params: IdParams,
+    response: Ok,
+    status: 200,
+    access: "write",
+    phase: "S1"
+  },
+  "templates.versions": {
+    method: "GET",
+    path: "/v1/templates/:id/versions",
+    params: IdParams,
+    query: PageQuery,
+    response: list(TemplateVersion),
+    status: 200,
+    access: "read",
+    phase: "S1"
+  },
+  "templates.version": {
+    method: "GET",
+    path: "/v1/templates/:id/versions/:version",
+    params: TemplateVersionParams,
+    response: TemplateVersion,
+    status: 200,
+    access: "read",
+    phase: "S1"
+  },
+  "templates.import": {
+    method: "POST",
+    path: "/v1/templates/import",
+    body: TemplateImport,
+    response: TemplateImportResult,
+    status: 201,
+    access: "write",
+    phase: "S1"
+  },
+  "templates.importPreview": {
+    method: "POST",
+    path: "/v1/templates/import/preview",
+    body: TemplateImportPreviewRequest,
+    response: TemplateImportPreview,
+    status: 200,
+    access: "read",
+    phase: "S1"
+  },
+  "templates.export": {
+    method: "GET",
+    path: "/v1/templates/:id/export",
+    params: IdParams,
+    query: TemplateExportQuery,
+    response: z14.string(),
+    responseType: "text",
+    status: 200,
+    access: "read",
+    phase: "S1"
+  },
+  "templates.compile": {
+    method: "POST",
+    path: "/v1/templates/:id/compile",
+    params: IdParams,
+    body: TemplateCompileRequest,
+    response: CompileResult,
+    status: 200,
+    access: "read",
+    phase: "S1"
+  },
+  compile: {
+    method: "POST",
+    path: "/v1/compile",
+    body: CompileRequest,
+    response: CompileResult,
+    status: 200,
+    access: "read",
+    phase: "S1"
+  },
+  "assets.upload": {
+    method: "POST",
+    path: "/v1/assets",
+    multipart: { fileField: "file" },
+    response: Asset,
+    status: 201,
+    access: "write",
+    phase: "S1"
+  },
+  "assets.import": {
+    method: "POST",
+    path: "/v1/assets/import",
+    body: AssetImport,
+    response: Asset,
+    status: 201,
+    access: "write",
+    phase: "S1"
+  },
+  "assets.get": {
+    method: "GET",
+    path: "/v1/assets/:id",
+    params: IdParams,
+    response: Asset,
+    status: 200,
+    access: "read",
+    phase: "S1"
+  },
+  // Saved sections: one section of a document, kept under a name so it can be
+  // dropped into any other template of the same workspace.
+  //
+  // `write` rather than `admin`: saving a footer is ordinary editing work, and
+  // the person who builds templates is the person who has it. Phase `S1`, with
+  // the rest of the editor and templates area: the plan calls this its own
+  // slice four, which is its numbering, not the service's phase.
+  "savedSections.list": {
+    method: "GET",
+    path: "/v1/saved-sections",
+    query: PageQuery,
+    response: list(SavedSection),
+    status: 200,
+    access: "read",
+    phase: "S1"
+  },
+  "savedSections.create": {
+    method: "POST",
+    path: "/v1/saved-sections",
+    body: SavedSectionCreate,
+    response: SavedSection,
+    status: 201,
+    access: "write",
+    phase: "S1"
+  },
+  "savedSections.update": {
+    method: "PATCH",
+    path: "/v1/saved-sections/:id",
+    params: IdParams,
+    body: SavedSectionUpdate,
+    response: SavedSection,
+    status: 200,
+    access: "write",
+    phase: "S1"
+  },
+  "savedSections.delete": {
+    method: "DELETE",
+    path: "/v1/saved-sections/:id",
+    params: IdParams,
+    response: Ok,
+    status: 200,
+    access: "write",
+    phase: "S1"
+  }
+};
+var sendingRoutes = {
+  "providers.list": {
+    method: "GET",
+    path: "/v1/providers",
+    query: PageQuery,
+    response: list(Provider),
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "providers.create": {
+    method: "POST",
+    path: "/v1/providers",
+    body: ProviderCreate,
+    response: Provider,
+    status: 201,
+    access: "admin",
+    phase: "S2"
+  },
+  "providers.get": {
+    method: "GET",
+    path: "/v1/providers/:id",
+    params: IdParams,
+    response: Provider,
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "providers.update": {
+    method: "PATCH",
+    path: "/v1/providers/:id",
+    params: IdParams,
+    body: ProviderUpdate,
+    response: Provider,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "providers.delete": {
+    method: "DELETE",
+    path: "/v1/providers/:id",
+    params: IdParams,
+    response: Ok,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "providers.verify": {
+    method: "POST",
+    path: "/v1/providers/:id/verify",
+    params: IdParams,
+    response: ProviderVerifyResult,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "providers.setEventsSecret": {
+    method: "PUT",
+    path: "/v1/providers/:id/events-secret",
+    params: IdParams,
+    body: ProviderEventsSecret,
+    response: Provider,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "providers.clearAnomaly": {
+    method: "POST",
+    path: "/v1/providers/:id/clear-anomaly",
+    params: IdParams,
+    response: Provider,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "providers.usage": {
+    method: "GET",
+    path: "/v1/providers/:id/usage",
+    params: IdParams,
+    response: ProviderUsage,
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "topics.list": {
+    method: "GET",
+    path: "/v1/topics",
+    query: PageQuery,
+    response: list(Topic),
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "topics.create": {
+    method: "POST",
+    path: "/v1/topics",
+    body: TopicCreate,
+    response: Topic,
+    status: 201,
+    access: "admin",
+    phase: "S2"
+  },
+  "topics.update": {
+    method: "PATCH",
+    path: "/v1/topics/:id",
+    params: IdParams,
+    body: TopicUpdate,
+    response: Topic,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "contacts.upsert": {
+    method: "POST",
+    path: "/v1/contacts",
+    body: ContactUpsert,
+    response: ContactUpsertResult,
+    status: 200,
+    access: "write",
+    phase: "S2"
+  },
+  "contacts.list": {
+    method: "GET",
+    path: "/v1/contacts",
+    query: ContactListQuery,
+    response: list(Contact),
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "contacts.get": {
+    method: "GET",
+    path: "/v1/contacts/:id",
+    params: IdParams,
+    response: Contact,
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "contacts.erase": {
+    method: "DELETE",
+    path: "/v1/contacts/:id",
+    params: IdParams,
+    response: ContactErased,
+    status: 200,
+    access: "write",
+    phase: "S2"
+  },
+  "contacts.messages": {
+    method: "GET",
+    path: "/v1/contacts/:id/messages",
+    params: IdParams,
+    query: PageQuery,
+    response: list(MessageSummary),
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "suppressions.list": {
+    method: "GET",
+    path: "/v1/suppressions",
+    query: SuppressionListQuery,
+    response: list(Suppression),
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "suppressions.create": {
+    method: "POST",
+    path: "/v1/suppressions",
+    body: SuppressionCreate,
+    response: Suppression,
+    status: 201,
+    access: "write",
+    phase: "S2"
+  },
+  "suppressions.delete": {
+    method: "DELETE",
+    path: "/v1/suppressions/:id",
+    params: IdParams,
+    response: Ok,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "mailings.list": {
+    method: "GET",
+    path: "/v1/mailings",
+    query: MailingListQuery,
+    response: list(MailingSummary),
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "mailings.create": {
+    method: "POST",
+    path: "/v1/mailings",
+    body: MailingCreate,
+    response: Mailing,
+    status: 201,
+    access: "write",
+    phase: "S2"
+  },
+  "mailings.get": {
+    method: "GET",
+    path: "/v1/mailings/:id",
+    params: IdParams,
+    response: Mailing,
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "mailings.export": {
+    method: "GET",
+    path: "/v1/mailings/:id/export",
+    params: IdParams,
+    query: MailingExportQuery,
+    response: z14.string(),
+    responseType: "text",
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "mailings.update": {
+    method: "PATCH",
+    path: "/v1/mailings/:id",
+    params: IdParams,
+    body: MailingUpdate,
+    response: Mailing,
+    status: 200,
+    access: "write",
+    phase: "S2"
+  },
+  "mailings.addRecipients": {
+    method: "POST",
+    path: "/v1/mailings/:id/recipients",
+    params: IdParams,
+    body: RecipientBatch,
+    response: RecipientBatchResult,
+    status: 200,
+    access: "write",
+    phase: "S2"
+  },
+  "mailings.listRecipients": {
+    method: "GET",
+    path: "/v1/mailings/:id/recipients",
+    params: IdParams,
+    query: RecipientListQuery,
+    response: list(Recipient),
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "mailings.test": {
+    method: "POST",
+    path: "/v1/mailings/:id/test",
+    params: IdParams,
+    body: MailingTestRequest,
+    response: MailingTestResult,
+    status: 200,
+    access: "write",
+    phase: "S2"
+  },
+  "mailings.send": {
+    method: "POST",
+    path: "/v1/mailings/:id/send",
+    params: IdParams,
+    body: MailingSendRequest,
+    response: Mailing,
+    status: 202,
+    access: "write",
+    phase: "S2"
+  },
+  "mailings.pause": {
+    method: "POST",
+    path: "/v1/mailings/:id/pause",
+    params: IdParams,
+    body: MailingActionRequest,
+    response: Mailing,
+    status: 200,
+    access: "write",
+    phase: "S2"
+  },
+  "mailings.resume": {
+    method: "POST",
+    path: "/v1/mailings/:id/resume",
+    params: IdParams,
+    body: MailingActionRequest,
+    response: Mailing,
+    status: 202,
+    access: "write",
+    phase: "S2"
+  },
+  "mailings.cancel": {
+    method: "POST",
+    path: "/v1/mailings/:id/cancel",
+    params: IdParams,
+    body: MailingActionRequest,
+    response: Mailing,
+    status: 200,
+    access: "write",
+    phase: "S2"
+  },
+  "mailings.retryFailed": {
+    method: "POST",
+    path: "/v1/mailings/:id/retry-failed",
+    params: IdParams,
+    body: MailingRetryFailedRequest,
+    response: Mailing,
+    status: 202,
+    access: "write",
+    phase: "S2"
+  },
+  /**
+   * Copies any mailing, in any state, into a new `draft` with the same content,
+   * topic and provider (no recipients). An A/B test's definition is copied
+   * (variants, test fraction, winner metric and wait) with its run reset: the
+   * copy's test is `pending`, with no winner and no results.
+   */
+  "mailings.duplicate": {
+    method: "POST",
+    path: "/v1/mailings/:id/duplicate",
+    params: IdParams,
+    body: MailingActionRequest,
+    response: Mailing,
+    status: 201,
+    access: "write",
+    phase: "S2"
+  },
+  "messages.list": {
+    method: "GET",
+    path: "/v1/messages",
+    query: MessageListQuery,
+    response: list(MessageSummary),
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "messages.get": {
+    method: "GET",
+    path: "/v1/messages/:id",
+    params: IdParams,
+    response: Message,
+    status: 200,
+    access: "read",
+    phase: "S2"
+  },
+  "webhooks.list": {
+    method: "GET",
+    path: "/v1/webhooks",
+    query: PageQuery,
+    response: list(WebhookEndpoint),
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "webhooks.create": {
+    method: "POST",
+    path: "/v1/webhooks",
+    body: WebhookEndpointCreate,
+    response: WebhookEndpointWithSecret,
+    status: 201,
+    access: "admin",
+    phase: "S2"
+  },
+  "webhooks.get": {
+    method: "GET",
+    path: "/v1/webhooks/:id",
+    params: IdParams,
+    response: WebhookEndpoint,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "webhooks.update": {
+    method: "PATCH",
+    path: "/v1/webhooks/:id",
+    params: IdParams,
+    body: WebhookEndpointUpdate,
+    response: WebhookEndpoint,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "webhooks.delete": {
+    method: "DELETE",
+    path: "/v1/webhooks/:id",
+    params: IdParams,
+    response: Ok,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "webhooks.rotateSecret": {
+    method: "POST",
+    path: "/v1/webhooks/:id/rotate-secret",
+    params: IdParams,
+    response: WebhookEndpointWithSecret,
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "webhooks.deliveries": {
+    method: "GET",
+    path: "/v1/webhooks/:id/deliveries",
+    params: IdParams,
+    query: WebhookDeliveryListQuery,
+    response: list(WebhookDelivery),
+    status: 200,
+    access: "admin",
+    phase: "S2"
+  },
+  "webhooks.redeliver": {
+    method: "POST",
+    path: "/v1/webhooks/:id/deliveries/:delivery_id/redeliver",
+    params: WebhookDeliveryParams,
+    response: WebhookDelivery,
+    status: 202,
+    access: "admin",
+    phase: "S2"
+  }
+};
+var platformRoutes = {
+  "tags.list": { method: "GET", path: "/v1/tags", query: PageQuery, response: list(Tag), status: 200, access: "read", phase: "S4" },
+  "tags.create": { method: "POST", path: "/v1/tags", body: TagCreate, response: Tag, status: 201, access: "write", phase: "S4" },
+  /** Deleting a tag takes it off every contact; segments that name it then match nobody for it. */
+  "tags.delete": { method: "DELETE", path: "/v1/tags/:id", params: IdParams, response: Ok, status: 200, access: "write", phase: "S4" },
+  "tags.assign": {
+    method: "POST",
+    path: "/v1/tags/:id/contacts",
+    params: IdParams,
+    body: TagAssignment,
+    response: Tag,
+    status: 200,
+    access: "write",
+    phase: "S4"
+  },
+  "tags.unassign": {
+    method: "DELETE",
+    path: "/v1/tags/:id/contacts",
+    params: IdParams,
+    body: TagAssignment,
+    response: Tag,
+    status: 200,
+    access: "write",
+    phase: "S4"
+  },
+  "contactProperties.list": {
+    method: "GET",
+    path: "/v1/contact-properties",
+    response: z14.object({ data: z14.array(ContactPropertyDefinition) }),
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
+  /** Defining a key refuses when a stored value of an existing contact has another type (`conflict`, with examples). */
+  "contactProperties.create": {
+    method: "POST",
+    path: "/v1/contact-properties",
+    body: ContactPropertyDefinition,
+    response: ContactPropertyDefinition,
+    status: 201,
+    access: "admin",
+    phase: "S4"
+  },
+  /** Removes the definition only; stored values stay and become free-form again. */
+  "contactProperties.delete": {
+    method: "DELETE",
+    path: "/v1/contact-properties/:key",
+    params: ContactPropertyParams,
+    response: Ok,
+    status: 200,
+    access: "admin",
+    phase: "S4"
+  },
+  "segments.list": {
+    method: "GET",
+    path: "/v1/segments",
+    query: PageQuery,
+    response: list(Segment),
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
+  "segments.create": {
+    method: "POST",
+    path: "/v1/segments",
+    body: SegmentCreate,
+    response: Segment,
+    status: 201,
+    access: "write",
+    phase: "S4"
+  },
+  /** Counts what a filter matches without saving it. */
+  "segments.preview": {
+    method: "POST",
+    path: "/v1/segments/preview",
+    body: SegmentPreviewRequest,
+    response: SegmentPreview,
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
+  "segments.get": { method: "GET", path: "/v1/segments/:id", params: IdParams, response: Segment, status: 200, access: "read", phase: "S4" },
+  "segments.update": {
+    method: "PUT",
+    path: "/v1/segments/:id",
+    params: IdParams,
+    body: SegmentCreate,
+    response: Segment,
+    status: 200,
+    access: "write",
+    phase: "S4"
+  },
+  "segments.delete": { method: "DELETE", path: "/v1/segments/:id", params: IdParams, response: Ok, status: 200, access: "write", phase: "S4" },
+  "mailings.addSegment": {
+    method: "POST",
+    path: "/v1/mailings/:id/recipients/segment",
+    params: IdParams,
+    body: MailingAudienceFromSegment,
+    response: RecipientBatchResult,
+    status: 200,
+    access: "write",
+    phase: "S4"
+  },
+  "mailings.schedule": {
+    method: "POST",
+    path: "/v1/mailings/:id/schedule",
+    params: IdParams,
+    body: MailingScheduleRequest,
+    response: Mailing,
+    status: 200,
+    access: "write",
+    phase: "S4"
+  },
+  /** A `scheduled` mailing back to `draft`. */
+  "mailings.unschedule": {
+    method: "POST",
+    path: "/v1/mailings/:id/unschedule",
+    params: IdParams,
+    body: MailingActionRequest,
+    response: Mailing,
+    status: 200,
+    access: "write",
+    phase: "S4"
+  },
+  /** Sets or replaces the A/B test of a `draft` or `scheduled` mailing. */
+  "mailings.setAbTest": {
+    method: "PUT",
+    path: "/v1/mailings/:id/ab-test",
+    params: IdParams,
+    body: AbTestConfig,
+    response: Mailing,
+    status: 200,
+    access: "write",
+    phase: "S4"
+  },
+  "mailings.clearAbTest": {
+    method: "DELETE",
+    path: "/v1/mailings/:id/ab-test",
+    params: IdParams,
+    response: Mailing,
+    status: 200,
+    access: "write",
+    phase: "S4"
+  },
+  /** Picks the winner of a running test by hand; the held recipients get it. */
+  "mailings.pickAbWinner": {
+    method: "POST",
+    path: "/v1/mailings/:id/ab-test/winner",
+    params: IdParams,
+    body: AbWinnerRequest,
+    response: Mailing,
+    status: 200,
+    access: "write",
+    phase: "S4"
+  },
+  "mailings.analytics": {
+    method: "GET",
+    path: "/v1/mailings/:id/analytics",
+    params: IdParams,
+    response: MailingAnalytics,
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
+  "signupForms.list": {
+    method: "GET",
+    path: "/v1/signup-forms",
+    query: PageQuery,
+    response: list(SignupForm),
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
+  "signupForms.create": {
+    method: "POST",
+    path: "/v1/signup-forms",
+    body: SignupFormCreate,
+    response: SignupForm,
+    status: 201,
+    access: "admin",
+    phase: "S4"
+  },
+  "signupForms.get": {
+    method: "GET",
+    path: "/v1/signup-forms/:id",
+    params: IdParams,
+    response: SignupForm,
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
+  "signupForms.update": {
+    method: "PUT",
+    path: "/v1/signup-forms/:id",
+    params: IdParams,
+    body: SignupFormCreate,
+    response: SignupForm,
+    status: 200,
+    access: "admin",
+    phase: "S4"
+  },
+  /** Pending confirmations of a deleted form stop working; confirmed subscriptions stay. */
+  "signupForms.delete": {
+    method: "DELETE",
+    path: "/v1/signup-forms/:id",
+    params: IdParams,
+    response: Ok,
+    status: 200,
+    access: "admin",
+    phase: "S4"
+  },
+  "signupForms.embed": {
+    method: "GET",
+    path: "/v1/signup-forms/:id/embed",
+    params: IdParams,
+    response: SignupFormEmbed,
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
+  /**
+   * The public submission, as JSON (the optional embed script and custom
+   * frontends). Answers 202 for every accepted-looking submission, whatever
+   * happens next, so it discloses nobody's membership.
+   */
+  "signupForms.submit": {
+    method: "POST",
+    path: "/v1/signup-forms/:id/submit",
+    params: IdParams,
+    body: SignupSubmission,
+    response: Ok,
+    status: 202,
+    access: "public",
+    phase: "S4"
+  },
+  /** Uploads the CSV (`file` field, UTF-8, comma or semicolon separated, a header row). */
+  "imports.create": {
+    method: "POST",
+    path: "/v1/imports",
+    multipart: { fileField: "file" },
+    response: ImportJob,
+    status: 201,
+    access: "write",
+    phase: "S4"
+  },
+  "imports.list": {
+    method: "GET",
+    path: "/v1/imports",
+    query: PageQuery,
+    response: list(ImportJob),
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
+  "imports.get": { method: "GET", path: "/v1/imports/:id", params: IdParams, response: ImportJob, status: 200, access: "read", phase: "S4" },
+  /** Sets or revises the mapping and starts its dry run (a revision discards the previous dry run). */
+  "imports.setMapping": {
+    method: "PUT",
+    path: "/v1/imports/:id/mapping",
+    params: IdParams,
+    body: ImportMappingRequest,
+    response: ImportJob,
+    status: 202,
+    access: "write",
+    phase: "S4"
+  },
+  "imports.commit": {
+    method: "POST",
+    path: "/v1/imports/:id/commit",
+    params: IdParams,
+    body: ImportCommitRequest,
+    response: ImportJob,
+    status: 202,
+    access: "write",
+    phase: "S4"
+  },
+  "imports.cancel": {
+    method: "POST",
+    path: "/v1/imports/:id/cancel",
+    params: IdParams,
+    body: MailingActionRequest,
+    response: ImportJob,
+    status: 200,
+    access: "write",
+    phase: "S4"
+  },
+  "imports.rows": {
+    method: "GET",
+    path: "/v1/imports/:id/rows",
+    params: IdParams,
+    query: ImportRowListQuery,
+    response: list(ImportRow),
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
+  "tracking.get": {
+    method: "GET",
+    path: "/v1/workspace/tracking",
+    response: TrackingSettings,
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
+  "tracking.update": {
+    method: "PUT",
+    path: "/v1/workspace/tracking",
+    body: TrackingSettings,
+    response: TrackingSettings,
+    status: 200,
+    access: "admin",
+    phase: "S4"
+  }
+};
+var billingRoutes = {
+  "billing.plans": {
+    method: "GET",
+    path: "/v1/billing/plans",
+    response: z14.object({ data: z14.array(CatalogPlan) }),
+    status: 200,
+    access: "read",
+    phase: "S5"
+  },
+  "billing.subscription": {
+    method: "GET",
+    path: "/v1/billing/subscription",
+    response: Subscription,
+    status: 200,
+    access: "admin",
+    phase: "S5"
+  },
+  "billing.usage": { method: "GET", path: "/v1/billing/usage", response: Usage, status: 200, access: "read", phase: "S5" },
+  "billing.checkout": {
+    method: "POST",
+    path: "/v1/billing/checkout",
+    body: CheckoutRequest,
+    response: CheckoutSession,
+    status: 200,
+    access: "admin",
+    phase: "S5"
+  },
+  "billing.portal": {
+    method: "POST",
+    path: "/v1/billing/portal",
+    body: PortalRequest,
+    response: PortalSession,
+    status: 200,
+    access: "admin",
+    phase: "S5"
+  }
+};
+var inviteRoutes = {
+  "invites.create": {
+    method: "POST",
+    path: "/v1/invites",
+    body: InviteCreate,
+    response: InviteCreated,
+    status: 201,
+    access: "admin",
+    phase: "S3"
+  },
+  "invites.list": {
+    method: "GET",
+    path: "/v1/invites",
+    query: InviteListQuery,
+    response: list(Invite),
+    status: 200,
+    access: "admin",
+    phase: "S3"
+  },
+  "invites.revoke": {
+    method: "DELETE",
+    path: "/v1/invites/:id",
+    params: IdParams,
+    response: Invite,
+    status: 200,
+    access: "admin",
+    phase: "S3"
+  },
+  "invites.accept": {
+    method: "POST",
+    path: "/v1/invites/accept",
+    body: InviteAccept,
+    response: InviteAccepted,
+    status: 200,
+    access: "dashboard",
+    phase: "S3"
+  }
+};
+var automationRoutes = {
+  "automations.list": {
+    method: "GET",
+    path: "/v1/automations",
+    query: AutomationListQuery,
+    response: list(AutomationSummary),
+    status: 200,
+    access: "read",
+    phase: "A1"
+  },
+  "automations.create": {
+    method: "POST",
+    path: "/v1/automations",
+    body: AutomationCreate,
+    response: AutomationWithFlow,
+    status: 201,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.get": {
+    method: "GET",
+    path: "/v1/automations/:id",
+    params: IdParams,
+    response: AutomationWithFlow,
+    status: 200,
+    access: "read",
+    phase: "A1"
+  },
+  "automations.update": {
+    method: "PATCH",
+    path: "/v1/automations/:id",
+    params: IdParams,
+    body: AutomationUpdate,
+    response: AutomationWithFlow,
+    status: 200,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.delete": {
+    method: "DELETE",
+    path: "/v1/automations/:id",
+    params: IdParams,
+    response: Ok,
+    status: 200,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.validate": {
+    method: "POST",
+    path: "/v1/automations/:id/validate",
+    params: IdParams,
+    body: AutomationValidateRequest,
+    response: AutomationValidation,
+    status: 200,
+    access: "read",
+    phase: "A1"
+  },
+  "automations.publish": {
+    method: "POST",
+    path: "/v1/automations/:id/publish",
+    params: IdParams,
+    body: AutomationPublishRequest,
+    response: AutomationPublishResult,
+    status: 200,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.pause": {
+    method: "POST",
+    path: "/v1/automations/:id/pause",
+    params: IdParams,
+    body: z14.object({}).strict(),
+    response: Automation,
+    status: 200,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.resume": {
+    method: "POST",
+    path: "/v1/automations/:id/resume",
+    params: IdParams,
+    body: z14.object({}).strict(),
+    response: Automation,
+    status: 200,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.archive": {
+    method: "POST",
+    path: "/v1/automations/:id/archive",
+    params: IdParams,
+    body: z14.object({}).strict(),
+    response: Automation,
+    status: 200,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.duplicate": {
+    method: "POST",
+    path: "/v1/automations/:id/duplicate",
+    params: IdParams,
+    body: AutomationDuplicateRequest,
+    response: AutomationWithFlow,
+    status: 201,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.enroll": {
+    method: "POST",
+    path: "/v1/automations/:id/enroll",
+    params: IdParams,
+    body: AutomationEnrollRequest,
+    response: AutomationEnrollResult,
+    status: 200,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.testEmail": {
+    method: "POST",
+    path: "/v1/automations/:id/steps/:step_id/test",
+    params: AutomationStepParams,
+    body: AutomationTestEmailRequest,
+    response: MailingTestResult,
+    status: 200,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.runs": {
+    method: "GET",
+    path: "/v1/automations/:id/runs",
+    params: IdParams,
+    query: AutomationRunListQuery,
+    response: list(AutomationRun),
+    status: 200,
+    access: "read",
+    phase: "A1"
+  },
+  "automations.run": {
+    method: "GET",
+    path: "/v1/automations/:id/runs/:run_id",
+    params: AutomationRunParams,
+    response: AutomationJourney,
+    status: 200,
+    access: "read",
+    phase: "A1"
+  },
+  "automations.exitRun": {
+    method: "POST",
+    path: "/v1/automations/:id/runs/:run_id/exit",
+    params: AutomationRunParams,
+    body: AutomationExitRunRequest,
+    response: AutomationRun,
+    status: 200,
+    access: "write",
+    phase: "A1"
+  },
+  "automations.report": {
+    method: "GET",
+    path: "/v1/automations/:id/report",
+    params: IdParams,
+    response: AutomationReport,
+    status: 200,
+    access: "read",
+    phase: "A1"
+  },
+  /**
+   * Every automation one contact has been through, newest first. It sits with
+   * the automations because that is the surface it belongs to, though its path
+   * hangs off the contact, which is where a person asks the question.
+   */
+  "contacts.automations": {
+    method: "GET",
+    path: "/v1/contacts/:id/automations",
+    params: IdParams,
+    query: ContactAutomationListQuery,
+    response: list(ContactAutomationRun),
+    status: 200,
+    access: "read",
+    phase: "A1"
+  },
+  "events.create": {
+    method: "POST",
+    path: "/v1/events",
+    body: EventCreate,
+    response: Event,
+    status: 201,
+    access: "write",
+    phase: "A1"
+  },
+  "events.list": {
+    method: "GET",
+    path: "/v1/events",
+    query: EventListQuery,
+    response: list(Event),
+    status: 200,
+    access: "read",
+    phase: "A1"
+  }
+};
+var routes = {
+  ...foundationRoutes,
+  ...templateRoutes,
+  ...sendingRoutes,
+  ...inviteRoutes,
+  ...platformRoutes,
+  ...billingRoutes,
+  ...automationRoutes
+};
+function acceptsIdempotencyKey(route) {
+  return route.method !== "GET";
+}
+function buildPath(path, params = {}) {
+  return path.replace(/:([a-z_]+)/g, (_, name) => {
+    const value = params[name];
+    if (value === void 0 || value === "") throw new Error(`missing path parameter "${name}" for ${path}`);
+    return encodeURIComponent(String(value));
+  });
+}
+function matchRoute(method, pathname) {
+  for (const [id, route] of Object.entries(routes)) {
+    if (route.method !== method) continue;
+    const names = [];
+    const pattern = new RegExp(
+      "^" + route.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:([a-z_]+)/g, (_, name) => {
+        names.push(name);
+        return "([^/]+)";
+      }) + "$"
+    );
+    const match = pattern.exec(pathname);
+    if (!match) continue;
+    const params = {};
+    names.forEach((name, i) => {
+      params[name] = decodeURIComponent(match[i + 1]);
+    });
+    return { id, params };
+  }
+  return null;
+}
+export {
+  AB_TEST_STATUSES,
+  AB_WINNER_METRICS,
+  API_KEY_SCOPES,
+  API_VERSION_PREFIX,
+  ASSET_CONTENT_TYPES,
+  ASSET_POLICIES,
+  ASSET_UPLOAD_FIELD,
+  AUDIT_ACTIONS,
+  AUTHORIZATION_HEADER,
+  AUTOMATION_DATE_TRIGGER_KINDS,
+  AUTOMATION_END_REASONS,
+  AUTOMATION_ENTRY_REFUSALS,
+  AUTOMATION_FILTER_FIELD_OPERATORS,
+  AUTOMATION_FILTER_FIELD_PATTERN,
+  AUTOMATION_ISSUE_CODES,
+  AUTOMATION_STATUSES,
+  AUTOMATION_STEP_KINDS,
+  AUTOMATION_TRIGGER_KINDS,
+  AUTOMATION_WAIT_REASONS,
+  AbTestConfig,
+  AbTestState,
+  AbVariant,
+  AbWinnerRequest,
+  ApiKey,
+  ApiKeyCreate,
+  ApiKeyCreated,
+  ApiKeyScope,
+  Asset,
+  AssetContentType,
+  AssetImport,
+  AssetPolicy,
+  AuditAction,
+  AuditActor,
+  AuditEntry,
+  AuditQuery,
+  Automation,
+  AutomationCounts,
+  AutomationCreate,
+  AutomationDuplicateRequest,
+  AutomationEndReason,
+  AutomationEnrollRequest,
+  AutomationEnrollResult,
+  AutomationEnrollment,
+  AutomationEntryRefusal,
+  AutomationExitRunRequest,
+  AutomationFilter,
+  AutomationFilterCondition,
+  AutomationFilterField,
+  AutomationFlow,
+  AutomationIssue,
+  AutomationIssueCode,
+  AutomationJourney,
+  AutomationListQuery,
+  AutomationPublishMove,
+  AutomationPublishRequest,
+  AutomationPublishResult,
+  AutomationReport,
+  AutomationRun,
+  AutomationRunCompletedData,
+  AutomationRunExitedData,
+  AutomationRunFailedData,
+  AutomationRunListQuery,
+  AutomationRunParams,
+  AutomationRunStartedData,
+  AutomationRunStatus,
+  AutomationSettings,
+  AutomationStatus,
+  AutomationStep,
+  AutomationStepExecution,
+  AutomationStepKind,
+  AutomationStepParams,
+  AutomationStepReport,
+  AutomationSummary,
+  AutomationTestEmailRequest,
+  AutomationTrigger,
+  AutomationTriggerKind,
+  AutomationUpdate,
+  AutomationValidateRequest,
+  AutomationValidation,
+  AutomationWaitReason,
+  AutomationWebhookData,
+  AutomationWithFlow,
+  BEARER_PREFIX,
+  BILLING_NOT_CONFIGURED_REASON,
+  BoundedAutomationFilter,
+  BoundedSegmentFilter,
+  CONTACT_PROPERTY_TYPES,
+  CatalogPlan,
+  CheckoutRequest,
+  CheckoutSession,
+  CompanyId,
+  CompileMessage,
+  CompileRequest,
+  CompileResult,
+  ConditionStep,
+  Contact,
+  ContactAutomationListQuery,
+  ContactAutomationRun,
+  ContactBouncedData,
+  ContactErased,
+  ContactListQuery,
+  ContactPropertyDefinition,
+  ContactPropertyKey,
+  ContactPropertyParams,
+  ContactPropertyType,
+  ContactResubscribedData,
+  ContactSubscribedData,
+  ContactTaggedData,
+  ContactUnsubscribedData,
+  ContactUpdatedData,
+  ContactUpsert,
+  ContactUpsertResult,
+  DATE_PASSED_ANSWERS,
+  DEFAULT_INVITE_TTL_DAYS,
+  DEFAULT_PAGE_LIMIT,
+  DOCUMENT_SCHEMA_VERSIONS,
+  DateOnly,
+  DatePassedAnswer,
+  DelayStep,
+  DocumentSchemaVersion,
+  EDITABLE_MAILING_STATUSES,
+  ERROR_CODES,
+  ERROR_STATUS,
+  EXPORT_CONTENT_TYPES,
+  EXPORT_FORMATS,
+  EXPORT_WARNINGS_HEADER,
+  EXPORT_WARNING_COUNT_HEADER,
+  Email,
+  EmailStep,
+  ErrorBody,
+  ErrorCodeSchema,
+  Event,
+  EventCreate,
+  EventListQuery,
+  EventName,
+  ExportFormat,
+  FILTER_FIELD_OPERATORS,
+  FILTER_OPERATORS,
+  FilterCondition,
+  FilterField,
+  FilterOperator,
+  GotoStep,
+  HEALTH_PATH,
+  HOSTED_PAGE_LOCALES,
+  ICLOUD_SMTP_POLICY,
+  IDEMPOTENCY_KEY_HEADER,
+  IDEMPOTENCY_KEY_MAX_LENGTH,
+  IDEMPOTENCY_KEY_RETENTION_HOURS,
+  IMPORT_FILE_FIELD,
+  IMPORT_ROW_OUTCOMES,
+  IMPORT_SKIP_REASONS,
+  IMPORT_STATUSES,
+  IMPORT_TERMINAL_STATUSES,
+  INVITE_REFUSAL_REASONS,
+  INVITE_STATUSES,
+  Id,
+  IdParams,
+  ImportColumnMapping,
+  ImportCommitRequest,
+  ImportFinishedData,
+  ImportJob,
+  ImportMappingRequest,
+  ImportReport,
+  ImportRow,
+  ImportRowListQuery,
+  ImportRowOutcome,
+  ImportSkipReason,
+  ImportStatus,
+  ImportWarning,
+  ImportedAsset,
+  Invite,
+  InviteAccept,
+  InviteAccepted,
+  InviteCreate,
+  InviteCreated,
+  InviteListQuery,
+  InviteStatus,
+  JsonValue,
+  LIST_UNSUBSCRIBE_POST_VALUE,
+  MAILING_ACTIONS,
+  MAILING_KINDS,
+  MAILING_STATUSES,
+  MAILING_TRANSITIONS,
+  MAX_ASSET_BYTES,
+  MAX_DELAY_SECONDS,
+  MAX_DOCUMENT_BYTES,
+  MAX_ENGAGEMENT_DAYS,
+  MAX_EXPORT_WARNINGS_HEADER_LENGTH,
+  MAX_FILTER_DEPTH,
+  MAX_IMPORTED_REMOTE_IMAGES,
+  MAX_IMPORT_BYTES,
+  MAX_IMPORT_ROWS,
+  MAX_IMPORT_URL_LENGTH,
+  MAX_INVITE_TTL_DAYS,
+  MAX_IN_LIST,
+  MAX_MJML_DEPTH,
+  MAX_MJML_ELEMENTS,
+  MAX_MJML_IMPORT_BYTES,
+  MAX_PAGE_LIMIT,
+  MAX_RECIPIENTS_PER_BATCH,
+  MAX_RE_ENTRY_COOLDOWN_SECONDS,
+  MAX_SAVED_SECTIONS,
+  MAX_SPLIT_BRANCHES,
+  MAX_STEPS,
+  MAX_STEP_VISITS,
+  MAX_TRIGGERS,
+  MEMBER_ROLES,
+  MERGE_FIELD_PATTERN,
+  MESSAGE_OUTCOMES,
+  MIN_SPLIT_BRANCHES,
+  MJML_IMPORT_REFUSALS,
+  Mailing,
+  MailingAbWinnerSelectedData,
+  MailingAction,
+  MailingActionRequest,
+  MailingAnalytics,
+  MailingAudienceFromSegment,
+  MailingCounts,
+  MailingCreate,
+  MailingExportQuery,
+  MailingFinishedData,
+  MailingKind,
+  MailingListQuery,
+  MailingMetadata,
+  MailingRetryFailedRequest,
+  MailingScheduleFailedData,
+  MailingScheduleRequest,
+  MailingScheduledData,
+  MailingSendRequest,
+  MailingStartedData,
+  MailingStatus,
+  MailingSummary,
+  MailingTestRequest,
+  MailingTestResult,
+  MailingUpdate,
+  Member,
+  MemberCreate,
+  MemberRole,
+  MemberUpdate,
+  Message,
+  MessageFailedData,
+  MessageListQuery,
+  MessageOutcome,
+  MessageSentData,
+  MessageSummary,
+  NotifyRecipients,
+  NotifyStep,
+  OffsetDays,
+  Ok,
+  PLAN_FEATURES,
+  PLAN_IDS,
+  PROVIDER_KINDS,
+  PageQuery,
+  Plan,
+  PlanFeatures,
+  PlanId,
+  PlanLimits,
+  PortalRequest,
+  PortalSession,
+  Properties,
+  Provider,
+  ProviderCreate,
+  ProviderEvents,
+  ProviderEventsSecret,
+  ProviderKind,
+  ProviderPolicy,
+  ProviderRejections,
+  ProviderUpdate,
+  ProviderUsage,
+  ProviderVerifyResult,
+  QuietHours,
+  RECIPIENT_REJECTIONS,
+  RECIPIENT_STATUSES,
+  REQUEST_ID_HEADER,
+  RESEND_EVENT_TYPES,
+  RESERVED_MERGE_FIELDS,
+  RETRYABLE_ERRORS,
+  RETRY_AFTER_HEADER,
+  RE_ENTRY_MODES,
+  ReEntryMode,
+  Recipient,
+  RecipientBatch,
+  RecipientBatchResult,
+  RecipientInput,
+  RecipientListQuery,
+  RecipientStatus,
+  RemoteImage,
+  ResendSigningSecret,
+  SIGNUP_FORM_FIELDS,
+  SKIP_REASONS,
+  SMTP_SECURITY,
+  SUBJECT_HEADER,
+  SUPPRESSION_REASONS,
+  SavedSection,
+  SavedSectionBody,
+  SavedSectionCreate,
+  SavedSectionUpdate,
+  Segment,
+  SegmentCreate,
+  SegmentFilter,
+  SegmentPreview,
+  SegmentPreviewRequest,
+  SignupForm,
+  SignupFormCreate,
+  SignupFormEmbed,
+  SignupFormTranslation,
+  SignupSubmission,
+  SkipReason,
+  Slug,
+  SplitBranchKey,
+  SplitStep,
+  StepId,
+  Subscription,
+  Suppression,
+  SuppressionCreate,
+  SuppressionListQuery,
+  SuppressionReason,
+  TERMINAL_MAILING_STATUSES,
+  Tag,
+  TagAssignment,
+  TagCreate,
+  Template,
+  TemplateCompileRequest,
+  TemplateCreate,
+  TemplateDocument,
+  TemplateExportQuery,
+  TemplateImport,
+  TemplateImportPreview,
+  TemplateImportPreviewRequest,
+  TemplateImportResult,
+  TemplateListQuery,
+  TemplateSummary,
+  TemplateUpdate,
+  TemplateVersion,
+  TemplateVersionParams,
+  TimeOfDay,
+  Timestamp,
+  TimezoneName,
+  Topic,
+  TopicCreate,
+  TopicUpdate,
+  TrackingSettings,
+  UNSUBSCRIBE_PATH_PREFIX,
+  UNSUBSCRIBE_SOURCES,
+  USAGE_METRICS,
+  USAGE_WARNING_HEADER,
+  USAGE_WARNING_RATIO,
+  Usage,
+  UsageMetric,
+  UsageWarning,
+  ValidationIssue,
+  VariantAnalytics,
+  WEBHOOK_DELIVERY_STATUSES,
+  WEBHOOK_EVENT_ID_HEADER,
+  WEBHOOK_EVENT_TYPES,
+  WEBHOOK_MAX_ATTEMPTS,
+  WEBHOOK_RETRY_DELAYS_SECONDS,
+  WEBHOOK_SECRET_PREFIX,
+  WEBHOOK_SIGNATURE_HEADER,
+  WEBHOOK_SIGNATURE_VERSION,
+  WEBHOOK_TIMESTAMP_HEADER,
+  WEBHOOK_TOLERANCE_SECONDS,
+  WORKSPACE_HEADER,
+  WebhookDelivery,
+  WebhookDeliveryListQuery,
+  WebhookDeliveryParams,
+  WebhookDeliveryStatus,
+  WebhookEndpoint,
+  WebhookEndpointCreate,
+  WebhookEndpointUpdate,
+  WebhookEndpointWithSecret,
+  WebhookEvent,
+  WebhookEventType,
+  WebhookStep,
+  WebhookUrl,
+  Weekday,
+  Workspace,
+  WorkspaceCreate,
+  WorkspaceMembership,
+  WorkspaceMove,
+  WorkspaceSettings,
+  WorkspaceUpdate,
+  acceptsIdempotencyKey,
+  alwaysWaits,
+  automationFilterFamily,
+  automationRoutes,
+  billingRoutes,
+  buildPath,
+  canTransition,
+  cycles,
+  defaultSettings,
+  emptyFlow,
+  errorBody,
+  exportFilename,
+  filterConditions,
+  filterDepth,
+  filterFieldFamily,
+  filterLeafProblem,
+  findMergeFields,
+  formatExportWarningsHeader,
+  formatUsageWarningHeader,
+  foundationRoutes,
+  inviteRoutes,
+  isDayEntirelyPast,
+  isPublishable,
+  isRetryableError,
+  matchRoute,
+  missingRequiredMergeFields,
+  nowSeconds,
+  page,
+  parseExportWarningsHeader,
+  parseUsageWarningHeader,
+  platformRoutes,
+  reachable,
+  routes,
+  sendingRoutes,
+  signWebhook,
+  statusForError,
+  stepTargets,
+  stronglyConnected,
+  templateRoutes,
+  testGroupSize,
+  tightLoops,
+  timingSafeEqualString,
+  triggerKey,
+  validateAutomation,
+  verifyWebhook
+};