@marlinjai/mail-contract 0.4.0 → 0.5.0

package/dist/index.mjs

@@ -22,6 +22,29 @@ function page(item) {
 }
 var IdParams = z.object({ id: Id });
 var Ok = z.object({ ok: z.literal(true) });
+var LOCALE_TAG_PATTERN = /^[A-Za-z]{2,3}(?:-[A-Za-z]{4})?(?:-(?:[A-Za-z]{2}|[0-9]{3}))?$/;
+var LocaleTag = z.string().min(2).max(35).regex(LOCALE_TAG_PATTERN, "a language tag such as en, fr or pt-BR");
+function canonicalLocale(tag) {
+  if (typeof tag !== "string") return null;
+  const trimmed = tag.trim().replace(/_/g, "-");
+  if (!LOCALE_TAG_PATTERN.test(trimmed)) return null;
+  return trimmed.split("-").map((part, i) => {
+    if (i === 0) return part.toLowerCase();
+    if (part.length === 4) return part[0].toUpperCase() + part.slice(1).toLowerCase();
+    return part.toUpperCase();
+  }).join("-");
+}
+function primaryLanguage(tag) {
+  return canonicalLocale(tag)?.split("-")[0] ?? null;
+}
+function matchLocale(wanted, available) {
+  const canonical = canonicalLocale(wanted);
+  if (!canonical) return null;
+  const exact = available.find((a) => canonicalLocale(a) === canonical);
+  if (exact !== void 0) return exact;
+  const primary = canonical.split("-")[0];
+  return available.find((a) => primaryLanguage(a) === primary) ?? null;
+}
 
 // src/errors.ts
 import { z as z2 } from "zod";
@@ -137,32 +160,71 @@ var TemplateDocument = z3.object({
   sections: z3.array(z3.record(z3.unknown()))
 }).passthrough();
 var MAX_DOCUMENT_BYTES = 1e6;
+var MAX_SUBJECT_LENGTH = 998;
+var MAX_PREHEADER_LENGTH = 500;
+var TemplateSubject = z3.string().max(MAX_SUBJECT_LENGTH).regex(/^[^\x00-\x1f\x7f]*$/, "one line, without control characters");
+var TemplatePreheader = z3.string().max(MAX_PREHEADER_LENGTH).regex(/^[^\x00-\x1f\x7f]*$/, "one line, without control characters");
+var TEMPLATE_LANGUAGE_STATUSES = ["draft", "ready"];
+var TemplateLanguageStatus = z3.enum(TEMPLATE_LANGUAGE_STATUSES);
+var TemplateTranslation = z3.object({
+  subject: TemplateSubject.nullable(),
+  preheader: TemplatePreheader.nullable(),
+  document: TemplateDocument,
+  status: TemplateLanguageStatus
+});
+var MAX_TEMPLATE_TRANSLATIONS = 19;
+var TemplateTranslations = z3.record(LocaleTag, TemplateTranslation).refine((t) => Object.keys(t).length <= MAX_TEMPLATE_TRANSLATIONS, `at most ${MAX_TEMPLATE_TRANSLATIONS} language versions`);
 var Template = z3.object({
   id: Id,
   name: z3.string().min(1).max(200),
   description: z3.string().max(2e3).nullable(),
+  /**
+   * The main language: what `subject`, `preheader` and `document` are written
+   * in, and what every recipient without a ready version of their own gets.
+   * Set from the workspace's `default_locale` when the template is created
+   * unless given, and never changed by a later change of that setting.
+   */
+  locale: LocaleTag,
+  /** The main language's subject line; null when the mailing that uses the template gives one. */
+  subject: TemplateSubject.nullable(),
+  preheader: TemplatePreheader.nullable(),
   document: TemplateDocument,
-  /** Increments on every saved change. */
+  /**
+   * The other languages. A version whose language the workspace no longer
+   * lists is kept, but no send uses it until the language is listed again.
+   */
+  translations: TemplateTranslations,
+  /** Increments on every saved change, of any language. */
   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 TemplateSummary = Template.omit({ document: true, translations: true }).extend({
+  languages: z3.record(LocaleTag, TemplateLanguageStatus)
+});
 var TemplateCreate = z3.object({
   name: z3.string().min(1).max(200),
   description: z3.string().max(2e3).optional(),
-  document: TemplateDocument
+  locale: LocaleTag.optional(),
+  subject: TemplateSubject.nullable().optional(),
+  preheader: TemplatePreheader.nullable().optional(),
+  document: TemplateDocument,
+  translations: TemplateTranslations.optional()
 });
 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(),
+  locale: LocaleTag.optional(),
+  subject: TemplateSubject.nullable().optional(),
+  preheader: TemplatePreheader.nullable().optional(),
   document: TemplateDocument.optional(),
+  translations: z3.record(LocaleTag, TemplateTranslation.nullable()).optional(),
   archived: z3.boolean().optional()
 }).refine(
-  (v) => v.name !== void 0 || v.description !== void 0 || v.document !== void 0 || v.archived !== void 0,
+  (v) => v.name !== void 0 || v.description !== void 0 || v.locale !== void 0 || v.subject !== void 0 || v.preheader !== void 0 || v.document !== void 0 || v.translations !== void 0 || v.archived !== void 0,
   "at least one field besides base_version"
 );
 var SavedSectionBody = z3.record(z3.unknown());
