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

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,13 @@ 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,
+  "collection-failed": true,
+  "collection-announced": true,
+  "collection-reversed": true
 };
 function toSubscriptionNoticeRecord(row) {
   return {
@@ -538,6 +560,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 +796,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 +1284,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 +1515,92 @@ 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",
+  /**
+   * The subscriber's direct debit names no mandate reference
+   * (`paymentMethodId`), which has to be announced before it is debited
+   * (`SC-PRIC-028`). An invoice collected by it draws no number, and one
+   * planned with it is not announced, until the payment method is replaced.
+   */
+  SUBSCRIPTION_INVOICE_MANDATE_MISSING: "SUBSCRIPTION_INVOICE_MANDATE_MISSING",
+  /**
+   * The subscriber (`subscriberId`) has no payment method in use, so the
+   * invoice is not collected until one is (`SC-PRIC-082`).
+   */
+  SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD: "SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD",
+  /**
+   * A direct debit announced again after a failed collection (`attemptKey`)
+   * waits until the subscriber has been told of that failure
+   * (`SC-PRIC-080`).
+   */
+  SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD: "SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD",
+  /**
+   * 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",
+  /** No credit under this id for the tenant's subscriber (`creditId`). */
+  SUBSCRIBER_CREDIT_NOT_FOUND: "SUBSCRIBER_CREDIT_NOT_FOUND",
+  /**
+   * A payout of more than the credit still owes (`creditId`, `open`): nothing
+   * is paid out beyond it (`SC-PRIC-083`), and nothing is recorded.
+   */
+  SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT: "SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT",
+  /**
+   * A payout on a day still to come (`paidOn`, `today` in the installation's
+   * zone): a payout is recorded once it left.
+   */
+  SUBSCRIBER_PAYOUT_NOT_MADE_YET: "SUBSCRIBER_PAYOUT_NOT_MADE_YET",
+  /** No case to reconcile under this id (`caseId`). */
+  SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND: "SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND",
+  /**
+   * A case closed before (`caseId`, `closedAt`), by the operator or by
+   * SaaSiCat; its note stands, and nothing is written (`SC-ADM-033`).
+   */
+  SUBSCRIBER_RECONCILIATION_CASE_CLOSED: "SUBSCRIBER_RECONCILIATION_CASE_CLOSED"
+};
 var SUBSCRIBER_ERROR_CODES = {
   /**
    * A contract, a plan change or a booking for a tenant that has no
@@ -1468,6 +1781,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 +1835,45 @@ 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"],
+  SubscriptionInvoiceCollection: [
+    "entitlement.invoiceCollectionRepository",
+    "entitlement.subscriberPaymentRepository"
+  ],
+  SubscriberPayment: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriptionInvoiceSettlement: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriberCredit: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriberCreditEntry: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriberRefund: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriberReversal: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
+  SubscriberReconciliationCase: [
+    "entitlement.subscriberPaymentRepository",
+    "entitlement.invoiceCollectionRepository"
+  ],
   PromoCodeHold: ["promo.holdRepository"]
 };
 function membersLeftOut(notAdopted = []) {
@@ -1704,6 +2056,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 +2115,23 @@ 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_MANDATE_MISSING: "The direct debit {paymentMethodId} names no mandate reference, which has to be announced before it is debited. The invoice waits until the payment method is replaced.",
+  SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD: "The subscriber {subscriberId} has no payment method in use. The invoice is collected once one is.",
+  SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD: "The direct debit is announced once the subscriber has been told that collection {attemptKey} failed.",
+  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.",
+  SUBSCRIBER_CREDIT_NOT_FOUND: "No credit '{creditId}' of this tenant's subscriber.",
+  SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT: "The credit {creditId} still owes {open}; nothing beyond that is paid out, and nothing was recorded.",
+  SUBSCRIBER_PAYOUT_NOT_MADE_YET: "A payout is recorded once it left: {paidOn} is after today, {today}.",
+  SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND: "No case to reconcile '{caseId}'.",
+  SUBSCRIBER_RECONCILIATION_CASE_CLOSED: "The case {caseId} was closed on {closedAt}; its note stands, and nothing was recorded.",
   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.",
@@ -1831,11 +2217,21 @@ var ERROR_MESSAGES_EN = {
   TAX_VAT_ID_CHECK_NOT_COMPLETED: "The VAT identification number could not be checked just now ({reason}). Please try again later.",
   TAX_VAT_ID_CHECK_NOT_AVAILABLE: "This installation names no tax adapter, so no VAT identification number is checked."
 };
+function parameterText(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value instanceof Date) return String(value);
+  if (!Array.isArray(value)) return null;
+  const items = value.map(parameterText);
+  return items.every((item) => item !== null) ? items.join(",") : null;
+}
 function formatErrorMessage(template, params = {}) {
-  return template.replace(/\{(\w+)\}/g, (match, name) => {
-    const value = params[name];
-    return value === void 0 || value === null ? match : String(value);
-  });
+  return template.replace(
+    /\{(\w+)\}/g,
+    (match, name) => parameterText(params[name]) ?? match
+  );
 }
 function resolveErrorMessage(body, overrides = {}, defaults = ERROR_MESSAGES_EN) {
   const code = typeof body.code === "string" ? body.code : void 0;
@@ -2013,6 +2409,13 @@ function selectChargeableBundles(planFeatures, selectedBundles) {
 }
 
 // src/payment-gateway.types.ts
+var RETRYABLE_FAILURES = /* @__PURE__ */ new Set([
+  "insufficient-funds",
+  "declined"
+]);
+function isRetryableCollectionFailure(reason) {
+  return RETRYABLE_FAILURES.has(reason);
+}
 var PAYMENT_CALLBACK_REJECTED = "PAYMENT_CALLBACK_REJECTED";
 var PaymentCallbackRejectedError = class extends Error {
   code = PAYMENT_CALLBACK_REJECTED;
@@ -2188,17 +2591,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 +2612,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 +2653,96 @@ 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/column-day.ts
+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.`);
+}
+
+// src/subscriber-payment-method-mapping.ts
+var PAYMENT_METHOD_TYPES = ["card", "sepa_debit"];
+var STATUSES = ["ACTIVE", "REPLACED"];
+var TABLE4 = "subscriber_payment_methods";
+function toSubscriberPaymentMethodRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    gatewayAccount: row.gatewayAccount,
+    provider: row.provider,
+    customerRef: row.customerRef,
+    paymentMethodRef: row.paymentMethodRef,
+    type: oneOf(PAYMENT_METHOD_TYPES, row.type, { table: TABLE4, column: "type", id: row.id }),
+    brand: row.brand,
+    last4: row.last4,
+    expiryMonth: row.expiryMonth,
+    expiryYear: row.expiryYear,
+    country: row.country,
+    bankCode: row.bankCode,
+    mandateReference: row.mandateReference,
+    status: oneOf(STATUSES, row.status, { table: TABLE4, column: "status", id: row.id }),
+    confirmedAt: row.confirmedAt,
+    replacedAt: row.replacedAt,
+    createdAt: row.createdAt
+  };
+}
+function subscriberPaymentMethodColumns(data) {
+  return {
+    subscriberId: data.subscriberId,
+    gatewayAccount: data.gatewayAccount,
+    provider: data.provider,
+    customerRef: data.customerRef,
+    paymentMethodRef: data.paymentMethodRef,
+    type: data.type,
+    brand: data.brand,
+    last4: data.last4,
+    expiryMonth: data.expiryMonth,
+    expiryYear: data.expiryYear,
+    country: data.country,
+    bankCode: data.bankCode,
+    mandateReference: data.mandateReference,
+    confirmedAt: data.confirmedAt
+  };
+}
+var FOREIGN_PAYMENT_METHOD_REFERENCE = "FOREIGN_PAYMENT_METHOD_REFERENCE";
+var ForeignPaymentMethodReferenceError = class extends Error {
+  constructor(gatewayAccount, paymentMethodRef) {
+    super(
+      `Payment method '${paymentMethodRef}' of account '${gatewayAccount}' belongs to another subscriber. A reference belongs to exactly one, so it is not handed out.`
+    );
+    this.gatewayAccount = gatewayAccount;
+    this.paymentMethodRef = paymentMethodRef;
+    this.name = "ForeignPaymentMethodReferenceError";
+  }
+  gatewayAccount;
+  paymentMethodRef;
+  code = FOREIGN_PAYMENT_METHOD_REFERENCE;
+};
+function isForeignPaymentMethodReferenceError(error) {
+  return error instanceof Error && error.code === FOREIGN_PAYMENT_METHOD_REFERENCE;
+}
+function refuseForeignPaymentMethodReference(recorded, subscriberId) {
+  if (recorded.subscriberId === subscriberId) return;
+  throw new ForeignPaymentMethodReferenceError(
+    recorded.gatewayAccount,
+    recorded.paymentMethodRef
+  );
+}
+
 // src/subscriber.types.ts
 var SUBSCRIBER_INVOICE_ADDRESS_FIELDS = [
   "addressLine1",
@@ -2378,89 +2874,1375 @@ function textEntries(value) {
   return entries;
 }
 
-// src/subscriber-mapping.ts
-function formatCustomerNumber(prefix, sequence) {
-  return `${prefix}${sequence}`;
-}
-function toSubscriberRecord(row, tenantId) {
+// 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.`);
+  }
+  const dueDate = dayOf2(row.dueDate, where("dueDate"));
   return {
     id: row.id,
-    customerNumber: formatCustomerNumber(row.customerNumberPrefix, row.customerSequence),
-    legalName: row.legalName,
-    addressLine1: row.addressLine1,
-    addressLine2: row.addressLine2,
-    postalCode: row.postalCode,
-    city: row.city,
-    country: row.country,
-    vatId: row.vatId,
-    taxNumber: row.taxNumber,
-    invoiceEmail: row.invoiceEmail,
-    business: row.business,
-    tenantId,
-    migrated: row.migrated,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt
+    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,
+    servicePeriodFrom: dayOf2(row.servicePeriodFrom, where("servicePeriodFrom")),
+    servicePeriodUntil: dayOf2(row.servicePeriodUntil, where("servicePeriodUntil")),
+    ...collectionOf(row.payment, row.collectionDate, dueDate, where),
+    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 toSubscriberCorrectionRecord(row) {
+function toSubscriptionInvoiceLineRecord(row) {
+  const where = (column) => ({ table: LINES, column, id: row.id });
   return {
     id: row.id,
-    subscriberId: row.subscriberId,
-    previous: toIdentityValues(row.previous),
-    corrected: toIdentityValues(row.corrected),
-    reason: row.reason,
-    correctedBy: row.correctedBy,
-    correctedAt: row.correctedAt
+    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 toSubscriberTaxOriginChangeRecord(row) {
+function subscriptionInvoiceColumns(invoice, drawn) {
   return {
-    id: row.id,
-    subscriberId: row.subscriberId,
-    previous: toTaxOriginValues(row.previous),
-    changed: toTaxOriginValues(row.changed),
-    changedBy: row.changedBy,
-    changedAt: row.changedAt,
-    reason: row.reason
+    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,
+    payment: invoice.payment ? { ...invoice.payment } : null,
+    collectionDate: invoice.collectionDate,
+    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 identityCorrectionDelta(current, corrected) {
-  const previous = {};
-  const next = {};
-  for (const field of LEGAL_IDENTITY_FIELDS) {
-    const value = corrected[field];
-    if (value === void 0 || value === current[field]) continue;
-    previous[field] = current[field];
-    next[field] = value;
-  }
+function subscriptionInvoiceLineColumns(line, invoiceId) {
   return {
-    previous,
-    corrected: next
+    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 contractPartiesOf(subscriber, issuer) {
-  const party = {
-    customerNumber: subscriber.customerNumber,
-    legalName: subscriber.legalName,
-    vatId: subscriber.vatId,
-    taxNumber: subscriber.taxNumber,
-    addressLine1: subscriber.addressLine1,
-    addressLine2: subscriber.addressLine2,
-    postalCode: subscriber.postalCode,
-    city: subscriber.city,
-    country: subscriber.country
+function utcMidnightOf(day) {
+  return /* @__PURE__ */ new Date(`${day}T00:00:00.000Z`);
+}
+function collectionOf(payment, collectionDate, dueDate, where) {
+  const paymentAt = where("payment");
+  if (payment === void 0 || collectionDate === void 0) {
+    throw new Error(
+      `${paymentAt.table} row ${paymentAt.id} was read without its payment or its collection date.`
+    );
+  }
+  if (payment === null) {
+    if (collectionDate !== null) {
+      throw new Error(
+        `${paymentAt.table}.collectionDate of ${paymentAt.id} is set on an invoice that is not collected.`
+      );
+    }
+    return { payment: null, collectionDate: null };
+  }
+  if (typeof payment !== "object" || Array.isArray(payment)) {
+    throw new Error(`${paymentAt.table}.payment of ${paymentAt.id} is not a payment method.`);
+  }
+  const required = (key) => {
+    const value = textOrNull2(payment, key, paymentAt);
+    if (value === null) {
+      throw new Error(`${paymentAt.table}.payment of ${paymentAt.id} names no ${key}.`);
+    }
+    return value;
   };
-  return {
-    subscriberId: subscriber.id,
-    subscriber: party,
-    issuer: issuer ? issuerPartyOf(issuer) : null
+  const type = oneOf(PAYMENT_METHOD_TYPES, required("type"), {
+    ...paymentAt,
+    column: "payment.type"
+  });
+  const recorded = {
+    paymentMethodId: required("paymentMethodId"),
+    gatewayAccount: required("gatewayAccount"),
+    type,
+    brand: textOrNull2(payment, "brand", paymentAt),
+    last4: required("last4"),
+    mandateReference: type === "sepa_debit" ? required("mandateReference") : null
   };
+  if (type !== "sepa_debit") {
+    if (collectionDate !== null) {
+      throw new Error(
+        `${paymentAt.table}.collectionDate of ${paymentAt.id} is set on an invoice paid by ${type}.`
+      );
+    }
+    return { payment: recorded, collectionDate: null };
+  }
+  const collected = dayOf2(collectionDate, where("collectionDate"));
+  if (collected !== dueDate) {
+    throw new Error(
+      `${paymentAt.table}.dueDate of ${paymentAt.id} is ${dueDate}, and a direct debit falls due on the day it is collected, ${collected}.`
+    );
+  }
+  return { payment: recorded, collectionDate: collected };
 }
-function issuerPartyOf(issuer) {
-  const identity = issuerIdentityOf(issuer);
-  return {
-    legalName: identity?.legalName ?? "",
-    vatId: identity?.vatId ?? null,
+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 fieldOf(source, key) {
+  const field = Object.getOwnPropertyDescriptor(source, key)?.value;
+  return field;
+}
+function textOrNull2(source, key, where) {
+  const value = fieldOf(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)
+  );
+}
+var DIRECT_DEBIT_LEAD_DAYS = 14;
+function directDebitLeadDaysOf(invoicing) {
+  return invoicing.directDebitLeadDays ?? DIRECT_DEBIT_LEAD_DAYS;
+}
+function invoicePaymentOf(method) {
+  if (!method) return null;
+  if (method.type === "sepa_debit" && method.mandateReference === null) return null;
+  return {
+    paymentMethodId: method.id,
+    gatewayAccount: method.gatewayAccount,
+    type: method.type,
+    brand: method.brand,
+    last4: method.last4,
+    mandateReference: method.type === "sepa_debit" ? method.mandateReference : null
+  };
+}
+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 })));
+  const payment = tax.gross > 0 ? input.payment : null;
+  if (payment?.type === "sepa_debit" && payment.mandateReference === null) {
+    throw new Error(
+      `Payment method ${payment.paymentMethodId} is a direct debit without a mandate reference, which an invoice collected by it has to announce.`
+    );
+  }
+  const collectionDate = payment?.type === "sepa_debit" ? addDaysToDay(issueDate, input.directDebitLeadDays) : null;
+  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: collectionDate ?? addDaysToDay(issueDate, input.paymentTermDays),
+    payment: payment ? { ...payment } : null,
+    collectionDate,
+    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/invoice-collection.types.ts
+function sentCollectionOf(attempt) {
+  const { submittedAt, heldAt } = attempt;
+  if (submittedAt === null || heldAt === null) {
+    throw new Error(`Collection attempt ${attempt.attemptKey} has not been sent.`);
+  }
+  return { ...attempt, submittedAt, heldAt };
+}
+var INVOICE_COLLECTION_LEASE_MS = 15 * 6e4;
+var INVOICE_COLLECTION_ASK_EVERY_MS = 60 * 6e4;
+function collectionAttemptKey(invoiceId, attempt) {
+  if (!Number.isInteger(attempt) || attempt < 1) {
+    throw new RangeError(`A collection attempt counts from 1; ${attempt} is not one.`);
+  }
+  return `saasicat:collect:${invoiceId}:${attempt}`;
+}
+function collectionStatusOf(outcome) {
+  if (outcome.status === "succeeded") return "SUCCEEDED";
+  if (outcome.status === "pending") return "PENDING";
+  return "FAILED";
+}
+var COLLECTION_NOT_SENT_PAID = {
+  status: "failed",
+  paymentRef: null,
+  reason: "other",
+  gatewayCode: "saasicat_invoice_paid"
+};
+var COLLECTION_NOT_SENT_REVERSED = {
+  status: "failed",
+  paymentRef: null,
+  reason: "other",
+  gatewayCode: "saasicat_payment_method_reversed"
+};
+
+// src/invoice-collection-mapping.ts
+var TABLE5 = "subscription_invoice_collections";
+var INVOICE_COLLECTION_STATUSES = [
+  "SCHEDULED",
+  "SUBMITTED",
+  "PENDING",
+  "SUCCEEDED",
+  "FAILED",
+  "WITHDRAWN",
+  "REVERSED"
+];
+var UNSETTLED_COLLECTION_STATUSES = [
+  "SUBMITTED",
+  "PENDING"
+];
+var BLOCKING_COLLECTION_STATUSES = [
+  "SCHEDULED",
+  ...UNSETTLED_COLLECTION_STATUSES,
+  "SUCCEEDED"
+];
+var FOLLOWED_UP_COLLECTION_STATUSES = [
+  "FAILED",
+  "REVERSED"
+];
+var REVERSIBLE_COLLECTION_STATUSES = [
+  "SUCCEEDED",
+  "FAILED"
+];
+function lastCollectionOf(earlier) {
+  return earlier.reduce((last, row) => Math.max(last, row.attempt), 0);
+}
+function refusesFirstAttempt(earlier) {
+  return earlier.length > 0;
+}
+function refusesPlannedAttempt(earlier, after) {
+  return earlier.some((row) => BLOCKING.has(row.status)) || lastCollectionOf(earlier) !== after;
+}
+var BLOCKING = new Set(BLOCKING_COLLECTION_STATUSES);
+var NOT_SENT = /* @__PURE__ */ new Set(["SCHEDULED", "WITHDRAWN"]);
+var COLLECTION_FAILURE_REASONS = [
+  "insufficient-funds",
+  "declined",
+  "authentication-required",
+  "payment-method-unusable",
+  "mandate-invalid",
+  "other"
+];
+function toInvoiceCollectionRecord(row) {
+  const where = (column) => ({ table: TABLE5, column, id: row.id });
+  const amount = Number(
+    // oxlint-disable-next-line typescript/no-base-to-string -- Prisma hands a Decimal, whose text is the number; any other object becomes NaN and is refused below
+    row.amount === null || row.amount === void 0 ? NaN : String(row.amount)
+  );
+  if (!Number.isFinite(amount)) {
+    throw new Error(`${TABLE5}.amount of ${row.id} is not an amount.`);
+  }
+  const status = oneOf(INVOICE_COLLECTION_STATUSES, row.status, where("status"));
+  const sent = !NOT_SENT.has(status);
+  if (sent !== (row.submittedAt !== null) || sent !== (row.heldAt !== null)) {
+    throw new Error(
+      `${TABLE5}.submittedAt and heldAt of ${row.id} do not fit its status ${status}: an attempt that left carries both, and one that did not carries neither.`
+    );
+  }
+  const collectOn = row.collectOn === null || row.collectOn === void 0 ? null : dayOf2(row.collectOn, where("collectOn"));
+  if (status === "SCHEDULED" && collectOn === null) {
+    throw new Error(`${TABLE5}.collectOn of ${row.id} is missing from a planned attempt.`);
+  }
+  return {
+    id: row.id,
+    invoiceId: row.invoiceId,
+    attempt: row.attempt,
+    attemptKey: row.attemptKey,
+    gatewayAccount: row.gatewayAccount,
+    paymentMethodId: row.paymentMethodId,
+    paymentMethodType: oneOf(
+      PAYMENT_METHOD_TYPES,
+      row.paymentMethodType,
+      where("paymentMethodType")
+    ),
+    customerRef: row.customerRef,
+    paymentMethodRef: row.paymentMethodRef,
+    invoiceNumber: row.invoiceNumber,
+    amount,
+    currency: row.currency,
+    status,
+    paymentRef: row.paymentRef,
+    failureReason: row.failureReason === null ? null : oneOf(COLLECTION_FAILURE_REASONS, row.failureReason, where("failureReason")),
+    failureCode: row.failureCode,
+    submittedAt: row.submittedAt,
+    heldAt: row.heldAt,
+    resolvedAt: row.resolvedAt,
+    collectOn,
+    announcedAt: row.announcedAt,
+    followedUpAt: row.followedUpAt
+  };
+}
+function invoiceCollectionColumns(attempt, number) {
+  return {
+    invoiceId: attempt.invoiceId,
+    attempt: number,
+    attemptKey: collectionAttemptKey(attempt.invoiceId, number),
+    gatewayAccount: attempt.gatewayAccount,
+    paymentMethodId: attempt.paymentMethodId,
+    paymentMethodType: attempt.paymentMethodType,
+    customerRef: attempt.customerRef,
+    paymentMethodRef: attempt.paymentMethodRef,
+    invoiceNumber: attempt.invoiceNumber,
+    amount: attempt.amount.toFixed(2),
+    currency: attempt.currency,
+    status: "SUBMITTED",
+    submittedAt: attempt.at,
+    heldAt: attempt.at,
+    collectOn: null
+  };
+}
+function plannedCollectionColumns(plan, number) {
+  return {
+    invoiceId: plan.invoiceId,
+    attempt: number,
+    attemptKey: collectionAttemptKey(plan.invoiceId, number),
+    gatewayAccount: plan.gatewayAccount,
+    paymentMethodId: plan.paymentMethodId,
+    paymentMethodType: plan.paymentMethodType,
+    customerRef: plan.customerRef,
+    paymentMethodRef: plan.paymentMethodRef,
+    invoiceNumber: plan.invoiceNumber,
+    amount: plan.amount.toFixed(2),
+    currency: plan.currency,
+    status: "SCHEDULED",
+    submittedAt: null,
+    heldAt: null,
+    collectOn: plan.collectOn
+  };
+}
+function collectionOutcomeColumns(outcome, at) {
+  const failed = outcome.status === "failed" ? outcome : null;
+  return {
+    status: collectionStatusOf(outcome),
+    paymentRef: outcome.paymentRef,
+    failureReason: failed?.reason ?? null,
+    failureCode: failed?.gatewayCode ?? null,
+    resolvedAt: outcome.status === "pending" ? null : at
+  };
+}
+
+// src/invoice-collection-plan.ts
+var COLLECTION_RETRY_AFTER_DAYS = 7;
+function isChargedAgain(failed, attempts) {
+  if (failed.status !== "FAILED" || failed.failureReason === null) return false;
+  if (!isRetryableCollectionFailure(failed.failureReason)) return false;
+  return !attempts.some(
+    (other) => other.id !== failed.id && other.status === "FAILED" && other.paymentMethodId === failed.paymentMethodId
+  );
+}
+function chargedAgainOn(failedOn) {
+  return addDaysToDay(failedOn, COLLECTION_RETRY_AFTER_DAYS);
+}
+function announcedCollectionDay(earliest2, announcedOn, leadDays) {
+  const afterLead = addDaysToDay(announcedOn, leadDays);
+  return afterLead > earliest2 ? afterLead : earliest2;
+}
+
+// src/invoice-collection-notice-mapping.ts
+var TABLE6 = "subscription_notices";
+var NEXT_ACTIONS = [
+  "charged-again",
+  "announced-again",
+  "replace-payment-method"
+];
+var AFTER_REVERSAL_ACTIONS = [
+  "collected-with-payment-method-in-use",
+  "replace-payment-method"
+];
+var NoticeFields = class _NoticeFields {
+  constructor(content, id) {
+    this.content = content;
+    this.id = id;
+  }
+  content;
+  id;
+  where(column) {
+    return { table: TABLE6, column: `content.${column}`, id: this.id };
+  }
+  value(name) {
+    if (this.content === null || typeof this.content !== "object") {
+      throw new Error(`${TABLE6}.content of ${this.id} is not a notice.`);
+    }
+    return Object.getOwnPropertyDescriptor(this.content, name)?.value;
+  }
+  text(name) {
+    const value = this.value(name);
+    if (typeof value !== "string" || value === "") {
+      throw new Error(`${TABLE6}.content.${name} of ${this.id} is not a text.`);
+    }
+    return value;
+  }
+  amount(name) {
+    const value = this.value(name);
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new Error(`${TABLE6}.content.${name} of ${this.id} is not an amount.`);
+    }
+    return value;
+  }
+  day(name) {
+    return dayOf2(this.value(name), this.where(name));
+  }
+  oneOf(allowed, name) {
+    return oneOf(allowed, this.text(name), this.where(name));
+  }
+  nested(name) {
+    return new _NoticeFields(this.value(name), this.id);
+  }
+  invoice() {
+    return {
+      tenantId: this.text("tenantId"),
+      subscriptionId: this.text("subscriptionId"),
+      subscriberId: this.text("subscriberId"),
+      invoiceId: this.text("invoiceId"),
+      invoiceNumber: this.text("invoiceNumber"),
+      amount: this.amount("amount"),
+      currency: this.text("currency")
+    };
+  }
+};
+function toCollectionFailedNotice(content, id) {
+  const fields = new NoticeFields(content, id);
+  const next = fields.nested("next");
+  const action = next.oneOf(NEXT_ACTIONS, "action");
+  return {
+    kind: fields.oneOf(["collection-failed"], "kind"),
+    ...fields.invoice(),
+    paymentMethodType: fields.oneOf(PAYMENT_METHOD_TYPES, "paymentMethodType"),
+    reason: fields.oneOf(COLLECTION_FAILURE_REASONS, "reason"),
+    next: action === "charged-again" ? { action, on: next.day("on") } : { action }
+  };
+}
+function toCollectionAnnouncedNotice(content, id) {
+  const fields = new NoticeFields(content, id);
+  return {
+    kind: fields.oneOf(["collection-announced"], "kind"),
+    ...fields.invoice(),
+    collectOn: fields.day("collectOn"),
+    mandateReference: fields.text("mandateReference"),
+    last4: fields.text("last4")
+  };
+}
+function toCollectionReversedNotice(content, id) {
+  const fields = new NoticeFields(content, id);
+  return {
+    kind: fields.oneOf(["collection-reversed"], "kind"),
+    ...fields.invoice(),
+    paymentMethodType: fields.oneOf(PAYMENT_METHOD_TYPES, "paymentMethodType"),
+    owed: fields.amount("owed"),
+    next: { action: fields.nested("next").oneOf(AFTER_REVERSAL_ACTIONS, "action") }
+  };
+}
+
+// src/subscriber-payment.types.ts
+var SUBSCRIBER_CREDIT_CAPABILITY = "credits.read";
+var SUBSCRIBER_PAYOUT_CAPABILITY = "credits.payout";
+
+// src/column-amount.ts
+function columnAmountOf(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;
+}
+
+// src/subscriber-payment-mapping.ts
+var PAYMENTS = "subscriber_payments";
+var CREDITS = "subscriber_credits";
+var CREDIT_ENTRIES = "subscriber_credit_entries";
+var REFUNDS = "subscriber_refunds";
+var SETTLEMENTS = "subscription_invoice_settlements";
+var REVERSALS = "subscriber_reversals";
+var INVOICE_SETTLEMENT_KINDS = [
+  "PAYMENT",
+  "REVERSAL",
+  "REINSTATEMENT"
+];
+var REOPENING_SETTLEMENT_KINDS = ["REVERSAL"];
+var SUBSCRIBER_CREDIT_ENTRY_KINDS = [
+  "REFUND",
+  "REFUND_FAILED",
+  "PAYOUT",
+  "REVERSAL",
+  "REVERSAL_TAKEN_BACK"
+];
+var REFUND_ENTRY_KINDS = /* @__PURE__ */ new Set([
+  "REFUND",
+  "REFUND_FAILED"
+]);
+var REVERSAL_ENTRY_KINDS = /* @__PURE__ */ new Set([
+  "REVERSAL",
+  "REVERSAL_TAKEN_BACK"
+]);
+var SUBSCRIBER_REFUND_STATUSES = [
+  "PENDING",
+  "SUCCEEDED",
+  "FAILED",
+  "CANCELED"
+];
+var ENDED_REFUND_STATUSES = ["FAILED", "CANCELED"];
+function isEndedRefund(status) {
+  return ENDED_REFUND_STATUSES.includes(status);
+}
+function toSubscriberPaymentRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    tenantId: row.tenantId,
+    invoiceId: row.invoiceId,
+    collectionId: row.collectionId,
+    gatewayAccount: row.gatewayAccount,
+    provider: row.provider,
+    gatewayRef: row.gatewayRef,
+    amount: columnAmountOf(row.amount, { table: PAYMENTS, column: "amount", id: row.id }),
+    currency: row.currency,
+    recordedAt: row.recordedAt
+  };
+}
+function subscriberPaymentColumns(payment, invoice) {
+  return {
+    subscriberId: invoice.subscriberId,
+    tenantId: invoice.tenantId,
+    invoiceId: payment.invoiceId,
+    collectionId: payment.collectionId,
+    gatewayAccount: payment.gatewayAccount,
+    provider: payment.provider,
+    gatewayRef: payment.gatewayRef,
+    amount: toDecimalString(payment.amount),
+    currency: payment.currency,
+    recordedAt: payment.at
+  };
+}
+function settledAmountOf(row) {
+  const kind = oneOf(INVOICE_SETTLEMENT_KINDS, row.kind, {
+    table: SETTLEMENTS,
+    column: "kind",
+    id: row.id
+  });
+  const amount = columnAmountOf(row.amount, { table: SETTLEMENTS, column: "amount", id: row.id });
+  return REOPENING_SETTLEMENT_KINDS.includes(kind) ? -amount : amount;
+}
+function toSubscriberCreditRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    tenantId: row.tenantId,
+    amount: columnAmountOf(row.amount, { table: CREDITS, column: "amount", id: row.id }),
+    currency: row.currency,
+    origin: creditOriginOf(row),
+    createdAt: row.createdAt
+  };
+}
+function creditOriginOf(row) {
+  const origins = [];
+  if (row.originPaymentId !== null) {
+    origins.push({ kind: "payment", paymentId: row.originPaymentId });
+  }
+  if (row.originInvoiceId !== null) {
+    origins.push({ kind: "invoice", invoiceId: row.originInvoiceId });
+  }
+  if (row.originReversalId !== null) {
+    origins.push({ kind: "reversal", reversalId: row.originReversalId });
+  }
+  const [origin] = origins;
+  if (origin && origins.length === 1) return origin;
+  throw new Error(
+    `${CREDITS} row '${row.id}' names ${origins.length === 0 ? "none" : String(origins.length)} of a payment, an invoice and a reversal it comes from; a credit comes from exactly one.`
+  );
+}
+function toSubscriberCreditEntryRecord(row) {
+  const where = (column) => ({ table: CREDIT_ENTRIES, column, id: row.id });
+  const kind = oneOf(SUBSCRIBER_CREDIT_ENTRY_KINDS, row.kind, where("kind"));
+  const paidOn = row.paidOn === null || row.paidOn === void 0 ? null : dayOf2(row.paidOn, where("paidOn"));
+  if (REFUND_ENTRY_KINDS.has(kind) !== (row.refundId !== null)) {
+    throw new Error(
+      `${CREDIT_ENTRIES} row '${row.id}' is a ${kind} ${row.refundId === null ? "without" : "with"} a refund; the entries of a refund name it, and no other entry does.`
+    );
+  }
+  if (REVERSAL_ENTRY_KINDS.has(kind) !== (row.reversalId !== null)) {
+    throw new Error(
+      `${CREDIT_ENTRIES} row '${row.id}' is a ${kind} ${row.reversalId === null ? "without" : "with"} a reversal; the entries of a reversal name it, and no other entry does.`
+    );
+  }
+  return {
+    id: row.id,
+    creditId: row.creditId,
+    kind,
+    amount: columnAmountOf(row.amount, where("amount")),
+    refundId: row.refundId,
+    reversalId: row.reversalId,
+    reference: row.reference,
+    paidOn,
+    recordedBy: row.recordedBy,
+    note: row.note,
+    recordedAt: row.recordedAt
+  };
+}
+function refundEntryColumns(creditId, refund, kind, amount, at) {
+  return {
+    creditId,
+    kind,
+    amount: toDecimalString(amount),
+    refundId: refund.id,
+    reversalId: null,
+    reference: refund.gatewayRef,
+    paidOn: null,
+    recordedBy: null,
+    note: null,
+    recordedAt: at
+  };
+}
+function payoutEntryColumns(payout) {
+  return {
+    creditId: payout.creditId,
+    kind: "PAYOUT",
+    amount: toDecimalString(payout.amount),
+    refundId: null,
+    reversalId: null,
+    reference: payout.reference,
+    paidOn: payout.paidOn,
+    recordedBy: payout.recordedBy,
+    note: payout.note,
+    recordedAt: payout.at
+  };
+}
+function toSubscriberRefundRecord(row) {
+  const where = (column) => ({ table: REFUNDS, column, id: row.id });
+  const status = oneOf(SUBSCRIBER_REFUND_STATUSES, row.status, where("status"));
+  if (isEndedRefund(status) !== (row.endedAt !== null)) {
+    throw new Error(
+      `${REFUNDS}.endedAt of ${row.id} does not fit its status ${status}: a refund that failed or was canceled carries when, and one that pays out does not.`
+    );
+  }
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    paymentId: row.paymentId,
+    gatewayAccount: row.gatewayAccount,
+    gatewayRef: row.gatewayRef,
+    amount: columnAmountOf(row.amount, where("amount")),
+    currency: row.currency,
+    status,
+    recordedAt: row.recordedAt,
+    endedAt: row.endedAt
+  };
+}
+function subscriberRefundColumns(refund, payment) {
+  return {
+    subscriberId: payment.subscriberId,
+    paymentId: payment.id,
+    gatewayAccount: refund.gatewayAccount,
+    gatewayRef: refund.gatewayRef,
+    amount: toDecimalString(refund.amount),
+    currency: refund.currency,
+    status: refund.status,
+    recordedAt: refund.at,
+    endedAt: isEndedRefund(refund.status) ? refund.at : null
+  };
+}
+function reversalEntryColumns(creditId, reversal, kind, amount, at) {
+  return {
+    creditId,
+    kind,
+    amount: toDecimalString(amount),
+    refundId: null,
+    reversalId: reversal.id,
+    reference: reversal.gatewayRef,
+    paidOn: null,
+    recordedBy: null,
+    note: null,
+    recordedAt: at
+  };
+}
+function toSubscriberReversalRecord(row) {
+  const where = (column) => ({ table: REVERSALS, column, id: row.id });
+  const amount = columnAmountOf(row.amount, where("amount"));
+  const fromCredit = columnAmountOf(row.fromCredit, where("fromCredit"));
+  const reinstated = columnAmountOf(row.reinstated, where("reinstated"));
+  const within = (part) => part >= 0 && toCents(part) <= toCents(amount);
+  if (!within(fromCredit) || !within(reinstated)) {
+    throw new Error(
+      `${REVERSALS} row '${row.id}' takes ${fromCredit} from the credit and is given back ${reinstated} of the ${amount} it withdrew; each is a part of it.`
+    );
+  }
+  if (reinstated > 0 !== (row.reinstatedAt !== null)) {
+    throw new Error(
+      `${REVERSALS}.reinstatedAt of ${row.id} does not fit what was given back of it: a reversal given something back carries when, and one given nothing does not.`
+    );
+  }
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    tenantId: row.tenantId,
+    paymentId: row.paymentId,
+    gatewayAccount: row.gatewayAccount,
+    gatewayRef: row.gatewayRef,
+    amount,
+    currency: row.currency,
+    fromCredit,
+    reinstated,
+    recordedAt: row.recordedAt,
+    reinstatedAt: row.reinstatedAt
+  };
+}
+function subscriberReversalColumns(reversal, payment) {
+  return {
+    subscriberId: payment.subscriberId,
+    tenantId: payment.tenantId,
+    paymentId: payment.id,
+    gatewayAccount: reversal.gatewayAccount,
+    gatewayRef: reversal.gatewayRef,
+    amount: toDecimalString(0),
+    currency: reversal.currency,
+    fromCredit: toDecimalString(0),
+    reinstated: toDecimalString(0),
+    recordedAt: reversal.at,
+    reinstatedAt: null
+  };
+}
+
+// src/subscriber-payment-rules.ts
+function owedOn(gross, settled) {
+  const paid = settled.reduce((sum2, amount) => sum2 + toCents(amount), 0);
+  return (toCents(gross) - paid) / 100;
+}
+function paymentSettlement(amount, owed) {
+  const brought = toCents(amount);
+  const settles = Math.min(brought, Math.max(0, toCents(owed)));
+  return { settles: settles / 100, credits: (brought - settles) / 100 };
+}
+var GIVING_BACK_CREDIT_ENTRY_KINDS = [
+  "REFUND_FAILED",
+  "REVERSAL_TAKEN_BACK"
+];
+var GIVING_BACK = new Set(GIVING_BACK_CREDIT_ENTRY_KINDS);
+function paidOutBy(entry) {
+  const cents2 = toCents(entry.amount);
+  return GIVING_BACK.has(entry.kind) ? -cents2 : cents2;
+}
+function openOfCredit(amount, entries) {
+  const paidOut = entries.reduce((sum2, entry) => sum2 + paidOutBy(entry), 0);
+  return Math.max(0, toCents(amount) - paidOut) / 100;
+}
+function refundParts(amount, paymentId, credits) {
+  const ownFirst = [...credits].sort(
+    (a, b) => rankFor(a, paymentId) - rankFor(b, paymentId) || a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id, "en")
+  );
+  let left = toCents(amount);
+  const parts = [];
+  for (const credit of ownFirst) {
+    if (left === 0) break;
+    const taken = Math.min(left, toCents(credit.open));
+    if (taken <= 0) continue;
+    parts.push({ creditId: credit.id, amount: taken / 100 });
+    left -= taken;
+  }
+  return { parts, unmatched: left / 100 };
+}
+function rankFor(credit, paymentId) {
+  return credit.origin.kind === "payment" && credit.origin.paymentId === paymentId ? 0 : 1;
+}
+function withdrawalParts(amount, credit, invoices, covering = []) {
+  let left = toCents(amount);
+  const share = credit ? Math.min(left, Math.max(0, toCents(credit.left))) : 0;
+  const open = credit ? Math.min(share, Math.max(0, toCents(credit.open))) : 0;
+  left -= share;
+  const opening = [];
+  for (const invoice of invoices) {
+    if (left === 0) break;
+    const taken = Math.min(left, Math.max(0, toCents(invoice.left)));
+    if (taken === 0) continue;
+    opening.push({ invoiceId: invoice.invoiceId, cents: taken });
+    left -= taken;
+  }
+  let toCover = opening.reduce((sum2, each) => sum2 + each.cents, 0);
+  const covered = [];
+  for (const other of covering) {
+    if (toCover === 0) break;
+    const taken = Math.min(toCover, Math.max(0, toCents(other.open)));
+    if (taken === 0) continue;
+    covered.push({ creditId: other.creditId, amount: taken / 100 });
+    toCover -= taken;
+  }
+  let coveredCents = opening.reduce((sum2, each) => sum2 + each.cents, 0) - toCover;
+  const opened = [];
+  for (const each of opening) {
+    const kept = Math.min(each.cents, coveredCents);
+    coveredCents -= kept;
+    if (each.cents > kept) {
+      opened.push({ invoiceId: each.invoiceId, amount: (each.cents - kept) / 100 });
+    }
+  }
+  return {
+    fromCredit: share / 100,
+    credit: credit && open > 0 ? { creditId: credit.creditId, amount: open / 100 } : null,
+    covering: covered,
+    invoices: opened,
+    unmatched: (share - open + left) / 100
+  };
+}
+function reinstatementParts(amount, took) {
+  let left = toCents(amount);
+  const covered = Math.min(left, Math.max(0, toCents(took.unmatched)));
+  left -= covered;
+  const credits = [];
+  for (const credit of took.credits) {
+    const given = Math.min(left, Math.max(0, toCents(credit.left)));
+    if (given === 0) continue;
+    credits.push({ creditId: credit.creditId, amount: given / 100 });
+    left -= given;
+  }
+  const invoices = [];
+  let credited = 0;
+  for (const invoice of took.invoices) {
+    const given = Math.min(left, Math.max(0, toCents(invoice.left)));
+    if (given === 0) continue;
+    const settles = Math.min(given, Math.max(0, toCents(invoice.owed)));
+    if (settles > 0) invoices.push({ invoiceId: invoice.invoiceId, amount: settles / 100 });
+    credited += given - settles;
+    left -= given;
+  }
+  return {
+    covered: covered / 100,
+    credits,
+    invoices,
+    credited: credited / 100,
+    beyond: left / 100
+  };
+}
+function netByInvoice(entries) {
+  const net = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    net.set(entry.invoiceId, (net.get(entry.invoiceId) ?? 0) + toCents(entry.amount));
+  }
+  return [...net].map(([invoiceId, cents2]) => ({ invoiceId, amount: cents2 / 100 }));
+}
+function paidOutByCredit(entries) {
+  const paid = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    paid.set(entry.creditId, (paid.get(entry.creditId) ?? 0) + paidOutBy(entry));
+  }
+  return [...paid].map(([creditId, cents2]) => ({ creditId, amount: cents2 / 100 }));
+}
+function coversOf(entries, own) {
+  const taken = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.reversalId === null || own.has(entry.reversalId)) continue;
+    taken.set(entry.reversalId, (taken.get(entry.reversalId) ?? 0) + paidOutBy(entry));
+  }
+  return [...taken].filter(([, cents2]) => cents2 > 0).map(([reversalId, cents2]) => ({ reversalId, amount: cents2 / 100 }));
+}
+function coversLifted(parts, covers) {
+  let reach = toCents(parts.fromCredit) - toCents(parts.credit?.amount ?? 0);
+  const lifted = [];
+  for (const cover of covers) {
+    if (reach <= 0) break;
+    const taken = Math.min(reach, toCents(cover.amount));
+    if (taken <= 0) continue;
+    lifted.push({ reversalId: cover.reversalId, amount: taken / 100 });
+    reach -= taken;
+  }
+  const liftedCents = lifted.reduce((sum2, each) => sum2 + toCents(each.amount), 0);
+  return { lifted, unmatched: (toCents(parts.unmatched) - liftedCents) / 100 };
+}
+function inWithdrawalOrder(parts, credits, paymentId) {
+  const byId = new Map(credits.map((credit) => [credit.id, credit]));
+  const rank = (part) => {
+    const credit = byId.get(part.creditId);
+    if (!credit) return [2, 0, part.creditId];
+    const own = credit.origin.kind === "payment" && credit.origin.paymentId === paymentId;
+    return [own ? 0 : 1, credit.createdAt.getTime(), credit.id];
+  };
+  return [...parts].sort((a, b) => {
+    const [x, y] = [rank(a), rank(b)];
+    return x[0] - y[0] || x[1] - y[1] || x[2].localeCompare(y[2], "en");
+  });
+}
+function casesCovered(cases, covered) {
+  const limit = toCents(covered);
+  let running = 0;
+  const ids = [];
+  for (const each of cases) {
+    running += toCents(each.amount);
+    if (running <= limit) ids.push(each.id);
+  }
+  return ids;
+}
+
+// src/subscriber-reconciliation.types.ts
+var RECONCILIATION_READ_CAPABILITY = "reconciliation.read";
+var RECONCILIATION_CLOSE_CAPABILITY = "reconciliation.close";
+var SUBSCRIBER_PAYMENTS_CAPABILITY = "payments.read";
+var RECONCILIATION_NOTE_MAX_LENGTH = 500;
+
+// src/subscriber-reconciliation-mapping.ts
+var CASES2 = "subscriber_reconciliation_cases";
+var RECONCILIATION_CASE_KINDS = [
+  "REFUND_UNMATCHED",
+  "REVERSAL_UNMATCHED"
+];
+function toSubscriberReconciliationCaseRecord(row) {
+  const where = (column) => ({ table: CASES2, column, id: row.id });
+  const kind = oneOf(RECONCILIATION_CASE_KINDS, row.kind, where("kind"));
+  const aboutRefund = kind === "REFUND_UNMATCHED";
+  if (aboutRefund !== (row.refundId !== null) || aboutRefund === (row.reversalId !== null)) {
+    throw new Error(
+      `${CASES2} row '${row.id}' is a ${kind} naming ${row.refundId === null ? "no" : "a"} refund and ${row.reversalId === null ? "no" : "a"} reversal; a case names what it is about, and nothing else.`
+    );
+  }
+  if (row.closedAt === null !== (row.note === null)) {
+    throw new Error(
+      `${CASES2} row '${row.id}' is ${row.closedAt === null ? "open with" : "closed without"} a note; a case is closed with one, and an open case carries none.`
+    );
+  }
+  if (row.closedAt === null && row.closedBy !== null) {
+    throw new Error(`${CASES2} row '${row.id}' is open and names who closed it.`);
+  }
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    tenantId: row.tenantId,
+    kind,
+    amount: columnAmountOf(row.amount, where("amount")),
+    currency: row.currency,
+    paymentId: row.paymentId,
+    refundId: row.refundId,
+    reversalId: row.reversalId,
+    gatewayAccount: row.gatewayAccount,
+    gatewayRef: row.gatewayRef,
+    recordedAt: row.recordedAt,
+    closedAt: row.closedAt,
+    closedBy: row.closedBy,
+    note: row.note
+  };
+}
+function reconciliationCaseColumns(opened) {
+  const aboutRefund = opened.kind === "REFUND_UNMATCHED";
+  return {
+    subscriberId: opened.payment.subscriberId,
+    tenantId: opened.payment.tenantId,
+    kind: opened.kind,
+    amount: toDecimalString(opened.amount),
+    currency: opened.currency,
+    paymentId: opened.payment.id,
+    refundId: aboutRefund ? opened.about.id : null,
+    reversalId: aboutRefund ? null : opened.about.id,
+    gatewayAccount: opened.about.gatewayAccount,
+    gatewayRef: opened.about.gatewayRef,
+    recordedAt: opened.at,
+    closedAt: null,
+    closedBy: null,
+    note: null
+  };
+}
+var CASE_CLOSED_REFUND_ENDED = "The refund failed or was canceled, and its money came back.";
+var CASE_CLOSED_REVERSAL_GIVEN_BACK = "The gateway gave the reversal back, and with it what matched nothing.";
+
+// 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}`;
+}
+function toSubscriberRecord(row, tenantId) {
+  return {
+    id: row.id,
+    customerNumber: formatCustomerNumber(row.customerNumberPrefix, row.customerSequence),
+    legalName: row.legalName,
+    addressLine1: row.addressLine1,
+    addressLine2: row.addressLine2,
+    postalCode: row.postalCode,
+    city: row.city,
+    country: row.country,
+    vatId: row.vatId,
+    taxNumber: row.taxNumber,
+    invoiceEmail: row.invoiceEmail,
+    business: row.business,
+    tenantId,
+    migrated: row.migrated,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function toSubscriberCorrectionRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    previous: toIdentityValues(row.previous),
+    corrected: toIdentityValues(row.corrected),
+    reason: row.reason,
+    correctedBy: row.correctedBy,
+    correctedAt: row.correctedAt
+  };
+}
+function toSubscriberTaxOriginChangeRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    previous: toTaxOriginValues(row.previous),
+    changed: toTaxOriginValues(row.changed),
+    changedBy: row.changedBy,
+    changedAt: row.changedAt,
+    reason: row.reason
+  };
+}
+function identityCorrectionDelta(current, corrected) {
+  const previous = {};
+  const next = {};
+  for (const field of LEGAL_IDENTITY_FIELDS) {
+    const value = corrected[field];
+    if (value === void 0 || value === current[field]) continue;
+    previous[field] = current[field];
+    next[field] = value;
+  }
+  return {
+    previous,
+    corrected: next
+  };
+}
+function contractPartiesOf(subscriber, issuer) {
+  const party = {
+    customerNumber: subscriber.customerNumber,
+    legalName: subscriber.legalName,
+    vatId: subscriber.vatId,
+    taxNumber: subscriber.taxNumber,
+    addressLine1: subscriber.addressLine1,
+    addressLine2: subscriber.addressLine2,
+    postalCode: subscriber.postalCode,
+    city: subscriber.city,
+    country: subscriber.country
+  };
+  return {
+    subscriberId: subscriber.id,
+    subscriber: party,
+    issuer: issuer ? issuerPartyOf(issuer) : null
+  };
+}
+function issuerPartyOf(issuer) {
+  const identity = issuerIdentityOf(issuer);
+  return {
+    legalName: identity?.legalName ?? "",
+    vatId: identity?.vatId ?? null,
     taxNumber: identity?.taxNumber ?? null,
     // Settled like the three above rather than copied verbatim: one copy
     // whose halves were settled differently is a row that reads two ways,
@@ -2504,75 +4286,6 @@ function toIdentityValues(value) {
   return values;
 }
 
-// src/subscriber-payment-method-mapping.ts
-var PAYMENT_METHOD_TYPES = ["card", "sepa_debit"];
-var STATUSES = ["ACTIVE", "REPLACED"];
-var TABLE3 = "subscriber_payment_methods";
-function toSubscriberPaymentMethodRecord(row) {
-  return {
-    id: row.id,
-    subscriberId: row.subscriberId,
-    gatewayAccount: row.gatewayAccount,
-    provider: row.provider,
-    customerRef: row.customerRef,
-    paymentMethodRef: row.paymentMethodRef,
-    type: oneOf(PAYMENT_METHOD_TYPES, row.type, { table: TABLE3, column: "type", id: row.id }),
-    brand: row.brand,
-    last4: row.last4,
-    expiryMonth: row.expiryMonth,
-    expiryYear: row.expiryYear,
-    country: row.country,
-    bankCode: row.bankCode,
-    mandateReference: row.mandateReference,
-    status: oneOf(STATUSES, row.status, { table: TABLE3, column: "status", id: row.id }),
-    confirmedAt: row.confirmedAt,
-    replacedAt: row.replacedAt,
-    createdAt: row.createdAt
-  };
-}
-function subscriberPaymentMethodColumns(data) {
-  return {
-    subscriberId: data.subscriberId,
-    gatewayAccount: data.gatewayAccount,
-    provider: data.provider,
-    customerRef: data.customerRef,
-    paymentMethodRef: data.paymentMethodRef,
-    type: data.type,
-    brand: data.brand,
-    last4: data.last4,
-    expiryMonth: data.expiryMonth,
-    expiryYear: data.expiryYear,
-    country: data.country,
-    bankCode: data.bankCode,
-    mandateReference: data.mandateReference,
-    confirmedAt: data.confirmedAt
-  };
-}
-var FOREIGN_PAYMENT_METHOD_REFERENCE = "FOREIGN_PAYMENT_METHOD_REFERENCE";
-var ForeignPaymentMethodReferenceError = class extends Error {
-  constructor(gatewayAccount, paymentMethodRef) {
-    super(
-      `Payment method '${paymentMethodRef}' of account '${gatewayAccount}' belongs to another subscriber. A reference belongs to exactly one, so it is not handed out.`
-    );
-    this.gatewayAccount = gatewayAccount;
-    this.paymentMethodRef = paymentMethodRef;
-    this.name = "ForeignPaymentMethodReferenceError";
-  }
-  gatewayAccount;
-  paymentMethodRef;
-  code = FOREIGN_PAYMENT_METHOD_REFERENCE;
-};
-function isForeignPaymentMethodReferenceError(error) {
-  return error instanceof Error && error.code === FOREIGN_PAYMENT_METHOD_REFERENCE;
-}
-function refuseForeignPaymentMethodReference(recorded, subscriberId) {
-  if (recorded.subscriberId === subscriberId) return;
-  throw new ForeignPaymentMethodReferenceError(
-    recorded.gatewayAccount,
-    recorded.paymentMethodRef
-  );
-}
-
 // src/subscription-bundle-mapping.ts
 var BILLING_CYCLES = ["MONTHLY", "YEARLY"];
 function toSubscriptionBundleRecord(row) {
@@ -2922,6 +4635,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 +4694,23 @@ 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_MANDATE_MISSING: "Die Lastschrift {paymentMethodId} nennt keine Mandatsreferenz, die vor dem Einzug angek\xFCndigt werden muss. Die Rechnung wartet, bis die Zahlungsart ersetzt ist.",
+  SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD: "Der Abonnent {subscriberId} hat keine Zahlungsart in Gebrauch. Die Rechnung wird eingezogen, sobald er eine hat.",
+  SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD: "Die Lastschrift wird angek\xFCndigt, sobald dem Abonnenten mitgeteilt ist, dass der Einzug {attemptKey} gescheitert ist.",
+  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.",
+  SUBSCRIBER_CREDIT_NOT_FOUND: "Kein Guthaben '{creditId}' des Abonnenten dieses Mandanten.",
+  SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT: "Vom Guthaben {creditId} sind noch {open} offen; mehr wird nicht ausgezahlt, und nichts wurde erfasst.",
+  SUBSCRIBER_PAYOUT_NOT_MADE_YET: "Eine Auszahlung wird erfasst, wenn sie erfolgt ist: {paidOn} liegt nach heute, {today}.",
+  SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND: "Kein abzugleichender Fall '{caseId}'.",
+  SUBSCRIBER_RECONCILIATION_CASE_CLOSED: "Der Fall {caseId} wurde am {closedAt} geschlossen; seine Notiz bleibt, und nichts wurde erfasst.",
   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.",
@@ -3053,16 +4800,37 @@ export {
   ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES,
   AUTH_ERROR_CODES,
   BILLING_ERROR_CODES,
+  BLOCKING_COLLECTION_STATUSES,
   BUNDLE_PRICE_LOOKUP_LIMIT,
   BUNDLE_VERSION_RETIREMENT_CAPABILITY,
+  CASE_CLOSED_REFUND_ENDED,
+  CASE_CLOSED_REVERSAL_GIVEN_BACK,
   CATALOGUE_KEYS,
   CATALOG_ERROR_CODES,
+  COLLECTION_FAILURE_REASONS,
+  COLLECTION_NOT_SENT_PAID,
+  COLLECTION_NOT_SENT_REVERSED,
+  COLLECTION_RETRY_AFTER_DAYS,
   CONTRACT_ERROR_CODES,
   CUSTOM_LIMITS_KEYS,
+  DIRECT_DEBIT_LEAD_DAYS,
+  ENDED_REFUND_STATUSES,
   ERROR_MESSAGES_DE,
   ERROR_MESSAGES_EN,
   FEATURE_NOT_LICENSED,
+  FEATURE_WITHDRAWAL_CAPABILITY,
+  FEATURE_WITHDRAWAL_REASON_MAX_LENGTH,
+  FOLLOWED_UP_COLLECTION_STATUSES,
   ForeignPaymentMethodReferenceError,
+  GIVING_BACK_CREDIT_ENTRY_KINDS,
+  INVOICE_ARCHIVE_TRIGGERS,
+  INVOICE_COLLECTION_ASK_EVERY_MS,
+  INVOICE_COLLECTION_LEASE_MS,
+  INVOICE_COLLECTION_STATUSES,
+  INVOICE_DOCUMENT_CAPABILITY,
+  INVOICE_ERROR_CODES,
+  INVOICE_SEQUENCE_DIGITS,
+  INVOICE_SETTLEMENT_KINDS,
   LEGAL_IDENTITY_FIELDS,
   MAINTENANCE_CAPABILITY,
   MAINTENANCE_ERROR_CODES,
@@ -3088,24 +4856,41 @@ export {
   PersistenceCapabilityError,
   PersistenceRefusal,
   PlatformUserExistsError,
+  RECONCILIATION_CASE_KINDS,
+  RECONCILIATION_CLOSE_CAPABILITY,
+  RECONCILIATION_NOTE_MAX_LENGTH,
+  RECONCILIATION_READ_CAPABILITY,
   REGISTRATION_ERROR_CODES,
   REGISTRATION_RESUME_TTL_MINUTES,
   REGISTRATION_STEP_BY_STATUS,
+  REOPENING_SETTLEMENT_KINDS,
   RETIREMENT_REMINDER_LEAD_DAYS,
+  REVERSIBLE_COLLECTION_STATUSES,
   SETTINGS_ERROR_CODES,
   SETUP_ERROR_CODES,
   SUBSCRIBER_ACCOUNT_CAPABILITY,
   SUBSCRIBER_ATTENTION_CAPABILITY,
   SUBSCRIBER_ATTENTION_PAGE_SIZE,
+  SUBSCRIBER_CHARGE_ORIGINS,
+  SUBSCRIBER_CHARGE_SOURCES,
   SUBSCRIBER_CORRECTION_CAPABILITY,
+  SUBSCRIBER_CREDIT_CAPABILITY,
+  SUBSCRIBER_CREDIT_ENTRY_KINDS,
   SUBSCRIBER_ERROR_CODES,
   SUBSCRIBER_INVOICE_ADDRESS_FIELDS,
+  SUBSCRIBER_PAYMENTS_CAPABILITY,
+  SUBSCRIBER_PAYOUT_CAPABILITY,
+  SUBSCRIBER_REFUND_STATUSES,
   SUBSCRIBER_STANDING_CAPABILITY,
   SUBSCRIBER_TAX_ORIGIN_FIELDS,
   TAX_ERROR_CODES,
   TAX_TREATMENT_KINDS,
+  UNSETTLED_COLLECTION_STATUSES,
   VERSION_RETIREMENT_CAPABILITY,
+  addDaysToDay,
+  announcedCollectionDay,
   applyPromo,
+  asXmlReadsIt,
   assertPersistenceCapabilities,
   buildActivePlanVersionWhere,
   buildActiveVersionWhere,
@@ -3115,38 +4900,69 @@ export {
   bundleStemDefaults,
   canonicalJson,
   canonicalVatId,
+  casesCovered,
   catalogDraftExists,
   catalogVersionAlreadyPublished,
   catalogVersionGone,
+  chargedAgainOn,
   classifyBundleVersionDiff,
   classifyIssuerChange,
   classifyPlanDiff,
   classifyVersionOffer,
   collectUnsatisfiedRequires,
+  collectionAttemptKey,
+  collectionOutcomeColumns,
+  collectionStatusOf,
+  columnAmountOf,
   computeIncludedVat,
   concurrencyGate,
   concurrencyGateOf,
   contractPartiesOf,
   coverageExcludingSelf,
+  coversLifted,
+  coversOf,
   customLimitsReader,
+  dayInZone,
   definedFields,
   diffSettings,
+  directDebitLeadDaysOf,
+  draftSubscriptionInvoice,
+  endedAtOnceSubjectOf,
+  featureWithdrawalRowOf,
+  featuresWithdrawnAt,
   formatCustomerNumber,
   formatErrorMessage,
+  formatInvoiceNumber,
   grossFromNet,
+  holdsOnlyXmlCharacters,
   identityCorrectionDelta,
+  inWithdrawalOrder,
+  invoiceArchiveProtectionProblem,
+  invoiceCollectionColumns,
+  invoiceContentDraftOf,
+  invoiceFooterOf,
+  invoiceGroupsOf,
+  invoiceIssuerOf,
+  invoicePaymentOf,
   isBundleRedundant,
+  isChargedAgain,
+  isEndedRefund,
+  isFeatureWithdrawnAt,
   isForeignPaymentMethodReferenceError,
+  isInvoiceDocumentChecksum,
   isMaintenanceAnnouncementLapsed,
   isMaintenanceOverrun,
   isPaymentCallbackRejectedError,
   isPersistenceRefusal,
   isPlatformUserExistsError,
+  isRetryableCollectionFailure,
   isVersionActiveAt,
   isVersionEditable,
   issuerIdentityOf,
   keepOneRecommended,
   keepsVatIdCheck,
+  lastCollectionOf,
+  lastDayInZone,
   maintenanceRetryAfterSeconds,
   maintenanceStatusOf,
   maintenanceWindowStatusOf,
@@ -3155,14 +4971,22 @@ export {
   membersLeftOut,
   missingRequiresFor,
   movedIdentityFields,
+  netByInvoice,
   netFromGross,
+  nextWithdrawalChange,
   noActivePlanVersion,
+  openOfCredit,
+  owedOn,
+  paidOutByCredit,
   parseZonedInstant,
+  paymentSettlement,
+  payoutEntryColumns,
   percentOf,
   pickActivePromo,
   planCatalogSettingsOf,
   planKeyTaken,
   planNotInCatalog,
+  plannedCollectionColumns,
   previousUtcDay,
   promoCodeTaken,
   promoStatus,
@@ -3171,54 +4995,90 @@ export {
   readCustomLimits,
   readQuotaRecord,
   readQuotaValue,
+  reconciliationCaseColumns,
   recordedIssuerIdentity,
+  refundEntryColumns,
+  refundParts,
   refuseForeignPaymentMethodReference,
+  refusesFirstAttempt,
+  refusesPlannedAttempt,
+  reinstatementParts,
   resolveBundleAvailability,
   resolveErrorMessage,
   retirementCostsTheSubscription,
   retirementReminderDueAt,
   retirementReminderIsDue,
   retirementSwitchTerms,
+  reversalEntryColumns,
   roundToCents,
   sameLegalIdentity,
   scheduledChangeAfterWrite,
   selectChargeableBundles,
+  sentCollectionOf,
   settingsSubtreeOf,
+  settledAmountOf,
   startOfUtcDay,
   subscriberChargeColumns,
   subscriberFromRegistration,
+  subscriberPaymentColumns,
   subscriberPaymentMethodColumns,
+  subscriberRefundColumns,
+  subscriberReversalColumns,
   subscriptionBundleAlreadyCancelled,
   subscriptionBundleGone,
   subscriptionContractGone,
   subscriptionGone,
+  subscriptionInvoiceChargeInvoiced,
+  subscriptionInvoiceColumns,
+  subscriptionInvoiceDocumentChanged,
+  subscriptionInvoiceLineColumns,
   sumToCents,
   taxOriginOf,
   taxOriginWrite,
+  taxPerRate,
   taxTreatmentToJson,
+  toArchivedInvoiceDocument,
   toBundleStemRow,
   toBundleVersionRetirementRecord,
   toCents,
+  toCollectionAnnouncedNotice,
+  toCollectionFailedNotice,
+  toCollectionReversedNotice,
   toContractLineItemRecord,
   toDecimalString,
+  toFeatureWithdrawalRecord,
+  toInvoiceCollectionRecord,
   toMaintenanceWindowRecord,
   toPlanRow,
   toPlanVersionRow,
   toRunningContractIssuer,
   toSubscriberChargeRecord,
   toSubscriberCorrectionRecord,
+  toSubscriberCreditEntryRecord,
+  toSubscriberCreditRecord,
   toSubscriberPaymentMethodRecord,
+  toSubscriberPaymentRecord,
+  toSubscriberReconciliationCaseRecord,
   toSubscriberRecord,
+  toSubscriberRefundRecord,
+  toSubscriberReversalRecord,
   toSubscriberTaxOriginChangeRecord,
   toSubscriberVatIdCheckRecord,
   toSubscriptionBundleRecord,
   toSubscriptionContractRecord,
+  toSubscriptionInvoiceDocumentRecord,
+  toSubscriptionInvoiceRecord,
   toSubscriptionNoticeRecord,
   toTaxOriginValues,
   toTaxTreatment,
   toVersionRetirementRecord,
+  utcMidnightOf,
+  vatCategoryOf,
   vatIdCheckFromStore,
   versionOnSale,
   versionOnSaleOrNext,
-  versionSale
+  versionSale,
+  withdrawalParts,
+  withdrawnFeaturesOf,
+  yearOfDay
 };