@saasicat/core 1.0.0-rc.25 → 1.0.0-rc.26

package/dist/index.js

@@ -157,6 +157,22 @@ function computeIncludedVat(gross, vatRate) {
   const rate = exactDecimal(vatRate);
   return amountOf(cents(exactDecimal(gross), rate, sum(HUNDRED, rate)));
 }
+function taxPerRate(lines) {
+  const nets = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const key = String(line.rate);
+    const entry = nets.get(key) ?? { rate: line.rate, terms: [] };
+    entry.terms.push(line.net);
+    nets.set(key, entry);
+  }
+  const rates = [...nets.values()].sort((a, b) => a.rate - b.rate).map(({ rate, terms }) => {
+    const net2 = sumToCents(...terms);
+    return { rate, net: net2, tax: percentOf(net2, rate) };
+  });
+  const net = sumToCents(...rates.map((entry) => entry.net));
+  const tax = sumToCents(...rates.map((entry) => entry.tax));
+  return { rates, net, tax, gross: sumToCents(net, tax) };
+}
 
 // src/promotion.types.ts
 function promoStatus(promo, today = /* @__PURE__ */ new Date()) {
@@ -407,7 +423,10 @@ var KINDS = {
   "version-retirement-reminder": true,
   "bundle-version-retired": true,
   "bundle-version-retirement-reminder": true,
-  "bundle-version-offered": true
+  "bundle-version-offered": true,
+  "feature-withdrawn": true,
+  "feature-withdrawal-lifted": true,
+  "ended-at-once": true
 };
 function toSubscriptionNoticeRecord(row) {
   return {
@@ -538,6 +557,106 @@ function toBundleVersionRetirementRecord(row) {
   };
 }
 
+// src/feature-withdrawal.types.ts
+var FEATURE_WITHDRAWAL_REASON_MAX_LENGTH = 1e3;
+function isFeatureWithdrawnAt(withdrawal, at) {
+  return withdrawal.effectiveFrom <= at && (withdrawal.liftedFrom === null || at < withdrawal.liftedFrom);
+}
+function featuresWithdrawnAt(withdrawals, at) {
+  return new Set(
+    withdrawals.filter((withdrawal) => isFeatureWithdrawnAt(withdrawal, at)).map((withdrawal) => withdrawal.featureKey)
+  );
+}
+function nextWithdrawalChange(withdrawals, at) {
+  let next = null;
+  for (const { effectiveFrom, liftedFrom } of withdrawals) {
+    for (const moment of [effectiveFrom, liftedFrom]) {
+      if (moment === null || moment <= at) continue;
+      if (next === null || moment < next) next = moment;
+    }
+  }
+  return next;
+}
+var FEATURE_WITHDRAWAL_CAPABILITY = "features.withdraw";
+function featureWithdrawalRowOf(record) {
+  return {
+    id: record.id,
+    featureKey: record.featureKey,
+    reason: record.reason,
+    effectiveFrom: record.effectiveFrom.toISOString(),
+    liftedFrom: record.liftedFrom?.toISOString() ?? null,
+    reductions: record.reductions,
+    announcedAt: record.announcedAt.toISOString(),
+    announcedBy: record.announcedBy,
+    liftedAt: record.liftedAt?.toISOString() ?? null,
+    liftedBy: record.liftedBy,
+    toldAt: record.toldAt?.toISOString() ?? null
+  };
+}
+function withdrawnFeaturesOf(withdrawals, now) {
+  return withdrawals.filter(
+    ({ effectiveFrom, liftedFrom }) => liftedFrom === null || liftedFrom > now && effectiveFrom < liftedFrom
+  ).sort((a, b) => a.effectiveFrom.getTime() - b.effectiveFrom.getTime()).map((withdrawal) => ({
+    featureKey: withdrawal.featureKey,
+    reason: withdrawal.reason,
+    effectiveFrom: withdrawal.effectiveFrom.toISOString(),
+    liftedFrom: withdrawal.liftedFrom?.toISOString() ?? null
+  }));
+}
+function endedAtOnceSubjectOf(subscriptionOrBookingId, at) {
+  return `${subscriptionOrBookingId}@${at.toISOString()}`;
+}
+
+// src/feature-withdrawal-mapping.ts
+var TABLE2 = "feature_withdrawals";
+var KINDS2 = { plan: true, bundle: true };
+var CYCLES = { MONTHLY: true, YEARLY: true };
+function toFeatureWithdrawalRecord(row) {
+  return {
+    id: row.id,
+    featureKey: row.featureKey,
+    reason: row.reason,
+    effectiveFrom: row.effectiveFrom,
+    liftedFrom: row.liftedFrom,
+    reductions: reductionsOf(row),
+    announcedAt: row.announcedAt,
+    announcedBy: row.announcedBy,
+    liftedAt: row.liftedAt,
+    liftedBy: row.liftedBy,
+    toldAt: row.toldAt
+  };
+}
+function reductionsOf(row) {
+  if (!Array.isArray(row.reductions)) {
+    throw new Error(`${TABLE2} row '${row.id}' holds reductions that are not a list.`);
+  }
+  return row.reductions.map((entry, index) => {
+    const column = `reductions[${index}]`;
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`${TABLE2} row '${row.id}' holds ${column} that is not an object.`);
+    }
+    const { kind, key, billingCycle, amountNet } = entry;
+    if (typeof kind !== "string" || typeof key !== "string" || typeof billingCycle !== "string" || typeof amountNet !== "number" || !Number.isFinite(amountNet)) {
+      throw new Error(
+        `${TABLE2} row '${row.id}' holds ${column} without a kind, a key, a billing cycle and a finite amount.`
+      );
+    }
+    const source = { table: TABLE2, id: row.id };
+    return {
+      kind: oneOf(Object.keys(KINDS2), kind, {
+        ...source,
+        column: `${column}.kind`
+      }),
+      key,
+      billingCycle: oneOf(Object.keys(CYCLES), billingCycle, {
+        ...source,
+        column: `${column}.billingCycle`
+      }),
+      amountNet
+    };
+  });
+}
+
 // src/scheduled-change-after-write.ts
 var NO_SCHEDULED_CHANGE = {
   pendingPlan: null,
@@ -674,6 +793,37 @@ function parseZonedInstant(text) {
   return Number.isNaN(moment.getTime()) ? null : moment;
 }
 
+// src/zoned-day.ts
+function dayInZone(at, timeZone) {
+  if (typeof timeZone !== "string" || timeZone === "") {
+    throw new RangeError("A day is read in a named time zone.");
+  }
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(at);
+  const part = (type) => parts.find((candidate) => candidate.type === type)?.value;
+  return `${part("year")}-${part("month")}-${part("day")}`;
+}
+function lastDayInZone(period, timeZone) {
+  if (!(period.until.getTime() > period.from.getTime())) {
+    throw new RangeError("A period ends after it begins.");
+  }
+  return dayInZone(new Date(period.until.getTime() - 1), timeZone);
+}
+function addDaysToDay(day, days) {
+  if (!Number.isInteger(days)) throw new RangeError("Days are counted in whole days.");
+  const [year, month, date] = day.split("-").map(Number);
+  if (!year || !month || !date) throw new RangeError(`${day} is not a day.`);
+  const moved = new Date(Date.UTC(year, month - 1, date + days));
+  return moved.toISOString().slice(0, 10);
+}
+function yearOfDay(day) {
+  return Number(day.slice(0, 4));
+}
+
 // src/settings-subtree.ts
 var CATALOGUE_KEYS = /* @__PURE__ */ new Set([
   "schemaVersion",
@@ -1131,6 +1281,80 @@ var BILLING_ERROR_CODES = {
    * show it instead of guessing.
    */
   BUNDLE_VERSION_OFFER_CHANGED: "BUNDLE_VERSION_OFFER_CHANGED",
+  // ── withdrawing a feature for an external reason ──
+  /**
+   * Withdrawing a feature is not offered: the installation's stores cannot
+   * list everybody a withdrawal would reach.
+   */
+  FEATURE_WITHDRAWAL_UNAVAILABLE: "FEATURE_WITHDRAWAL_UNAVAILABLE",
+  /** The catalogue knows no feature of that key, so there is nothing to withdraw. Carries `featureKey`. */
+  FEATURE_WITHDRAWAL_FEATURE_UNKNOWN: "FEATURE_WITHDRAWAL_FEATURE_UNKNOWN",
+  /**
+   * The date names a moment before now. A feature is withdrawn from the
+   * moment it is announced or from a later date: the days before were
+   * delivered.
+   */
+  FEATURE_WITHDRAWAL_DATE_IN_PAST: "FEATURE_WITHDRAWAL_DATE_IN_PAST",
+  /** A withdrawal of the feature is not lifted yet; one at a time. Carries `featureKey`. */
+  FEATURE_WITHDRAWAL_OPEN: "FEATURE_WITHDRAWAL_OPEN",
+  /**
+   * A withdrawal of the feature is lifted only from a date after the one
+   * named, so the two would overlap. Carries `featureKey` and the `date` a
+   * new one may begin on.
+   */
+  FEATURE_WITHDRAWAL_OVERLAPS: "FEATURE_WITHDRAWAL_OVERLAPS",
+  /**
+   * A reduction names a plan or an add-on, in a rhythm, that no line the
+   * withdrawal reaches is. Carries `kind`, `key` and `billingCycle`.
+   */
+  FEATURE_WITHDRAWAL_REDUCTION_NOT_REACHED: "FEATURE_WITHDRAWAL_REDUCTION_NOT_REACHED",
+  /** A reduction is named twice. Carries `kind`, `key` and `billingCycle`. */
+  FEATURE_WITHDRAWAL_REDUCTION_NAMED_TWICE: "FEATURE_WITHDRAWAL_REDUCTION_NAMED_TWICE",
+  /**
+   * A reduction is more than the lowest price among the lines it reduces:
+   * a price is reduced to nothing at most. Carries `key`, `billingCycle` and
+   * that `price`.
+   */
+  FEATURE_WITHDRAWAL_REDUCTION_EXCEEDS_PRICE: "FEATURE_WITHDRAWAL_REDUCTION_EXCEEDS_PRICE",
+  /**
+   * The subscriptions the withdrawal reaches changed since the preview the
+   * operator looked at. Nothing was announced; carries the current `preview`.
+   */
+  FEATURE_WITHDRAWAL_PREVIEW_CHANGED: "FEATURE_WITHDRAWAL_PREVIEW_CHANGED",
+  /** No withdrawal has that id. Carries `withdrawalId`. */
+  FEATURE_WITHDRAWAL_NOT_FOUND: "FEATURE_WITHDRAWAL_NOT_FOUND",
+  /** The withdrawal was lifted already. Carries the `date` it is lifted from. */
+  FEATURE_WITHDRAWAL_ALREADY_LIFTED: "FEATURE_WITHDRAWAL_ALREADY_LIFTED",
+  /**
+   * Nobody the withdrawal reaches has been told of it yet, and telling them
+   * failed just now: a withdrawal is lifted only once they were. Nothing was
+   * lifted; the next try, or the quarter-hourly run, tells them first.
+   */
+  FEATURE_WITHDRAWAL_NOT_TOLD_YET: "FEATURE_WITHDRAWAL_NOT_TOLD_YET",
+  /**
+   * The date a withdrawal would be lifted from lies before now: what was
+   * withdrawn until then was withdrawn.
+   */
+  FEATURE_WITHDRAWAL_LIFT_IN_PAST: "FEATURE_WITHDRAWAL_LIFT_IN_PAST",
+  /**
+   * The withdrawal does not take its feature away now — its date is ahead,
+   * or it was lifted — so nothing ends at once because of it. Carries
+   * `featureKey`.
+   */
+  FEATURE_WITHDRAWAL_NOT_IN_EFFECT: "FEATURE_WITHDRAWAL_NOT_IN_EFFECT",
+  /**
+   * The withdrawal did not reach the subscription, or the line to end: it
+   * was not running at the announcement, or no longer holds the feature.
+   */
+  FEATURE_WITHDRAWAL_DOES_NOT_REACH: "FEATURE_WITHDRAWAL_DOES_NOT_REACH",
+  /** What was to be ended at once has ended already. */
+  FEATURE_WITHDRAWAL_ALREADY_ENDED: "FEATURE_WITHDRAWAL_ALREADY_ENDED",
+  /**
+   * A cancellation is declared for a later date, and the installation's
+   * subscription write or booking store cannot bring it forward (`endNow`).
+   * It ends as declared. Carries that `date`.
+   */
+  FEATURE_WITHDRAWAL_END_NOW_UNSUPPORTED: "FEATURE_WITHDRAWAL_END_NOW_UNSUPPORTED",
   // ── the preview routes' own blockers and warnings ──
   //
   // These travel inside a 200 response, in `blockers[]` and `warnings[]`, not
@@ -1288,6 +1512,55 @@ var CONTRACT_ERROR_CODES = {
    */
   SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED"
 };
+var INVOICE_ERROR_CODES = {
+  /**
+   * A charge already stands on an invoice: a second run issuing the same
+   * charges lost the race. Nothing is written and no number is drawn.
+   */
+  SUBSCRIPTION_INVOICE_CHARGE_INVOICED: "SUBSCRIPTION_INVOICE_CHARGE_INVOICED",
+  /**
+   * The invoice lacks content the tax adapter requires of it — `missing`
+   * names the fields, `adapter` the adapter. It draws no number and waits
+   * until what is missing is supplied (`SC-PRIC-027`).
+   */
+  SUBSCRIPTION_INVOICE_CONTENT_INCOMPLETE: "SUBSCRIPTION_INVOICE_CONTENT_INCOMPLETE",
+  /**
+   * The contract's parties were copied by a migration and the operator has
+   * not confirmed them yet; its charges are not invoiced until then
+   * (`SC-AUD-012`).
+   */
+  SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED: "SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED",
+  /**
+   * A file of the invoice's document has another checksum than the one
+   * recorded or archived for it (`invoiceId`, `recorded`, `rendered`), and
+   * the first stays. The run takes the archived file as the one issued, or —
+   * where nothing is archived — records the new rendering in place of the
+   * old (`SC-AUD-019`); the invoice waits only where another run changed the
+   * record or the archive in between, and the next run settles it.
+   */
+  SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED: "SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED",
+  /**
+   * The tax adapter refuses the rendered document — `missing` names what it
+   * lacks or disagrees with, `adapter` the adapter. The invoice keeps its
+   * number and waits for a document that passes (`SC-PRIC-042`).
+   */
+  SUBSCRIPTION_INVOICE_DOCUMENT_REFUSED: "SUBSCRIPTION_INVOICE_DOCUMENT_REFUSED",
+  /**
+   * The archived document does not match the checksum recorded when it was
+   * rendered (`invoiceId`). It is not handed out (`SC-AUD-019`).
+   */
+  SUBSCRIPTION_INVOICE_DOCUMENT_MISMATCH: "SUBSCRIPTION_INVOICE_DOCUMENT_MISMATCH",
+  /** The invoice's document is not archived yet (`invoiceId`); nothing is offered until it is (`SC-AUD-014`). */
+  SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED: "SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED",
+  /** No invoice with this id (`invoiceId`). */
+  SUBSCRIPTION_INVOICE_NOT_FOUND: "SUBSCRIPTION_INVOICE_NOT_FOUND",
+  /**
+   * The subscriber's record holds no invoice email (`subscriberId`), so the
+   * archived invoice cannot be sent (`SC-PRIC-047`); it is sent once one is
+   * entered.
+   */
+  SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL"
+};
 var SUBSCRIBER_ERROR_CODES = {
   /**
    * A contract, a plan change or a booking for a tenant that has no
@@ -1468,6 +1741,7 @@ var PLATFORM_ERROR_CODES = {
   ...CATALOG_ERROR_CODES,
   ...BILLING_ERROR_CODES,
   ...CONTRACT_ERROR_CODES,
+  ...INVOICE_ERROR_CODES,
   ...SUBSCRIBER_ERROR_CODES,
   ...REGISTRATION_ERROR_CODES,
   ...PAYMENT_ERROR_CODES,
@@ -1521,7 +1795,13 @@ var OPTIONAL_CANONICAL_MODELS = {
   SubscriptionNotice: ["tenantBilling.subscriptionNotices"],
   VersionRetirement: ["tenantBilling.versionRetirements"],
   BundleVersionRetirement: ["tenantBilling.bundleVersionRetirements"],
+  FeatureWithdrawal: ["tenantBilling.featureWithdrawals"],
   SubscriberLedgerEntry: ["entitlement.subscriberLedgerRepository"],
+  SubscriptionInvoice: ["entitlement.subscriptionInvoiceRepository"],
+  SubscriptionInvoiceLine: ["entitlement.subscriptionInvoiceRepository"],
+  SubscriptionInvoiceNumber: ["entitlement.subscriptionInvoiceRepository"],
+  SubscriptionInvoiceDocument: ["entitlement.subscriptionInvoiceRepository"],
+  SubscriptionInvoiceArchive: ["entitlement.subscriptionInvoiceArchive"],
   PromoCodeHold: ["promo.holdRepository"]
 };
 function membersLeftOut(notAdopted = []) {
@@ -1704,6 +1984,23 @@ var ERROR_MESSAGES_EN = {
   BUNDLE_RETIREMENT_REINSTATE_SUBSCRIPTION_ENDS: "Version {version} of {bundleKey} is being retired, and this booking ends before it would move. Your subscription ends by then as well.",
   BUNDLE_RETIREMENT_SWITCH_PLAN_CHANGES: "{bundleName} moves to its new version on {date}, and your plan changes before then, so the price a switch would keep is not known yet. Switch once your plan has changed, or let it move on that date.",
   BUNDLE_VERSION_OFFER_CHANGED: "The offer changed since it was shown. Look at the current one before switching.",
+  FEATURE_WITHDRAWAL_UNAVAILABLE: "Withdrawing a feature is not offered here: the stores cannot list everybody a withdrawal reaches.",
+  FEATURE_WITHDRAWAL_FEATURE_UNKNOWN: "The catalogue knows no feature {featureKey}.",
+  FEATURE_WITHDRAWAL_DATE_IN_PAST: "A feature is withdrawn from now on or from a later date, never from a date already past.",
+  FEATURE_WITHDRAWAL_OPEN: "{featureKey} is withdrawn already, and that withdrawal is not lifted. Lift it before announcing another.",
+  FEATURE_WITHDRAWAL_OVERLAPS: "{featureKey} is withdrawn until {date}. Another withdrawal can begin on that date at the earliest.",
+  FEATURE_WITHDRAWAL_REDUCTION_NOT_REACHED: "The reduction for {key} billed {billingCycle} names nothing this withdrawal reaches.",
+  FEATURE_WITHDRAWAL_REDUCTION_NAMED_TWICE: "The reduction for {key} billed {billingCycle} is named twice.",
+  FEATURE_WITHDRAWAL_REDUCTION_EXCEEDS_PRICE: "The reduction for {key} billed {billingCycle} is more than the lowest price it reduces, {price}.",
+  FEATURE_WITHDRAWAL_PREVIEW_CHANGED: "The subscriptions this withdrawal reaches changed since they were shown. Look at them again before announcing it.",
+  FEATURE_WITHDRAWAL_NOT_FOUND: "Feature withdrawal {withdrawalId} not found.",
+  FEATURE_WITHDRAWAL_ALREADY_LIFTED: "This withdrawal is lifted already, from {date}.",
+  FEATURE_WITHDRAWAL_NOT_TOLD_YET: "Nobody has been told of this withdrawal yet, and it is not lifted before they are. Try again in a moment.",
+  FEATURE_WITHDRAWAL_LIFT_IN_PAST: "A withdrawal is lifted from now on or from a later date, never from a date already past.",
+  FEATURE_WITHDRAWAL_NOT_IN_EFFECT: "{featureKey} is not withdrawn now, so nothing can be ended at once because of it.",
+  FEATURE_WITHDRAWAL_DOES_NOT_REACH: "This withdrawal does not reach your subscription, or no longer this booking.",
+  FEATURE_WITHDRAWAL_ALREADY_ENDED: "This has ended already.",
+  FEATURE_WITHDRAWAL_END_NOW_UNSUPPORTED: "Your cancellation for {date} is recorded, and it cannot be brought forward here. It ends on that date, and until then the reduction applies.",
   RETIREMENT_SWITCH_NOT_PENDING: "No retirement of your version is waiting for its date, so there is nothing to switch to.",
   RETIREMENT_SWITCH_IN_TRIAL: "The switch opens when your trial ends.",
   RETIREMENT_SWITCH_BUNDLE_CANNOT_FOLLOW: "{bundleName} cannot run on {planName} and runs until {until} at the earliest. Once it is cancelled, the switch can be made from that day.",
@@ -1746,6 +2043,15 @@ var ERROR_MESSAGES_EN = {
   PROMO_MAX_REDEMPTIONS_LOWERED: "maxRedemptions cannot be lowered.",
   // ── contract ──
   SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "The contract states {stated} % in {field}, and the tax adapter decides {decided} %.",
+  SUBSCRIPTION_INVOICE_CHARGE_INVOICED: "Charge '{chargeId}' already stands on an invoice.",
+  SUBSCRIPTION_INVOICE_CONTENT_INCOMPLETE: "The invoice lacks what the tax adapter {adapter} requires of it: {missing}. It is issued once that is supplied.",
+  SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED: "Contract {contractId} names no confirmed issuer and subscriber \u2014 a migration copied its parties, or it names no issuer \u2014 so its charges are not invoiced.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED: "The document of invoice {invoiceId} differs from the one recorded or archived for it ({rendered} instead of {recorded}); the first stays, and the next run settles which one the invoice keeps.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_REFUSED: "The tax adapter {adapter} refuses the rendered invoice: {missing}. The invoice keeps its number and waits for a document that passes.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_MISMATCH: "The archived document of invoice {invoiceId} does not match the checksum recorded when it was rendered, and is not handed out.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED: "The document of invoice {invoiceId} is not archived yet.",
+  SUBSCRIPTION_INVOICE_NOT_FOUND: "No invoice '{invoiceId}'.",
+  SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "Subscriber {subscriberId} has no invoice email, so its invoice cannot be sent; it is sent once one is entered.",
   CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "A checkout offer can yield only one contract, and only once its line items are frozen.",
   CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "A checkout offer requires a frozen plan line item.",
   CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Every selected bundle version requires a frozen bundle line item.",
@@ -2188,17 +2494,20 @@ var ORIGINS = {
   bundleBooking: true,
   bundleChange: true,
   credit: true,
-  correction: true
+  correction: true,
+  reductionTakenBack: true
 };
 var SOURCES = {
   plan: true,
   bundle: true,
   discount: true
 };
-var TABLE2 = "subscriber_ledger_entries";
+var SUBSCRIBER_CHARGE_ORIGINS = keysOf(ORIGINS);
+var SUBSCRIBER_CHARGE_SOURCES = keysOf(SOURCES);
+var TABLE3 = "subscriber_ledger_entries";
 var CENT_TOLERANCE = 1e-6;
 function toSubscriberChargeRecord(row) {
-  const where = (column) => ({ table: TABLE2, column, id: row.id });
+  const where = (column) => ({ table: TABLE3, column, id: row.id });
   return {
     id: row.id,
     subscriberId: row.subscriberId,
@@ -2206,8 +2515,8 @@ function toSubscriberChargeRecord(row) {
     subscriptionId: row.subscriptionId,
     contractId: row.contractId,
     contractLineItemId: row.contractLineItemId,
-    origin: oneOf(keysOf(ORIGINS), row.origin, where("origin")),
-    source: oneOf(keysOf(SOURCES), row.source, where("source")),
+    origin: oneOf(SUBSCRIBER_CHARGE_ORIGINS, row.origin, where("origin")),
+    source: oneOf(SUBSCRIBER_CHARGE_SOURCES, row.source, where("source")),
     sourceRef: row.sourceRef,
     periodStart: row.periodStart,
     periodEnd: row.periodEnd,
@@ -2247,6 +2556,15 @@ function keysOf(record) {
 // src/subscriber-ledger.types.ts
 var SUBSCRIBER_ACCOUNT_CAPABILITY = "charges.read";
 
+// src/subscription-invoice.types.ts
+var INVOICE_SEQUENCE_DIGITS = 6;
+function formatInvoiceNumber(prefix, year, sequence) {
+  if (!Number.isInteger(sequence) || sequence < 1) {
+    throw new RangeError(`An invoice number's sequence starts at 1; ${sequence} is not one.`);
+  }
+  return `${prefix}-${year}-${String(sequence).padStart(INVOICE_SEQUENCE_DIGITS, "0")}`;
+}
+
 // src/subscriber.types.ts
 var SUBSCRIBER_INVOICE_ADDRESS_FIELDS = [
   "addressLine1",
@@ -2378,6 +2696,420 @@ function textEntries(value) {
   return entries;
 }
 
+// src/subscription-invoice-mapping.ts
+var INVOICES = "subscription_invoices";
+var LINES = "subscription_invoice_lines";
+var CENT_TOLERANCE2 = 1e-6;
+function toSubscriptionInvoiceRecord(row, lines) {
+  const where = (column) => ({ table: INVOICES, column, id: row.id });
+  const treatment = toTaxTreatment(row.taxTreatment);
+  if (!treatment) {
+    throw new Error(`${INVOICES}.taxTreatment of ${row.id} is not a tax treatment.`);
+  }
+  return {
+    id: row.id,
+    number: row.number,
+    numberPrefix: row.numberPrefix,
+    numberYear: row.numberYear,
+    numberSequence: row.numberSequence,
+    tenantId: row.tenantId,
+    subscriberId: row.subscriberId,
+    subscriptionId: row.subscriptionId,
+    contractId: row.contractId,
+    issuedAt: row.issuedAt,
+    issueDate: dayOf2(row.issueDate, where("issueDate")),
+    dueDate: dayOf2(row.dueDate, where("dueDate")),
+    servicePeriodFrom: dayOf2(row.servicePeriodFrom, where("servicePeriodFrom")),
+    servicePeriodUntil: dayOf2(row.servicePeriodUntil, where("servicePeriodUntil")),
+    currency: row.currency,
+    issuer: issuerOf(row.issuerParty, where("issuerParty")),
+    subscriber: subscriberOf(row.subscriberParty, where("subscriberParty")),
+    footer: footerOf(row.footer, where("footer")),
+    taxTreatment: treatment,
+    taxes: taxesOf(row.taxes, where("taxes")),
+    totalNet: amountOf2(row.totalNet, where("totalNet")),
+    totalTax: amountOf2(row.totalTax, where("totalTax")),
+    totalGross: amountOf2(row.totalGross, where("totalGross")),
+    lines: [...lines].sort((a, b) => a.position - b.position).map((line) => toSubscriptionInvoiceLineRecord(line)),
+    createdAt: row.createdAt
+  };
+}
+function toSubscriptionInvoiceLineRecord(row) {
+  const where = (column) => ({ table: LINES, column, id: row.id });
+  return {
+    id: row.id,
+    invoiceId: row.invoiceId,
+    position: row.position,
+    chargeId: row.chargeId,
+    contractLineItemId: row.contractLineItemId,
+    title: row.title,
+    origin: oneOf(SUBSCRIBER_CHARGE_ORIGINS, row.origin, where("origin")),
+    source: oneOf(SUBSCRIBER_CHARGE_SOURCES, row.source, where("source")),
+    periodFrom: dayOf2(row.periodFrom, where("periodFrom")),
+    periodUntil: dayOf2(row.periodUntil, where("periodUntil")),
+    amountNet: amountOf2(row.amountNet, where("amountNet")),
+    taxRate: amountOf2(row.taxRate, where("taxRate"))
+  };
+}
+function subscriptionInvoiceColumns(invoice, drawn) {
+  return {
+    number: drawn.number,
+    numberPrefix: invoice.numberPrefix,
+    numberYear: invoice.numberYear,
+    numberSequence: drawn.numberSequence,
+    tenantId: invoice.tenantId,
+    subscriberId: invoice.subscriberId,
+    subscriptionId: invoice.subscriptionId,
+    contractId: invoice.contractId,
+    issuedAt: invoice.issuedAt,
+    issueDate: invoice.issueDate,
+    dueDate: invoice.dueDate,
+    servicePeriodFrom: invoice.servicePeriodFrom,
+    servicePeriodUntil: invoice.servicePeriodUntil,
+    currency: invoice.currency,
+    issuerParty: { ...invoice.issuer },
+    subscriberParty: { ...invoice.subscriber },
+    footer: [...invoice.footer],
+    taxTreatment: taxTreatmentToJson(invoice.taxTreatment),
+    taxes: invoice.taxes.map((entry) => ({ rate: entry.rate, net: entry.net, tax: entry.tax })),
+    totalNet: centsText(invoice.totalNet, "totalNet"),
+    totalTax: centsText(invoice.totalTax, "totalTax"),
+    totalGross: centsText(invoice.totalGross, "totalGross")
+  };
+}
+function subscriptionInvoiceLineColumns(line, invoiceId) {
+  return {
+    invoiceId,
+    position: line.position,
+    chargeId: line.chargeId,
+    contractLineItemId: line.contractLineItemId,
+    title: line.title,
+    origin: line.origin,
+    source: line.source,
+    periodFrom: line.periodFrom,
+    periodUntil: line.periodUntil,
+    amountNet: centsText(line.amountNet, "amountNet"),
+    taxRate: centsText(line.taxRate, "taxRate")
+  };
+}
+function utcMidnightOf(day) {
+  return /* @__PURE__ */ new Date(`${day}T00:00:00.000Z`);
+}
+var DAY_LENGTH = "YYYY-MM-DD".length;
+function dayOf2(value, where) {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString().slice(0, DAY_LENGTH);
+  }
+  if (typeof value === "string" && value.length === DAY_LENGTH && !Number.isNaN(Date.parse(value))) {
+    return value;
+  }
+  throw new Error(`${where.table}.${where.column} of ${where.id} is not a day.`);
+}
+function footerOf(value, where) {
+  if (!Array.isArray(value) || !value.every((line) => typeof line === "string")) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} is not a list of lines.`);
+  }
+  return [...value];
+}
+function amountOf2(value, where) {
+  const amount = Number(value === null || value === void 0 ? NaN : String(value));
+  if (!Number.isFinite(amount)) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} is not an amount.`);
+  }
+  return amount;
+}
+function centsText(amount, field) {
+  const cents2 = amount * 100;
+  if (!Number.isFinite(cents2) || Math.abs(cents2 - Math.round(cents2)) > CENT_TOLERANCE2) {
+    throw new Error(
+      `An invoice's ${field} of ${amount} is not a whole number of cents; it is rounded once, where the invoice is drafted, before it is written.`
+    );
+  }
+  return amount.toFixed(2);
+}
+function textOrNull2(source, key, where) {
+  const value = source[key];
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "string") {
+    throw new Error(`${where.table}.${where.column}.${key} of ${where.id} is not text.`);
+  }
+  return value;
+}
+function partyOf(value, where) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} is not a party.`);
+  }
+  const source = value;
+  const legalName = textOrNull2(source, "legalName", where);
+  if (legalName === null) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} names no legal name.`);
+  }
+  return {
+    legalName,
+    vatId: textOrNull2(source, "vatId", where),
+    taxNumber: textOrNull2(source, "taxNumber", where),
+    addressLine1: textOrNull2(source, "addressLine1", where),
+    addressLine2: textOrNull2(source, "addressLine2", where),
+    postalCode: textOrNull2(source, "postalCode", where),
+    city: textOrNull2(source, "city", where),
+    country: textOrNull2(source, "country", where)
+  };
+}
+function issuerOf(value, where) {
+  return partyOf(value, where);
+}
+function subscriberOf(value, where) {
+  const party = partyOf(value, where);
+  const customerNumber = textOrNull2(value, "customerNumber", where);
+  if (customerNumber === null) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} names no customer number.`);
+  }
+  return { ...party, customerNumber };
+}
+function taxesOf(value, where) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} is not a list of rates.`);
+  }
+  return value.map((entry) => {
+    const item = entry ?? {};
+    return {
+      rate: amountOf2(item.rate, where),
+      net: amountOf2(item.net, where),
+      tax: amountOf2(item.tax, where)
+    };
+  });
+}
+
+// src/subscription-invoice-refusals.ts
+function subscriptionInvoiceChargeInvoiced(chargeId) {
+  return new PersistenceRefusal(
+    INVOICE_ERROR_CODES.SUBSCRIPTION_INVOICE_CHARGE_INVOICED,
+    "moved",
+    `Charge '${chargeId}' already stands on an invoice.`,
+    { chargeId }
+  );
+}
+function subscriptionInvoiceDocumentChanged(invoiceId, recorded, rendered) {
+  return new PersistenceRefusal(
+    INVOICE_ERROR_CODES.SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED,
+    "moved",
+    `The document rendered for invoice '${invoiceId}' differs from the one recorded for it.`,
+    { invoiceId, recorded, rendered }
+  );
+}
+
+// src/subscription-invoice-draft.ts
+function invoiceGroupsOf(charges) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const charge of charges) {
+    const key = `${charge.contractId}|${charge.bookedAt.toISOString()}`;
+    const group = groups.get(key);
+    if (group) group.charges.push(charge);
+    else
+      groups.set(key, {
+        contractId: charge.contractId,
+        bookedAt: charge.bookedAt,
+        charges: [charge]
+      });
+  }
+  return [...groups.values()].filter((group) => group.charges.some((charge) => charge.amountNet !== 0)).sort(
+    (a, b) => a.bookedAt.getTime() - b.bookedAt.getTime() || a.contractId.localeCompare(b.contractId)
+  );
+}
+function draftSubscriptionInvoice(input) {
+  const { group, treatment, timeZone } = input;
+  const lines = linesOf(input);
+  const issueDate = dayInZone(input.issuedAt, timeZone);
+  const tax = input.tax(lines.map((line) => ({ net: line.amountNet, rate: line.taxRate })));
+  return {
+    numberPrefix: input.numberPrefix,
+    numberYear: yearOfDay(issueDate),
+    tenantId: input.tenantId,
+    subscriberId: input.subscriberId,
+    subscriptionId: group.charges[0].subscriptionId,
+    contractId: group.contractId,
+    issuedAt: input.issuedAt,
+    issueDate,
+    dueDate: addDaysToDay(issueDate, input.paymentTermDays),
+    servicePeriodFrom: lines.map((line) => line.periodFrom).sort()[0],
+    servicePeriodUntil: lines.map((line) => line.periodUntil).sort().at(-1),
+    currency: currencyOf(group),
+    issuer: input.issuer,
+    subscriber: input.subscriber,
+    footer: [...input.footer],
+    taxTreatment: treatment,
+    taxes: tax.rates,
+    totalNet: tax.net,
+    totalTax: tax.tax,
+    totalGross: tax.gross,
+    lines
+  };
+}
+function invoiceContentDraftOf(invoice) {
+  return {
+    issuer: invoice.issuer,
+    subscriber: invoice.subscriber,
+    treatment: invoice.taxTreatment,
+    issueDate: invoice.issueDate,
+    dueDate: invoice.dueDate,
+    servicePeriod: { from: invoice.servicePeriodFrom, until: invoice.servicePeriodUntil },
+    lines: invoice.lines.map((line) => ({
+      title: line.title,
+      net: line.amountNet,
+      rate: line.taxRate
+    }))
+  };
+}
+function linesOf(input) {
+  const placeOf = new Map(input.contractLines.map((line, index) => [line.id, index]));
+  const place = (charge) => {
+    const index = placeOf.get(charge.contractLineItemId);
+    if (index === void 0) {
+      throw new Error(
+        `Charge ${charge.id} names contract line ${charge.contractLineItemId}, which contract ${input.group.contractId} does not have.`
+      );
+    }
+    return index;
+  };
+  return [...input.group.charges].sort(
+    (a, b) => place(a) - place(b) || a.periodStart.getTime() - b.periodStart.getTime() || a.origin.localeCompare(b.origin)
+  ).map((charge, index) => ({
+    position: index + 1,
+    chargeId: charge.id,
+    contractLineItemId: charge.contractLineItemId,
+    title: input.contractLines[place(charge)].titleSnapshot,
+    origin: charge.origin,
+    source: charge.source,
+    periodFrom: dayInZone(charge.periodStart, input.timeZone),
+    periodUntil: lastDayInZone(
+      { from: charge.periodStart, until: charge.periodEnd },
+      input.timeZone
+    ),
+    amountNet: charge.amountNet,
+    taxRate: input.treatment.rate
+  }));
+}
+function currencyOf(group) {
+  const currencies = new Set(group.charges.map((charge) => charge.currency));
+  if (currencies.size !== 1) {
+    throw new Error(
+      `The charges of contract ${group.contractId} booked at ${group.bookedAt.toISOString()} are in ${[...currencies].join(" and ")}; an invoice is in one currency.`
+    );
+  }
+  return [...currencies][0];
+}
+
+// src/invoice-issuer.ts
+function invoiceIssuerOf(copy, configured, history) {
+  const target = configured && identityOf2(configured);
+  let reached = identityOf2(copy);
+  if (!target || !reached) return { ...copy };
+  for (const step of history) {
+    if (sameLegalIdentity(reached, target)) break;
+    const change = classifyIssuerChange(
+      recordedIssuerIdentity(step.previous),
+      issuerBlockOf(step.current)
+    );
+    if (change.kind === "corrected" && sameLegalIdentity(change.recorded, reached)) {
+      reached = change.current;
+    }
+  }
+  return sameLegalIdentity(reached, target) ? { ...configured } : { ...copy };
+}
+function invoiceFooterOf(issuer, configured, footer) {
+  const named = identityOf2(issuer);
+  const target = configured && identityOf2(configured);
+  return named && target && sameLegalIdentity(named, target) ? [...footer] : [];
+}
+function identityOf2(party) {
+  return recordedIssuerIdentity({ issuer: party });
+}
+function issuerBlockOf(values) {
+  const issuer = values.issuer;
+  if (issuer === null || typeof issuer !== "object" || Array.isArray(issuer)) return void 0;
+  return issuer;
+}
+
+// src/invoice-document.types.ts
+var INVOICE_DOCUMENT_CAPABILITY = "invoices.read";
+
+// src/invoice-document-mapping.ts
+var DOCUMENTS = "subscription_invoice_documents";
+var ARCHIVE = "subscription_invoice_archive";
+var CHECKSUM = /^[0-9a-f]{64}$/;
+function isInvoiceDocumentChecksum(value) {
+  return typeof value === "string" && CHECKSUM.test(value);
+}
+function toSubscriptionInvoiceDocumentRecord(row) {
+  if (!isInvoiceDocumentChecksum(row.checksum)) {
+    throw new Error(`${DOCUMENTS}.checksum of ${row.invoiceId} is not a SHA-256 digest.`);
+  }
+  const size = Number(row.size);
+  if (!Number.isSafeInteger(size) || size < 0) {
+    throw new Error(`${DOCUMENTS}.size of ${row.invoiceId} is not a size in bytes.`);
+  }
+  return {
+    invoiceId: row.invoiceId,
+    checksum: row.checksum,
+    mediaType: row.mediaType,
+    fileName: row.fileName,
+    size,
+    renderedAt: row.renderedAt,
+    archivedAt: row.archivedAt,
+    deliveryClaimedAt: row.deliveryClaimedAt,
+    deliveredAt: row.deliveredAt,
+    deliveredTo: row.deliveredTo
+  };
+}
+function toArchivedInvoiceDocument(row) {
+  if (!isInvoiceDocumentChecksum(row.checksum)) {
+    throw new Error(`${ARCHIVE}.checksum of ${row.invoiceId} is not a SHA-256 digest.`);
+  }
+  if (!(row.content instanceof Uint8Array)) {
+    throw new Error(`${ARCHIVE}.content of ${row.invoiceId} is not a file.`);
+  }
+  return {
+    invoiceId: row.invoiceId,
+    checksum: row.checksum,
+    mediaType: row.mediaType,
+    fileName: row.fileName,
+    // A copy that owns its bytes: a driver's `Buffer` may be a view into a
+    // pooled allocation, and a caller handing it on must not see that pool.
+    content: new Uint8Array(row.content),
+    archivedAt: row.archivedAt
+  };
+}
+var INVOICE_ARCHIVE_TRIGGERS = [
+  "subscription_invoice_archive_is_kept",
+  "subscription_invoice_archive_is_not_emptied"
+];
+function invoiceArchiveProtectionProblem(enabledTriggers) {
+  const missing = INVOICE_ARCHIVE_TRIGGERS.filter((name) => !enabledTriggers.includes(name));
+  if (missing.length === 0) return null;
+  return `${ARCHIVE} lacks ${missing.join(" and ")}, which keep an archived invoice document as it was issued: run @saasicat/spec/sql/1.0-an-invoice-document-is-archived.postgres.sql after db push, and enable the triggers where they were disabled.`;
+}
+
+// src/e-invoice-format.ts
+var CATEGORY = {
+  standard: "S",
+  reduced: "S",
+  exempt: "E",
+  "small-business": "E",
+  "reverse-charge": "AE",
+  "not-taxable": "O"
+};
+function vatCategoryOf(kind) {
+  return CATEGORY[kind];
+}
+var NOT_XML = /[^\t\n\r\u0020-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}]/gu;
+function holdsOnlyXmlCharacters(text) {
+  return text.search(NOT_XML) === -1;
+}
+var CARRIAGE_RETURN = /\r\n?/g;
+function asXmlReadsIt(text) {
+  return text.replace(NOT_XML, "?").replace(CARRIAGE_RETURN, "\n");
+}
+
 // src/subscriber-mapping.ts
 function formatCustomerNumber(prefix, sequence) {
   return `${prefix}${sequence}`;
@@ -2507,7 +3239,7 @@ function toIdentityValues(value) {
 // src/subscriber-payment-method-mapping.ts
 var PAYMENT_METHOD_TYPES = ["card", "sepa_debit"];
 var STATUSES = ["ACTIVE", "REPLACED"];
-var TABLE3 = "subscriber_payment_methods";
+var TABLE4 = "subscriber_payment_methods";
 function toSubscriberPaymentMethodRecord(row) {
   return {
     id: row.id,
@@ -2516,7 +3248,7 @@ function toSubscriberPaymentMethodRecord(row) {
     provider: row.provider,
     customerRef: row.customerRef,
     paymentMethodRef: row.paymentMethodRef,
-    type: oneOf(PAYMENT_METHOD_TYPES, row.type, { table: TABLE3, column: "type", id: row.id }),
+    type: oneOf(PAYMENT_METHOD_TYPES, row.type, { table: TABLE4, column: "type", id: row.id }),
     brand: row.brand,
     last4: row.last4,
     expiryMonth: row.expiryMonth,
@@ -2524,7 +3256,7 @@ function toSubscriberPaymentMethodRecord(row) {
     country: row.country,
     bankCode: row.bankCode,
     mandateReference: row.mandateReference,
-    status: oneOf(STATUSES, row.status, { table: TABLE3, column: "status", id: row.id }),
+    status: oneOf(STATUSES, row.status, { table: TABLE4, column: "status", id: row.id }),
     confirmedAt: row.confirmedAt,
     replacedAt: row.replacedAt,
     createdAt: row.createdAt
@@ -2922,6 +3654,23 @@ var ERROR_MESSAGES_DE = {
   BUNDLE_RETIREMENT_REINSTATE_SUBSCRIPTION_ENDS: "Version {version} von {bundleKey} wird stillgelegt, und diese Buchung endet, bevor sie umziehen w\xFCrde. Ihr Abonnement endet bis dahin ebenfalls.",
   BUNDLE_RETIREMENT_SWITCH_PLAN_CHANGES: "{bundleName} zieht am {date} auf seine neue Version um, und Ihr Paket \xE4ndert sich vorher. Der Preis, den ein Wechsel halten w\xFCrde, steht deshalb noch nicht fest. Wechseln Sie, sobald Ihr Paket gewechselt hat, oder lassen Sie es an diesem Tag umziehen.",
   BUNDLE_VERSION_OFFER_CHANGED: "Das Angebot hat sich seit der Anzeige ge\xE4ndert. Bitte sieh dir das aktuelle an, bevor du wechselst.",
+  FEATURE_WITHDRAWAL_UNAVAILABLE: "Ein Feature zur\xFCckzuziehen ist hier nicht m\xF6glich: Die Speicher k\xF6nnen nicht alle auflisten, die ein R\xFCckzug erreicht.",
+  FEATURE_WITHDRAWAL_FEATURE_UNKNOWN: "Der Katalog kennt kein Feature {featureKey}.",
+  FEATURE_WITHDRAWAL_DATE_IN_PAST: "Ein Feature wird ab jetzt oder ab einem sp\xE4teren Datum zur\xFCckgezogen, nie ab einem vergangenen.",
+  FEATURE_WITHDRAWAL_OPEN: "{featureKey} ist bereits zur\xFCckgezogen, und dieser R\xFCckzug ist nicht aufgehoben. Heben Sie ihn auf, bevor Sie einen weiteren ank\xFCndigen.",
+  FEATURE_WITHDRAWAL_OVERLAPS: "{featureKey} ist bis zum {date} zur\xFCckgezogen. Ein weiterer R\xFCckzug kann fr\xFChestens an diesem Tag beginnen.",
+  FEATURE_WITHDRAWAL_REDUCTION_NOT_REACHED: "Die Minderung f\xFCr {key} bei Abrechnung {billingCycle} betrifft nichts, was dieser R\xFCckzug erreicht.",
+  FEATURE_WITHDRAWAL_REDUCTION_NAMED_TWICE: "Die Minderung f\xFCr {key} bei Abrechnung {billingCycle} ist doppelt angegeben.",
+  FEATURE_WITHDRAWAL_REDUCTION_EXCEEDS_PRICE: "Die Minderung f\xFCr {key} bei Abrechnung {billingCycle} ist h\xF6her als der niedrigste Preis, den sie mindert: {price}.",
+  FEATURE_WITHDRAWAL_PREVIEW_CHANGED: "Die Abonnements, die dieser R\xFCckzug erreicht, haben sich seit der Anzeige ge\xE4ndert. Sehen Sie sie erneut an, bevor Sie ihn ank\xFCndigen.",
+  FEATURE_WITHDRAWAL_NOT_FOUND: "R\xFCckzug {withdrawalId} nicht gefunden.",
+  FEATURE_WITHDRAWAL_ALREADY_LIFTED: "Dieser R\xFCckzug ist bereits aufgehoben, ab dem {date}.",
+  FEATURE_WITHDRAWAL_NOT_TOLD_YET: "\xDCber diesen R\xFCckzug ist noch niemand informiert, und er wird nicht aufgehoben, bevor das geschehen ist. Versuchen Sie es gleich noch einmal.",
+  FEATURE_WITHDRAWAL_LIFT_IN_PAST: "Ein R\xFCckzug wird ab jetzt oder ab einem sp\xE4teren Datum aufgehoben, nie ab einem vergangenen.",
+  FEATURE_WITHDRAWAL_NOT_IN_EFFECT: "{featureKey} ist gerade nicht zur\xFCckgezogen. Deshalb kann nichts sofort beendet werden.",
+  FEATURE_WITHDRAWAL_DOES_NOT_REACH: "Dieser R\xFCckzug betrifft Ihr Abonnement nicht, oder diese Buchung nicht mehr.",
+  FEATURE_WITHDRAWAL_ALREADY_ENDED: "Das ist bereits beendet.",
+  FEATURE_WITHDRAWAL_END_NOW_UNSUPPORTED: "Ihre K\xFCndigung zum {date} ist erfasst und kann hier nicht vorgezogen werden. Sie endet an diesem Tag, und bis dahin gilt die Minderung.",
   RETIREMENT_SWITCH_NOT_PENDING: "F\xFCr Ihre Version steht keine Einstellung mehr bevor. Es gibt nichts, wohin Sie wechseln k\xF6nnten.",
   RETIREMENT_SWITCH_IN_TRIAL: "Der Wechsel ist m\xF6glich, sobald Ihre Testphase endet.",
   RETIREMENT_SWITCH_BUNDLE_CANNOT_FOLLOW: "{bundleName} kann im Paket {planName} nicht laufen und l\xE4uft fr\xFChestens bis {until}. Ist es gek\xFCndigt, ist der Wechsel ab diesem Tag m\xF6glich.",
@@ -2964,6 +3713,15 @@ var ERROR_MESSAGES_DE = {
   PROMO_MAX_REDEMPTIONS_LOWERED: "maxRedemptions l\xE4sst sich nicht senken.",
   // ── contract ──
   SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "Der Vertrag nennt in {field} {stated} %, der Steueradapter entscheidet {decided} %.",
+  SUBSCRIPTION_INVOICE_CHARGE_INVOICED: "Die Forderung '{chargeId}' steht bereits auf einer Rechnung.",
+  SUBSCRIPTION_INVOICE_CONTENT_INCOMPLETE: "Der Rechnung fehlt, was der Steueradapter {adapter} verlangt: {missing}. Sie wird ausgestellt, sobald es erg\xE4nzt ist.",
+  SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED: "Der Vertrag {contractId} nennt keinen best\xE4tigten Aussteller und Abonnenten \u2013 eine Migration hat seine Parteien \xFCbernommen, oder er nennt keinen Aussteller \u2013, deshalb werden seine Forderungen nicht in Rechnung gestellt.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED: "Das Dokument der Rechnung {invoiceId} weicht vom festgehaltenen oder archivierten ab ({rendered} statt {recorded}); das erste bleibt, und der n\xE4chste Lauf kl\xE4rt, welches die Rechnung beh\xE4lt.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_REFUSED: "Der Steueradapter {adapter} weist die gerenderte Rechnung zur\xFCck: {missing}. Die Rechnung beh\xE4lt ihre Nummer und wartet auf ein Dokument, das die Pr\xFCfung besteht.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_MISMATCH: "Das archivierte Dokument der Rechnung {invoiceId} passt nicht zur beim Rendern festgehaltenen Pr\xFCfsumme und wird nicht herausgegeben.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED: "Das Dokument der Rechnung {invoiceId} ist noch nicht archiviert.",
+  SUBSCRIPTION_INVOICE_NOT_FOUND: "Keine Rechnung '{invoiceId}'.",
+  SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "Der Abonnent {subscriberId} hat keine Rechnungs-E-Mail; seine Rechnung wird versendet, sobald eine eingetragen ist.",
   CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "Aus einem Checkout-Angebot entsteht nur ein einziger Vertrag, und das erst, wenn seine Positionen eingefroren sind.",
   CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "Ein Checkout-Angebot braucht eine eingefrorene Plan-Position.",
   CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Jede gew\xE4hlte Bundle-Version braucht eine eingefrorene Bundle-Position.",
@@ -3062,7 +3820,13 @@ export {
   ERROR_MESSAGES_DE,
   ERROR_MESSAGES_EN,
   FEATURE_NOT_LICENSED,
+  FEATURE_WITHDRAWAL_CAPABILITY,
+  FEATURE_WITHDRAWAL_REASON_MAX_LENGTH,
   ForeignPaymentMethodReferenceError,
+  INVOICE_ARCHIVE_TRIGGERS,
+  INVOICE_DOCUMENT_CAPABILITY,
+  INVOICE_ERROR_CODES,
+  INVOICE_SEQUENCE_DIGITS,
   LEGAL_IDENTITY_FIELDS,
   MAINTENANCE_CAPABILITY,
   MAINTENANCE_ERROR_CODES,
@@ -3097,6 +3861,8 @@ export {
   SUBSCRIBER_ACCOUNT_CAPABILITY,
   SUBSCRIBER_ATTENTION_CAPABILITY,
   SUBSCRIBER_ATTENTION_PAGE_SIZE,
+  SUBSCRIBER_CHARGE_ORIGINS,
+  SUBSCRIBER_CHARGE_SOURCES,
   SUBSCRIBER_CORRECTION_CAPABILITY,
   SUBSCRIBER_ERROR_CODES,
   SUBSCRIBER_INVOICE_ADDRESS_FIELDS,
@@ -3105,7 +3871,9 @@ export {
   TAX_ERROR_CODES,
   TAX_TREATMENT_KINDS,
   VERSION_RETIREMENT_CAPABILITY,
+  addDaysToDay,
   applyPromo,
+  asXmlReadsIt,
   assertPersistenceCapabilities,
   buildActivePlanVersionWhere,
   buildActiveVersionWhere,
@@ -3129,14 +3897,28 @@ export {
   contractPartiesOf,
   coverageExcludingSelf,
   customLimitsReader,
+  dayInZone,
   definedFields,
   diffSettings,
+  draftSubscriptionInvoice,
+  endedAtOnceSubjectOf,
+  featureWithdrawalRowOf,
+  featuresWithdrawnAt,
   formatCustomerNumber,
   formatErrorMessage,
+  formatInvoiceNumber,
   grossFromNet,
+  holdsOnlyXmlCharacters,
   identityCorrectionDelta,
+  invoiceArchiveProtectionProblem,
+  invoiceContentDraftOf,
+  invoiceFooterOf,
+  invoiceGroupsOf,
+  invoiceIssuerOf,
   isBundleRedundant,
+  isFeatureWithdrawnAt,
   isForeignPaymentMethodReferenceError,
+  isInvoiceDocumentChecksum,
   isMaintenanceAnnouncementLapsed,
   isMaintenanceOverrun,
   isPaymentCallbackRejectedError,
@@ -3147,6 +3929,7 @@ export {
   issuerIdentityOf,
   keepOneRecommended,
   keepsVatIdCheck,
+  lastDayInZone,
   maintenanceRetryAfterSeconds,
   maintenanceStatusOf,
   maintenanceWindowStatusOf,
@@ -3156,6 +3939,7 @@ export {
   missingRequiresFor,
   movedIdentityFields,
   netFromGross,
+  nextWithdrawalChange,
   noActivePlanVersion,
   parseZonedInstant,
   percentOf,
@@ -3192,15 +3976,22 @@ export {
   subscriptionBundleGone,
   subscriptionContractGone,
   subscriptionGone,
+  subscriptionInvoiceChargeInvoiced,
+  subscriptionInvoiceColumns,
+  subscriptionInvoiceDocumentChanged,
+  subscriptionInvoiceLineColumns,
   sumToCents,
   taxOriginOf,
   taxOriginWrite,
+  taxPerRate,
   taxTreatmentToJson,
+  toArchivedInvoiceDocument,
   toBundleStemRow,
   toBundleVersionRetirementRecord,
   toCents,
   toContractLineItemRecord,
   toDecimalString,
+  toFeatureWithdrawalRecord,
   toMaintenanceWindowRecord,
   toPlanRow,
   toPlanVersionRow,
@@ -3213,12 +4004,18 @@ export {
   toSubscriberVatIdCheckRecord,
   toSubscriptionBundleRecord,
   toSubscriptionContractRecord,
+  toSubscriptionInvoiceDocumentRecord,
+  toSubscriptionInvoiceRecord,
   toSubscriptionNoticeRecord,
   toTaxOriginValues,
   toTaxTreatment,
   toVersionRetirementRecord,
+  utcMidnightOf,
+  vatCategoryOf,
   vatIdCheckFromStore,
   versionOnSale,
   versionOnSaleOrNext,
-  versionSale
+  versionSale,
+  withdrawnFeaturesOf,
+  yearOfDay
 };