@@ -192,7 +254,11 @@ var TemplateListQuery = PageQuery.extend({
 var TemplateVersion = z3.object({
   template_id: Id,
   version: z3.number().int().min(1),
+  locale: LocaleTag,
+  subject: TemplateSubject.nullable(),
+  preheader: TemplatePreheader.nullable(),
   document: TemplateDocument,
+  translations: TemplateTranslations,
   created_by: z3.string().nullable(),
   created_at: Timestamp
 });
@@ -213,7 +279,8 @@ var CompileResult = z3.object({
   errors: z3.array(CompileMessage)
 });
 var TemplateCompileRequest = z3.object({
-  version: z3.number().int().min(1).optional()
+  version: z3.number().int().min(1).optional(),
+  locale: LocaleTag.optional()
 });
 var CompileRequest = z3.object({
   document: TemplateDocument
@@ -305,7 +372,8 @@ 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()
+  version: z3.coerce.number().int().min(1).optional(),
+  locale: LocaleTag.optional()
 });
 var MailingExportQuery = z3.object({ format: ExportFormat });
 var EXPORT_CONTENT_TYPES = {
@@ -436,9 +504,29 @@ var Mailing = z5.object({
   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. */
+  /**
+   * The template the document was taken from, if any. The snapshot is what is
+   * sent in the main language; the template's other language versions are
+   * taken, the ready ones, when the mailing starts (see "Languages" in the
+   * contract's documentation).
+   */
   template_id: Id.nullable(),
   document: TemplateDocument,
+  /**
+   * The main language: what `subject`, `preheader` and `document` are written
+   * in, and what every recipient without a ready version in their own language
+   * gets. The template's main language, or the workspace's default for a
+   * mailing made from a document.
+   */
+  locale: LocaleTag,
+  /**
+   * The language every recipient is treated as reading, or null to read each
+   * recipient's own (their `merge.locale`, else their contact's language). A
+   * letter sets it to the language its one reader wrote in; a broadcast can use
+   * it to send one language version to everyone. It is matched like anyone's
+   * language: without a ready version in it, the main language goes out.
+   */
+  send_locale: LocaleTag.nullable(),
   /**
    * The topic the mailing is sent under. Null for a letter (a one-to-one
    * mailing with at most one recipient, which belongs to no topic and whose
@@ -469,6 +557,8 @@ var MailingContent = {
   name: z5.string().max(200).optional(),
   subject: z5.string().min(1).max(998),
   preheader: z5.string().max(500).optional(),
+  /** See `Mailing.send_locale`. */
+  send_locale: LocaleTag.nullable().optional(),
   /**
    * Omitted or null makes the mailing a letter: one recipient at most, sent to
    * anybody not blocked on every topic, with an unsubscribe link that offers
@@ -481,11 +571,15 @@ var MailingContent = {
 };
 var MailingCreate = z5.object({
   ...MailingContent,
+  subject: MailingContent.subject.optional(),
   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"]
+}).refine((v) => v.template_id !== void 0 || v.subject !== void 0, {
+  message: "a mailing made from a document needs a subject",
+  path: ["subject"]
 });
 var MailingUpdate = z5.object({
   name: z5.string().max(200).nullable().optional(),
@@ -493,6 +587,7 @@ var MailingUpdate = z5.object({
   preheader: z5.string().max(500).nullable().optional(),
   /** Null turns a draft into a letter, which it can only be with at most one recipient. */
   topic: Slug.nullable().optional(),
+  send_locale: LocaleTag.nullable().optional(),
   provider_id: Id.optional(),
   metadata: MailingMetadata.optional(),
   document: TemplateDocument.optional()
@@ -515,7 +610,8 @@ var MailingRetryFailedRequest = z5.object({
 var MailingActionRequest = z5.object({}).strict();
 var MailingTestRequest = z5.object({
   to: Email,
-  merge: Properties.optional()
+  merge: Properties.optional(),
+  locale: LocaleTag.optional()
 });
 var MailingTestResult = z5.object({
   message_id: Id,
@@ -582,9 +678,27 @@ var MessageSummary = z5.object({
   error: z5.string().nullable(),
   is_test: z5.boolean(),
   recipient_count: z5.number().int().min(1),
+  /** The language version the message was sent in; null for messages archived before languages existed. */
+  locale: LocaleTag.nullable(),
   created_at: Timestamp
 });
 var Message = MessageSummary.extend({ html: z5.string() });
+var MailingLanguageStatus = z5.enum(["main", "ready", "draft", "not_a_workspace_language"]);
+var MailingLanguage = z5.object({
+  locale: LocaleTag,
+  status: MailingLanguageStatus,
+  /** Queued recipients who will get this version. */
+  planned: z5.number().int().min(0),
+  /** Messages already sent in this language (tests excluded). */
+  sent: z5.number().int().min(0)
+});
+var MailingLanguageReport = z5.object({
+  main_locale: LocaleTag,
+  send_locale: LocaleTag.nullable(),
+  languages: z5.array(MailingLanguage),
+  fallback: z5.array(z5.object({ wanted: z5.string(), planned: z5.number().int().min(1) })),
+  no_language: z5.number().int().min(0)
+});
 var MessageListQuery = PageQuery.extend({
   mailing_id: Id.optional(),
   outcome: MessageOutcome.optional()
@@ -1094,15 +1208,22 @@ 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 EmailStepLanguage = z7.object({
+  subject: z7.string().min(1).max(998),
+  preheader: z7.string().max(500).nullable(),
+  document: TemplateDocument
+}).strict();
 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. */
+  /** Empty while the step is being written, or when its template has a subject; else `not_chosen` refuses to publish it. */
   subject: z7.string().max(998),
-  preheader: z7.string().max(500).nullish()
+  preheader: z7.string().max(500).nullish(),
+  locale: LocaleTag.nullish(),
+  languages: z7.record(LocaleTag, EmailStepLanguage).nullish()
 }).strict();
 var DelayStep = z7.object({
   kind: z7.literal("delay"),
@@ -1408,7 +1529,7 @@ function validateAutomation(flow, settings, ctx) {
         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() === "") {
+        if (step.subject.trim() === "" && !(step.template_id && known.templates_with_subject?.has(step.template_id))) {
           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);
@@ -1893,7 +2014,7 @@ var AutomationReport = z7.object({
 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 AutomationTestEmailRequest = z7.object({ to: Email, merge: Properties.optional(), locale: LocaleTag.optional() }).strict();
 var AutomationValidateRequest = z7.object({ flow: AutomationFlow.optional(), settings: AutomationSettings.partial().optional() }).strict();
 var EventCreate = z7.object({
   name: EventName,
@@ -1962,10 +2083,19 @@ var MergeDefaults = z8.record(MergeFieldName, MergeDefaultValue).refine((m) => O
   message: `a reserved merge field (${Object.keys(RESERVED_MERGE_FIELDS).join(", ")}) cannot have a workspace default`
 });
 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),
+  /**
+   * The workspace's main language (a {@link LocaleTag}, e.g. "de"): the main
+   * language of a new template, and of the hosted pages when nothing else
+   * decides.
+   */
+  default_locale: LocaleTag,
+  /**
+   * The languages the workspace writes in, including `default_locale`, none
+   * twice (compared without regard to casing). A template can have a version in
+   * each; the hosted pages are offered in those of them they support (English,
+   * German, French, Italian, Spanish). The service stores canonical casing.
+   */
+  locales: z8.array(LocaleTag).min(1).max(20).refine((l) => new Set(l.map((t) => t.toLowerCase())).size === l.length, "a language appears twice"),
   /** 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. */
@@ -2217,6 +2347,200 @@ var InviteAccepted = z9.object({
 });
 var INVITE_REFUSAL_REASONS = ["email_mismatch", "inviter_lacks_role", "expired", "revoked", "accepted"];
 
+// src/template-languages.ts
+function languageTabs(mainLocale, versions, workspaceLocales) {
+  const main = canonicalLocale(mainLocale) ?? mainLocale;
+  const statuses = /* @__PURE__ */ new Map();
+  for (const [tag, status] of Object.entries(versions)) {
+    const canonical = canonicalLocale(tag) ?? tag;
+    if (canonical !== main) statuses.set(canonical, status);
+  }
+  const tabs = [{ locale: main, kind: "main", status: "ready" }];
+  const seen = /* @__PURE__ */ new Set([main]);
+  for (const tag of workspaceLocales) {
+    const canonical = canonicalLocale(tag) ?? tag;
+    if (seen.has(canonical)) continue;
+    seen.add(canonical);
+    tabs.push({ locale: canonical, kind: "translation", status: statuses.get(canonical) ?? "missing" });
+  }
+  const kept = [...statuses.keys()].filter((tag) => !seen.has(tag)).sort();
+  for (const tag of kept) tabs.push({ locale: tag, kind: "kept", status: statuses.get(tag) });
+  return tabs;
+}
+function languageName(tag) {
+  const canonical = canonicalLocale(tag) ?? tag;
+  try {
+    const names = new Intl.DisplayNames(["en"], { type: "language", fallback: "none" });
+    const name = names.of(canonical);
+    return name && name !== canonical ? name : canonical;
+  } catch {
+    return canonical;
+  }
+}
+function storedTemplateLine(value) {
+  if (value === null || value === void 0) return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+}
+function buildTemplatePatch(args) {
+  const { loaded, main, documentChanged, translations, changed, removed } = args;
+  const out = {};
+  const subject = storedTemplateLine(main.subject);
+  if (subject !== storedTemplateLine(loaded.subject)) out.subject = subject;
+  const preheader = storedTemplateLine(main.preheader);
+  if (preheader !== storedTemplateLine(loaded.preheader)) out.preheader = preheader;
+  if (documentChanged) out.document = main.document;
+  const patch = {};
+  for (const tag of changed) {
+    const version = translations[tag];
+    if (version && !removed.has(tag)) {
+      patch[tag] = { subject: storedTemplateLine(version.subject), preheader: storedTemplateLine(version.preheader), document: version.document, status: version.status };
+    }
+  }
+  for (const tag of removed) {
+    if (Object.prototype.hasOwnProperty.call(loaded.translations, tag)) patch[tag] = null;
+  }
+  if (Object.keys(patch).length > 0) out.translations = patch;
+  return out;
+}
+function restorePatch(old, current, workspaceLocales) {
+  const oldMain = canonicalLocale(old.locale) ?? old.locale;
+  const listed = workspaceLocales ? new Set(workspaceLocales.map((t) => canonicalLocale(t) ?? t)) : null;
+  const patch = {};
+  const skipped = [];
+  const untouched = /* @__PURE__ */ new Set();
+  for (const [tag, version] of Object.entries(old.translations)) {
+    const canonical = canonicalLocale(tag) ?? tag;
+    if (canonical === oldMain) continue;
+    if (listed && !listed.has(canonical)) {
+      skipped.push(canonical);
+      untouched.add(canonical);
+      continue;
+    }
+    patch[canonical] = version;
+  }
+  for (const tag of Object.keys(current.translations)) {
+    const canonical = canonicalLocale(tag) ?? tag;
+    if (!(canonical in patch) && !untouched.has(canonical)) patch[canonical] = null;
+    if (canonical === oldMain) patch[canonical] = null;
+  }
+  const update = {
+    ...oldMain !== (canonicalLocale(current.locale) ?? current.locale) ? { locale: oldMain } : {},
+    subject: old.subject,
+    preheader: old.preheader,
+    document: old.document,
+    ...Object.keys(patch).length > 0 ? { translations: patch } : {}
+  };
+  return { update, skipped: skipped.sort() };
+}
+function draftsFromTemplate(template) {
+  const translations = {};
+  for (const [tag, version] of Object.entries(template.translations)) translations[canonicalLocale(tag) ?? tag] = version;
+  return {
+    main: { subject: template.subject ?? "", preheader: template.preheader ?? "", document: template.document },
+    translations,
+    mainDocumentChanged: false,
+    changed: [],
+    removed: []
+  };
+}
+var withChanged = (list2, tag) => list2.includes(tag) ? [...list2] : [...list2, tag];
+var without = (list2, tag) => list2.filter((t) => t !== tag);
+function draftDocument(drafts, locale) {
+  if (locale === null) return drafts.main.document;
+  return drafts.translations[locale]?.document;
+}
+function addLanguageDraft(drafts, locale) {
+  const tag = canonicalLocale(locale) ?? locale;
+  if (drafts.translations[tag]) return drafts;
+  return {
+    ...drafts,
+    translations: {
+      ...drafts.translations,
+      [tag]: {
+        subject: drafts.main.subject,
+        preheader: drafts.main.preheader,
+        document: structuredClone(drafts.main.document),
+        status: "draft"
+      }
+    },
+    changed: withChanged(drafts.changed, tag),
+    removed: without(drafts.removed, tag)
+  };
+}
+function removeLanguageDraft(drafts, locale) {
+  const tag = canonicalLocale(locale) ?? locale;
+  const { [tag]: _gone, ...rest } = drafts.translations;
+  return { ...drafts, translations: rest, changed: without(drafts.changed, tag), removed: withChanged(drafts.removed, tag) };
+}
+function editLanguageDraft(drafts, locale, edit) {
+  if (locale === null) {
+    return {
+      ...drafts,
+      main: { ...drafts.main, ...edit },
+      mainDocumentChanged: drafts.mainDocumentChanged || edit.document !== void 0
+    };
+  }
+  const version = drafts.translations[locale];
+  if (!version) return drafts;
+  const next2 = { ...version, ...edit };
+  return { ...drafts, translations: { ...drafts.translations, [locale]: next2 }, changed: withChanged(drafts.changed, locale) };
+}
+function keepLanguageDocument(drafts, locale, document) {
+  if (locale === null) return { ...drafts, main: { ...drafts.main, document } };
+  const version = drafts.translations[locale];
+  if (!version) return drafts;
+  return { ...drafts, translations: { ...drafts.translations, [locale]: { ...version, document } } };
+}
+function setLanguageStatus(drafts, locale, status) {
+  const version = drafts.translations[locale];
+  if (!version || version.status === status) return drafts;
+  return { ...drafts, translations: { ...drafts.translations, [locale]: { ...version, status } }, changed: withChanged(drafts.changed, locale) };
+}
+function draftsPatch(drafts, loaded) {
+  return buildTemplatePatch({
+    loaded,
+    main: drafts.main,
+    documentChanged: drafts.mainDocumentChanged,
+    translations: drafts.translations,
+    changed: new Set(drafts.changed),
+    removed: new Set(drafts.removed)
+  });
+}
+function draftsDirty(drafts, loaded) {
+  return Object.keys(draftsPatch(drafts, loaded)).length > 0;
+}
+function readyWithoutSubject(drafts) {
+  return Object.entries(drafts.translations).filter(([tag, v]) => drafts.changed.includes(tag) && v.status === "ready" && storedTemplateLine(v.subject) === null).map(([tag]) => tag);
+}
+function rebaseDrafts(sent, now, saved) {
+  const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  let out = draftsFromTemplate(saved);
+  if (now.main.subject !== sent.main.subject) out = editLanguageDraft(out, null, { subject: now.main.subject });
+  if (now.main.preheader !== sent.main.preheader) out = editLanguageDraft(out, null, { preheader: now.main.preheader });
+  out = same(now.main.document, sent.main.document) ? keepLanguageDocument(out, null, now.main.document) : editLanguageDraft(out, null, { document: now.main.document });
+  const tags = /* @__PURE__ */ new Set([...Object.keys(sent.translations), ...Object.keys(now.translations)]);
+  for (const tag of tags) {
+    const before = sent.translations[tag];
+    const after = now.translations[tag];
+    if (same(before, after)) {
+      if (after) out = keepLanguageDocument(out, tag, after.document);
+      continue;
+    }
+    if (!after) {
+      out = removeLanguageDraft(out, tag);
+      continue;
+    }
+    out = {
+      ...out,
+      translations: { ...out.translations, [tag]: after },
+      changed: withChanged(out.changed, tag),
+      removed: without(out.removed, tag)
+    };
+  }
+  return out;
+}
+
 // src/providers.ts
 import { z as z10 } from "zod";
 var PROVIDER_KINDS = ["smtp", "resend"];
@@ -3811,6 +4135,15 @@ var platformRoutes = {
     access: "read",
     phase: "S4"
   },
+  "mailings.languages": {
+    method: "GET",
+    path: "/v1/mailings/:id/languages",
+    params: IdParams,
+    response: MailingLanguageReport,
+    status: 200,
+    access: "read",
+    phase: "S4"
+  },
   "signupForms.list": {
     method: "GET",
     path: "/v1/signup-forms",
@@ -4408,6 +4741,7 @@ export {
   EXPORT_WARNING_COUNT_HEADER,
   Email,
   EmailStep,
+  EmailStepLanguage,
   ErrorBody,
   ErrorCodeSchema,
   Event,
@@ -4459,6 +4793,8 @@ export {
   JsonValue,
   LETTER_RECIPIENT_REFUSAL,
   LIST_UNSUBSCRIBE_POST_VALUE,
+  LOCALE_TAG_PATTERN,
+  LocaleTag,
   MAILING_ACTIONS,
   MAILING_KINDS,
   MAILING_STATUSES,
@@ -4483,12 +4819,15 @@ export {
   MAX_MJML_ELEMENTS,
   MAX_MJML_IMPORT_BYTES,
   MAX_PAGE_LIMIT,
+  MAX_PREHEADER_LENGTH,
   MAX_RECIPIENTS_PER_BATCH,
   MAX_RE_ENTRY_COOLDOWN_SECONDS,
   MAX_SAVED_SECTIONS,
   MAX_SPLIT_BRANCHES,
   MAX_STEPS,
   MAX_STEP_VISITS,
+  MAX_SUBJECT_LENGTH,
+  MAX_TEMPLATE_TRANSLATIONS,
   MAX_TRIGGERS,
   MEMBER_ROLES,
   MERGE_FIELD_PATTERN,
@@ -4506,6 +4845,9 @@ export {
   MailingExportQuery,
   MailingFinishedData,
   MailingKind,
+  MailingLanguage,
+  MailingLanguageReport,
+  MailingLanguageStatus,
   MailingListQuery,
   MailingMetadata,
   MailingRetryFailedRequest,
@@ -4606,6 +4948,7 @@ export {
   SuppressionCreate,
   SuppressionListQuery,
   SuppressionReason,
+  TEMPLATE_LANGUAGE_STATUSES,
   TERMINAL_MAILING_STATUSES,
   Tag,
   TagAssignment,
@@ -4621,8 +4964,13 @@ export {
   TemplateImportPreview,
   TemplateImportPreviewRequest,
   TemplateImportResult,
+  TemplateLanguageStatus,
   TemplateListQuery,
+  TemplatePreheader,
+  TemplateSubject,
   TemplateSummary,
+  TemplateTranslation,
+  TemplateTranslations,
   TemplateUpdate,
   TemplateUpdatedData,
   TemplateVersion,
@@ -4675,14 +5023,22 @@ export {
   WorkspaceSettings,
   WorkspaceUpdate,
   acceptsIdempotencyKey,
+  addLanguageDraft,
   alwaysWaits,
   automationFilterFamily,
   automationRoutes,
   billingRoutes,
   buildPath,
+  buildTemplatePatch,
   canTransition,
+  canonicalLocale,
   cycles,
   defaultSettings,
+  draftDocument,
+  draftsDirty,
+  draftsFromTemplate,
+  draftsPatch,
+  editLanguageDraft,
   emptyFlow,
   errorBody,
   exportFilename,
@@ -4698,6 +5054,10 @@ export {
   isDayEntirelyPast,
   isPublishable,
   isRetryableError,
+  keepLanguageDocument,
+  languageName,
+  languageTabs,
+  matchLocale,
   matchRoute,
   missingRequiredMergeFields,
   nowSeconds,
@@ -4706,12 +5066,19 @@ export {
   parseExportWarningsHeader,
   parseUsageWarningHeader,
   platformRoutes,
+  primaryLanguage,
   reachable,
+  readyWithoutSubject,
+  rebaseDrafts,
+  removeLanguageDraft,
+  restorePatch,
   routes,
   sendingRoutes,
+  setLanguageStatus,
   signWebhook,
   statusForError,
   stepTargets,
+  storedTemplateLine,
   stronglyConnected,
   templateRoutes,
   testGroupSize,

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "The v1 API contract of the mail service: zod schemas and types for every request, response, error and webhook, the route table, and webhook signing helpers",
   "license": "MIT",
   "repository": {