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

package/dist/index.cjs

@@ -24,6 +24,7 @@ __export(index_exports, {
   AUTH_ERROR_CODES: () => AUTH_ERROR_CODES,
   BILLING_ERROR_CODES: () => BILLING_ERROR_CODES,
   BUNDLE_PRICE_LOOKUP_LIMIT: () => BUNDLE_PRICE_LOOKUP_LIMIT,
+  BUNDLE_VERSION_RETIREMENT_CAPABILITY: () => BUNDLE_VERSION_RETIREMENT_CAPABILITY,
   CATALOGUE_KEYS: () => CATALOGUE_KEYS,
   CATALOG_ERROR_CODES: () => CATALOG_ERROR_CODES,
   CONTRACT_ERROR_CODES: () => CONTRACT_ERROR_CODES,
@@ -31,7 +32,13 @@ __export(index_exports, {
   ERROR_MESSAGES_DE: () => ERROR_MESSAGES_DE,
   ERROR_MESSAGES_EN: () => ERROR_MESSAGES_EN,
   FEATURE_NOT_LICENSED: () => FEATURE_NOT_LICENSED,
+  FEATURE_WITHDRAWAL_CAPABILITY: () => FEATURE_WITHDRAWAL_CAPABILITY,
+  FEATURE_WITHDRAWAL_REASON_MAX_LENGTH: () => FEATURE_WITHDRAWAL_REASON_MAX_LENGTH,
   ForeignPaymentMethodReferenceError: () => ForeignPaymentMethodReferenceError,
+  INVOICE_ARCHIVE_TRIGGERS: () => INVOICE_ARCHIVE_TRIGGERS,
+  INVOICE_DOCUMENT_CAPABILITY: () => INVOICE_DOCUMENT_CAPABILITY,
+  INVOICE_ERROR_CODES: () => INVOICE_ERROR_CODES,
+  INVOICE_SEQUENCE_DIGITS: () => INVOICE_SEQUENCE_DIGITS,
   LEGAL_IDENTITY_FIELDS: () => LEGAL_IDENTITY_FIELDS,
   MAINTENANCE_CAPABILITY: () => MAINTENANCE_CAPABILITY,
   MAINTENANCE_ERROR_CODES: () => MAINTENANCE_ERROR_CODES,
@@ -64,9 +71,21 @@ __export(index_exports, {
   SETTINGS_ERROR_CODES: () => SETTINGS_ERROR_CODES,
   SETUP_ERROR_CODES: () => SETUP_ERROR_CODES,
   SUBSCRIBER_ACCOUNT_CAPABILITY: () => SUBSCRIBER_ACCOUNT_CAPABILITY,
+  SUBSCRIBER_ATTENTION_CAPABILITY: () => SUBSCRIBER_ATTENTION_CAPABILITY,
+  SUBSCRIBER_ATTENTION_PAGE_SIZE: () => SUBSCRIBER_ATTENTION_PAGE_SIZE,
+  SUBSCRIBER_CHARGE_ORIGINS: () => SUBSCRIBER_CHARGE_ORIGINS,
+  SUBSCRIBER_CHARGE_SOURCES: () => SUBSCRIBER_CHARGE_SOURCES,
+  SUBSCRIBER_CORRECTION_CAPABILITY: () => SUBSCRIBER_CORRECTION_CAPABILITY,
   SUBSCRIBER_ERROR_CODES: () => SUBSCRIBER_ERROR_CODES,
+  SUBSCRIBER_INVOICE_ADDRESS_FIELDS: () => SUBSCRIBER_INVOICE_ADDRESS_FIELDS,
+  SUBSCRIBER_STANDING_CAPABILITY: () => SUBSCRIBER_STANDING_CAPABILITY,
+  SUBSCRIBER_TAX_ORIGIN_FIELDS: () => SUBSCRIBER_TAX_ORIGIN_FIELDS,
+  TAX_ERROR_CODES: () => TAX_ERROR_CODES,
+  TAX_TREATMENT_KINDS: () => TAX_TREATMENT_KINDS,
   VERSION_RETIREMENT_CAPABILITY: () => VERSION_RETIREMENT_CAPABILITY,
+  addDaysToDay: () => addDaysToDay,
   applyPromo: () => applyPromo,
+  asXmlReadsIt: () => asXmlReadsIt,
   assertPersistenceCapabilities: () => assertPersistenceCapabilities,
   buildActivePlanVersionWhere: () => buildActivePlanVersionWhere,
   buildActiveVersionWhere: () => buildActiveVersionWhere,
@@ -75,6 +94,7 @@ __export(index_exports, {
   bundleKeyTaken: () => bundleKeyTaken,
   bundleStemDefaults: () => bundleStemDefaults,
   canonicalJson: () => canonicalJson,
+  canonicalVatId: () => canonicalVatId,
   catalogDraftExists: () => catalogDraftExists,
   catalogVersionAlreadyPublished: () => catalogVersionAlreadyPublished,
   catalogVersionGone: () => catalogVersionGone,
@@ -89,14 +109,28 @@ __export(index_exports, {
   contractPartiesOf: () => contractPartiesOf,
   coverageExcludingSelf: () => coverageExcludingSelf,
   customLimitsReader: () => customLimitsReader,
+  dayInZone: () => dayInZone,
   definedFields: () => definedFields,
   diffSettings: () => diffSettings,
+  draftSubscriptionInvoice: () => draftSubscriptionInvoice,
+  endedAtOnceSubjectOf: () => endedAtOnceSubjectOf,
+  featureWithdrawalRowOf: () => featureWithdrawalRowOf,
+  featuresWithdrawnAt: () => featuresWithdrawnAt,
   formatCustomerNumber: () => formatCustomerNumber,
   formatErrorMessage: () => formatErrorMessage,
+  formatInvoiceNumber: () => formatInvoiceNumber,
   grossFromNet: () => grossFromNet,
+  holdsOnlyXmlCharacters: () => holdsOnlyXmlCharacters,
   identityCorrectionDelta: () => identityCorrectionDelta,
+  invoiceArchiveProtectionProblem: () => invoiceArchiveProtectionProblem,
+  invoiceContentDraftOf: () => invoiceContentDraftOf,
+  invoiceFooterOf: () => invoiceFooterOf,
+  invoiceGroupsOf: () => invoiceGroupsOf,
+  invoiceIssuerOf: () => invoiceIssuerOf,
   isBundleRedundant: () => isBundleRedundant,
+  isFeatureWithdrawnAt: () => isFeatureWithdrawnAt,
   isForeignPaymentMethodReferenceError: () => isForeignPaymentMethodReferenceError,
+  isInvoiceDocumentChecksum: () => isInvoiceDocumentChecksum,
   isMaintenanceAnnouncementLapsed: () => isMaintenanceAnnouncementLapsed,
   isMaintenanceOverrun: () => isMaintenanceOverrun,
   isPaymentCallbackRejectedError: () => isPaymentCallbackRejectedError,
@@ -106,6 +140,8 @@ __export(index_exports, {
   isVersionEditable: () => isVersionEditable,
   issuerIdentityOf: () => issuerIdentityOf,
   keepOneRecommended: () => keepOneRecommended,
+  keepsVatIdCheck: () => keepsVatIdCheck,
+  lastDayInZone: () => lastDayInZone,
   maintenanceRetryAfterSeconds: () => maintenanceRetryAfterSeconds,
   maintenanceStatusOf: () => maintenanceStatusOf,
   maintenanceWindowStatusOf: () => maintenanceWindowStatusOf,
@@ -115,6 +151,7 @@ __export(index_exports, {
   missingRequiresFor: () => missingRequiresFor,
   movedIdentityFields: () => movedIdentityFields,
   netFromGross: () => netFromGross,
+  nextWithdrawalChange: () => nextWithdrawalChange,
   noActivePlanVersion: () => noActivePlanVersion,
   parseZonedInstant: () => parseZonedInstant,
   percentOf: () => percentOf,
@@ -151,11 +188,22 @@ __export(index_exports, {
   subscriptionBundleGone: () => subscriptionBundleGone,
   subscriptionContractGone: () => subscriptionContractGone,
   subscriptionGone: () => subscriptionGone,
+  subscriptionInvoiceChargeInvoiced: () => subscriptionInvoiceChargeInvoiced,
+  subscriptionInvoiceColumns: () => subscriptionInvoiceColumns,
+  subscriptionInvoiceDocumentChanged: () => subscriptionInvoiceDocumentChanged,
+  subscriptionInvoiceLineColumns: () => subscriptionInvoiceLineColumns,
   sumToCents: () => sumToCents,
+  taxOriginOf: () => taxOriginOf,
+  taxOriginWrite: () => taxOriginWrite,
+  taxPerRate: () => taxPerRate,
+  taxTreatmentToJson: () => taxTreatmentToJson,
+  toArchivedInvoiceDocument: () => toArchivedInvoiceDocument,
   toBundleStemRow: () => toBundleStemRow,
+  toBundleVersionRetirementRecord: () => toBundleVersionRetirementRecord,
   toCents: () => toCents,
   toContractLineItemRecord: () => toContractLineItemRecord,
   toDecimalString: () => toDecimalString,
+  toFeatureWithdrawalRecord: () => toFeatureWithdrawalRecord,
   toMaintenanceWindowRecord: () => toMaintenanceWindowRecord,
   toPlanRow: () => toPlanRow,
   toPlanVersionRow: () => toPlanVersionRow,
@@ -164,13 +212,24 @@ __export(index_exports, {
   toSubscriberCorrectionRecord: () => toSubscriberCorrectionRecord,
   toSubscriberPaymentMethodRecord: () => toSubscriberPaymentMethodRecord,
   toSubscriberRecord: () => toSubscriberRecord,
+  toSubscriberTaxOriginChangeRecord: () => toSubscriberTaxOriginChangeRecord,
+  toSubscriberVatIdCheckRecord: () => toSubscriberVatIdCheckRecord,
   toSubscriptionBundleRecord: () => toSubscriptionBundleRecord,
   toSubscriptionContractRecord: () => toSubscriptionContractRecord,
+  toSubscriptionInvoiceDocumentRecord: () => toSubscriptionInvoiceDocumentRecord,
+  toSubscriptionInvoiceRecord: () => toSubscriptionInvoiceRecord,
   toSubscriptionNoticeRecord: () => toSubscriptionNoticeRecord,
+  toTaxOriginValues: () => toTaxOriginValues,
+  toTaxTreatment: () => toTaxTreatment,
   toVersionRetirementRecord: () => toVersionRetirementRecord,
+  utcMidnightOf: () => utcMidnightOf,
+  vatCategoryOf: () => vatCategoryOf,
+  vatIdCheckFromStore: () => vatIdCheckFromStore,
   versionOnSale: () => versionOnSale,
   versionOnSaleOrNext: () => versionOnSaleOrNext,
-  versionSale: () => versionSale
+  versionSale: () => versionSale,
+  withdrawnFeaturesOf: () => withdrawnFeaturesOf,
+  yearOfDay: () => yearOfDay
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -333,6 +392,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()) {
@@ -580,7 +655,13 @@ var TABLE = "subscription_notices";
 var KINDS = {
   "version-offered": true,
   "version-retired": true,
-  "version-retirement-reminder": true
+  "version-retirement-reminder": true,
+  "bundle-version-retired": true,
+  "bundle-version-retirement-reminder": true,
+  "bundle-version-offered": true,
+  "feature-withdrawn": true,
+  "feature-withdrawal-lifted": true,
+  "ended-at-once": true
 };
 function toSubscriptionNoticeRecord(row) {
   return {
@@ -689,6 +770,128 @@ function toVersionRetirementRecord(row) {
   };
 }
 
+// src/bundle-version-retirement.types.ts
+var BUNDLE_VERSION_RETIREMENT_CAPABILITY = "bundleVersions.retire";
+
+// src/bundle-version-retirement-mapping.ts
+function toBundleVersionRetirementRecord(row) {
+  return {
+    id: row.id,
+    retired: {
+      bundleVersionId: row.retiredBundleVersionId,
+      bundleKey: row.retiredBundleKey,
+      version: row.retiredVersion
+    },
+    replacement: {
+      bundleVersionId: row.replacementBundleVersionId,
+      bundleKey: row.replacementBundleKey,
+      version: row.replacementVersion
+    },
+    announcedAt: row.announcedAt,
+    announcedBy: row.announcedBy
+  };
+}
+
+// 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,
@@ -825,6 +1028,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",
@@ -996,6 +1230,13 @@ var CATALOG_ERROR_CODES = {
   PLAN_NOT_FOUND: "PLAN_NOT_FOUND",
   PLAN_VERSION_NOT_FOUND: "PLAN_VERSION_NOT_FOUND",
   BUNDLE_NOT_FOUND: "BUNDLE_NOT_FOUND",
+  /**
+   * Bookings told that their add-on version is being retired have still to
+   * move onto a version of this add-on — waiting for their notice, for their
+   * date, or past it — and a deleted add-on is booked by nothing, the move
+   * included. Carries how many, and the add-on's key.
+   */
+  BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING: "BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING",
   BUNDLE_VERSION_NOT_FOUND: "BUNDLE_VERSION_NOT_FOUND",
   FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND",
   QUOTA_NOT_FOUND: "QUOTA_NOT_FOUND",
@@ -1186,6 +1427,16 @@ var BILLING_ERROR_CODES = {
    * to pick, so the way past it is the add-on ending.
    */
   RETIREMENT_SWITCH_BUNDLE_CANNOT_FOLLOW: "RETIREMENT_SWITCH_BUNDLE_CANNOT_FOLLOW",
+  /**
+   * As `RETIREMENT_SWITCH_BUNDLE_CANNOT_FOLLOW`, where only the version the
+   * add-on continues on from a retirement's date cannot run beside the
+   * replacement's plan. The version it is on can, so cancelling it — it then
+   * ends before that date — lets the switch through. Given while that date
+   * is ahead and the add-on is not cancelled yet; otherwise the earlier code
+   * names the day it can end. Carries the add-on, that version, its date and
+   * the plan.
+   */
+  RETIREMENT_SWITCH_BUNDLE_REPLACEMENT_CANNOT_FOLLOW: "RETIREMENT_SWITCH_BUNDLE_REPLACEMENT_CANNOT_FOLLOW",
   /**
    * The subscription takes no switch now: a change is scheduled, it has
    * ended, or its plan is held for a special contract.
@@ -1196,6 +1447,149 @@ var BILLING_ERROR_CODES = {
    * the retirement as it now stands.
    */
   RETIREMENT_SWITCH_CHANGED: "RETIREMENT_SWITCH_CHANGED",
+  // ── retiring an add-on version for running bookings ──
+  //
+  // An add-on retirement answers with the plan retirement's codes where the
+  // sentence is the same — terms not confirmed, a version named as its own
+  // replacement, twelve months, a preview that changed — and with these
+  // where it names an add-on rather than a plan.
+  /**
+   * The add-on version is still on sale: a booking made after the
+   * announcement would be on it without having been told. Carries the
+   * add-on key and the version.
+   */
+  BUNDLE_RETIREMENT_VERSION_ON_SALE: "BUNDLE_RETIREMENT_VERSION_ON_SALE",
+  /** The replacement is not on sale, so no booking can continue on it. Carries add-on key and version. */
+  BUNDLE_RETIREMENT_REPLACEMENT_NOT_ON_SALE: "BUNDLE_RETIREMENT_REPLACEMENT_NOT_ON_SALE",
+  /**
+   * The replacement is a version of another add-on. A booking continues on
+   * a version of its own add-on, so it stays the same booking with its term.
+   * Carries both add-on keys.
+   */
+  BUNDLE_RETIREMENT_REPLACEMENT_OF_ANOTHER_BUNDLE: "BUNDLE_RETIREMENT_REPLACEMENT_OF_ANOTHER_BUNDLE",
+  /**
+   * Some of the bookings it reaches run, at their date, beside a plan the
+   * replacement cannot run beside: not allowed there, without a price there
+   * in the booking's rhythm, or in a longer rhythm than the plan's. Carries
+   * how many, and the replacement's add-on key and version.
+   */
+  BUNDLE_RETIREMENT_REPLACEMENT_CANNOT_RUN: "BUNDLE_RETIREMENT_REPLACEMENT_CANNOT_RUN",
+  /** No running booking is on the version: there is nobody to tell. Carries add-on key and version. */
+  BUNDLE_RETIREMENT_NOTHING_AFFECTED: "BUNDLE_RETIREMENT_NOTHING_AFFECTED",
+  /**
+   * The booking is on an add-on version being retired, and was cancelled to
+   * end before it would move, so it was never told and nothing moves it.
+   * Reinstated, it would run on past the date on a version nobody sells;
+   * booking the replacement once it has ended is the way. Carries the add-on
+   * key, the version, the replacement's version and the day it can be booked
+   * from.
+   */
+  BUNDLE_RETIREMENT_REINSTATE_REFUSED: "BUNDLE_RETIREMENT_REINSTATE_REFUSED",
+  /**
+   * As `BUNDLE_RETIREMENT_REINSTATE_REFUSED`, where the replacement cannot
+   * run beside the plan the subscription is on when the booking ends, or
+   * beside one it is already set to move to after that, in any rhythm it
+   * could be booked in, so there is no version of the add-on to book.
+   * Carries the add-on key, the version and the replacement's version.
+   */
+  BUNDLE_RETIREMENT_REINSTATE_REPLACEMENT_CANNOT_RUN: "BUNDLE_RETIREMENT_REINSTATE_REPLACEMENT_CANNOT_RUN",
+  /**
+   * As `BUNDLE_RETIREMENT_REINSTATE_REFUSED`, where the subscription ends by
+   * the day the replacement could be booked from, so there is no day to
+   * name. Carries the add-on key, the version and the replacement's version.
+   */
+  BUNDLE_RETIREMENT_REINSTATE_SUBSCRIPTION_ENDS: "BUNDLE_RETIREMENT_REINSTATE_SUBSCRIPTION_ENDS",
+  /**
+   * The plan the add-on runs beside, or the rhythm it is billed in, changes
+   * before the date the booking was told — by a change scheduled, or by a
+   * retirement told that moves the subscription to another plan — so the
+   * price a switch now would hold is not the one the booking pays until
+   * then. Switching once the plan has changed, or waiting for the
+   * date, is the way. Carries the add-on and the date.
+   */
+  BUNDLE_RETIREMENT_SWITCH_PLAN_CHANGES: "BUNDLE_RETIREMENT_SWITCH_PLAN_CHANGES",
+  /**
+   * The add-on version the caller asked to switch a booking to is no longer
+   * the one offered beside it — another is on sale, the booking moved, or
+   * there is no offer. Nothing was switched. Carries the version named
+   * (`bundleVersionId`) and the current `offer`, or `null`, so the page can
+   * 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
@@ -1242,6 +1636,16 @@ var BILLING_ERROR_CODES = {
    * day the booking can end.
    */
   BUNDLE_BOOKING_DOES_NOT_FIT_TARGET_PLAN: "BUNDLE_BOOKING_DOES_NOT_FIT_TARGET_PLAN",
+  /**
+   * A bundle the tenant already holds can run on the plan they are moving
+   * to, but the version it continues on from a retirement's date cannot.
+   * Cancelling it lets the change through at once: the booking then ends
+   * before that date and never reaches the version. Given while that date is
+   * ahead and the booking is not cancelled yet; otherwise
+   * `BUNDLE_BOOKING_DOES_NOT_FIT_TARGET_PLAN` names the day it can end.
+   * Carries the bundle, that version, its date and the plan.
+   */
+  BUNDLE_REPLACEMENT_DOES_NOT_FIT_TARGET_PLAN: "BUNDLE_REPLACEMENT_DOES_NOT_FIT_TARGET_PLAN",
   /**
    * Features of the previewed bundle are already covered by the plan or by
    * another booked bundle. A warning rather than a blocker: paying twice is
@@ -1311,6 +1715,21 @@ var CONTRACT_ERROR_CODES = {
    * describes. Nothing was written; load the offer and conclude it again.
    */
   CHECKOUT_OFFER_CHANGED: "CHECKOUT_OFFER_CHANGED",
+  /**
+   * An offer concludes a tenant's first contract, and this tenant has a
+   * contract in force at the moment the offer's would take effect, or one
+   * beginning after it. Concluded, the two would run side by side. Nothing
+   * was written; a running subscription changes through its plan and its
+   * add-ons. Carries the offer and the contract that runs.
+   */
+  CHECKOUT_OFFER_CONTRACT_IN_FORCE: "CHECKOUT_OFFER_CONTRACT_IN_FORCE",
+  /**
+   * The offer names a version of an add-on the tenant has booked in another
+   * version. Concluded, the contract would name a version the booking is not
+   * on. Nothing was written; a booking changes its version through the offer
+   * beside it. Carries the offer, the add-on, the booking and both versions.
+   */
+  CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION: "CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION",
   SUBSCRIPTION_CONTRACT_NOT_FOUND: "SUBSCRIPTION_CONTRACT_NOT_FOUND",
   NO_ACTIVE_SUBSCRIPTION_CONTRACT: "NO_ACTIVE_SUBSCRIPTION_CONTRACT",
   SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SUBSCRIPTION_CONTRACT_ALREADY_CLOSED",
@@ -1321,7 +1740,61 @@ var CONTRACT_ERROR_CODES = {
    * second attempt, or a contract begins after the moment the successor
    * would take effect. Nothing was written.
    */
-  SUBSCRIPTION_CONTRACT_CHANGED: "SUBSCRIPTION_CONTRACT_CHANGED"
+  SUBSCRIPTION_CONTRACT_CHANGED: "SUBSCRIPTION_CONTRACT_CHANGED",
+  /**
+   * A contract states a tax rate — `field` names where — other than the one
+   * the installation's tax adapter decides for its subscriber.
+   */
+  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED"
+};
+var INVOICE_ERROR_CODES = {
+  /**
+   * A charge already stands on an invoice: a second run issuing the same
+   * charges lost the race. Nothing is written and no number is drawn.
+   */
+  SUBSCRIPTION_INVOICE_CHARGE_INVOICED: "SUBSCRIPTION_INVOICE_CHARGE_INVOICED",
+  /**
+   * The invoice lacks content the tax adapter requires of it — `missing`
+   * names the fields, `adapter` the adapter. It draws no number and waits
+   * until what is missing is supplied (`SC-PRIC-027`).
+   */
+  SUBSCRIPTION_INVOICE_CONTENT_INCOMPLETE: "SUBSCRIPTION_INVOICE_CONTENT_INCOMPLETE",
+  /**
+   * The contract's parties were copied by a migration and the operator has
+   * not confirmed them yet; its charges are not invoiced until then
+   * (`SC-AUD-012`).
+   */
+  SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED: "SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED",
+  /**
+   * A file of the invoice's document has another checksum than the one
+   * recorded or archived for it (`invoiceId`, `recorded`, `rendered`), and
+   * the first stays. The run takes the archived file as the one issued, or —
+   * where nothing is archived — records the new rendering in place of the
+   * old (`SC-AUD-019`); the invoice waits only where another run changed the
+   * record or the archive in between, and the next run settles it.
+   */
+  SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED: "SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED",
+  /**
+   * The tax adapter refuses the rendered document — `missing` names what it
+   * lacks or disagrees with, `adapter` the adapter. The invoice keeps its
+   * number and waits for a document that passes (`SC-PRIC-042`).
+   */
+  SUBSCRIPTION_INVOICE_DOCUMENT_REFUSED: "SUBSCRIPTION_INVOICE_DOCUMENT_REFUSED",
+  /**
+   * The archived document does not match the checksum recorded when it was
+   * rendered (`invoiceId`). It is not handed out (`SC-AUD-019`).
+   */
+  SUBSCRIPTION_INVOICE_DOCUMENT_MISMATCH: "SUBSCRIPTION_INVOICE_DOCUMENT_MISMATCH",
+  /** The invoice's document is not archived yet (`invoiceId`); nothing is offered until it is (`SC-AUD-014`). */
+  SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED: "SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED",
+  /** No invoice with this id (`invoiceId`). */
+  SUBSCRIPTION_INVOICE_NOT_FOUND: "SUBSCRIPTION_INVOICE_NOT_FOUND",
+  /**
+   * The subscriber's record holds no invoice email (`subscriberId`), so the
+   * archived invoice cannot be sent (`SC-PRIC-047`); it is sent once one is
+   * entered.
+   */
+  SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL"
 };
 var SUBSCRIBER_ERROR_CODES = {
   /**
@@ -1345,7 +1818,30 @@ var SUBSCRIBER_ERROR_CODES = {
   SUBSCRIBER_CORRECTION_ACTOR_REQUIRED: "SUBSCRIBER_CORRECTION_ACTOR_REQUIRED",
   SUBSCRIBER_CORRECTION_CHANGES_NOTHING: "SUBSCRIBER_CORRECTION_CHANGES_NOTHING",
   /** The operator declared another legal entity: that is a transfer, not an edit. */
-  SUBSCRIBER_TAKEOVER_IS_A_TRANSFER: "SUBSCRIBER_TAKEOVER_IS_A_TRANSFER"
+  SUBSCRIBER_TAKEOVER_IS_A_TRANSFER: "SUBSCRIBER_TAKEOVER_IS_A_TRANSFER",
+  /**
+   * A contact change named whether the subscriber is a business. That is part
+   * of its tax origin and changes as a recorded change naming who made it.
+   */
+  SUBSCRIBER_BUSINESS_STATUS_NOT_A_CONTACT: "SUBSCRIBER_BUSINESS_STATUS_NOT_A_CONTACT",
+  /** A change of the subscriber's contact details or business status did not say who makes it. */
+  SUBSCRIBER_CHANGE_ACTOR_REQUIRED: "SUBSCRIBER_CHANGE_ACTOR_REQUIRED",
+  /**
+   * Where a tax adapter decides, a contract names its subscriber only once
+   * the address an invoice names is complete (`SC-PRIC-032`): a party copied
+   * onto a contract incomplete cannot be completed afterwards. Carries
+   * `missing`, the empty fields, for a screen to name by their labels; the
+   * shipped sentence names all four rather than the keys.
+   */
+  SUBSCRIBER_IDENTITY_INCOMPLETE: "SUBSCRIBER_IDENTITY_INCOMPLETE",
+  /**
+   * A change of whether the subscriber is a business states no reason. It
+   * decides the tax treatment of the next invoice, so the change log keeps
+   * why it moved (`SC-PRIC-043`).
+   */
+  SUBSCRIBER_BUSINESS_STATUS_REASON_REQUIRED: "SUBSCRIBER_BUSINESS_STATUS_REASON_REQUIRED",
+  /** A check of the subscriber's VAT identification number was asked for, and it holds none. */
+  SUBSCRIBER_VAT_ID_MISSING: "SUBSCRIBER_VAT_ID_MISSING"
 };
 var REGISTRATION_ERROR_CODES = {
   PENDING_REGISTRATION_NOT_FOUND: "PENDING_REGISTRATION_NOT_FOUND",
@@ -1450,6 +1946,29 @@ var MAINTENANCE_ERROR_CODES = {
   /** The message is longer than `MAINTENANCE_MESSAGE_MAX_LENGTH`. */
   MAINTENANCE_MESSAGE_TOO_LONG: "MAINTENANCE_MESSAGE_TOO_LONG"
 };
+var TAX_ERROR_CODES = {
+  /**
+   * The tax adapter answers that it does not support the subscriber's case;
+   * `adapter` names it and `reason` is its sentence. Nothing is concluded with
+   * a guessed tax (`SC-PRIC-039`).
+   */
+  TAX_TREATMENT_NOT_SUPPORTED: "TAX_TREATMENT_NOT_SUPPORTED",
+  /**
+   * The tax adapter needs the VAT identification number checked to treat the
+   * case, and the check did not complete — the service is unavailable, timed
+   * out, or answered in a way the adapter cannot read (`503`). Nothing is
+   * decided in the subscriber's favour on a number not checked
+   * (`SC-PRIC-040`): try again later. `adapter` names the adapter and
+   * `reason` says why.
+   */
+  TAX_VAT_ID_CHECK_NOT_COMPLETED: "TAX_VAT_ID_CHECK_NOT_COMPLETED",
+  /**
+   * A VAT identification number was to be checked, and `config/saas.yaml`
+   * names no tax adapter, which is what names the service to check with
+   * (`409`).
+   */
+  TAX_VAT_ID_CHECK_NOT_AVAILABLE: "TAX_VAT_ID_CHECK_NOT_AVAILABLE"
+};
 var PLATFORM_ERROR_CODES = {
   ...SETUP_ERROR_CODES,
   ...AUTH_ERROR_CODES,
@@ -1457,11 +1976,13 @@ 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,
   ...SETTINGS_ERROR_CODES,
-  ...MAINTENANCE_ERROR_CODES
+  ...MAINTENANCE_ERROR_CODES,
+  ...TAX_ERROR_CODES
 };
 
 // src/errors.ts
@@ -1508,7 +2029,14 @@ var OPTIONAL_CANONICAL_MODELS = {
   MaintenanceWindow: ["core.maintenanceWindows"],
   SubscriptionNotice: ["tenantBilling.subscriptionNotices"],
   VersionRetirement: ["tenantBilling.versionRetirements"],
+  BundleVersionRetirement: ["tenantBilling.bundleVersionRetirements"],
+  FeatureWithdrawal: ["tenantBilling.featureWithdrawals"],
   SubscriberLedgerEntry: ["entitlement.subscriberLedgerRepository"],
+  SubscriptionInvoice: ["entitlement.subscriptionInvoiceRepository"],
+  SubscriptionInvoiceLine: ["entitlement.subscriptionInvoiceRepository"],
+  SubscriptionInvoiceNumber: ["entitlement.subscriptionInvoiceRepository"],
+  SubscriptionInvoiceDocument: ["entitlement.subscriptionInvoiceRepository"],
+  SubscriptionInvoiceArchive: ["entitlement.subscriptionInvoiceArchive"],
   PromoCodeHold: ["promo.holdRepository"]
 };
 function membersLeftOut(notAdopted = []) {
@@ -1625,6 +2153,7 @@ var ERROR_MESSAGES_EN = {
   PLAN_NOT_FOUND: "Plan '{planId}' not found",
   PLAN_VERSION_NOT_FOUND: "PlanVersion '{versionId}' not found",
   BUNDLE_NOT_FOUND: "Bundle '{bundleId}' not found",
+  BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING: "{count} bookings still move onto a version of {bundleKey}, as a retirement told them. The add-on can be deleted once they have.",
   BUNDLE_VERSION_NOT_FOUND: "BundleVersion '{bundleVersionId}' not found",
   FEATURE_NOT_FOUND: "Feature '{featureKey}' not found",
   QUOTA_NOT_FOUND: "Quota '{quotaKey}' not found",
@@ -1680,9 +2209,37 @@ var ERROR_MESSAGES_EN = {
   RETIREMENT_NOTHING_AFFECTED: "No running subscription is on version {version} of {planKey}, so there is nobody to tell.",
   RETIREMENT_WITHIN_TWELVE_MONTHS: "{count} of these subscriptions were reached by a retirement within the last twelve months. A subscription is reached at most once a year.",
   RETIREMENT_PREVIEW_CHANGED: "The subscriptions this retirement reaches changed since they were shown. Look at them again before announcing it.",
+  BUNDLE_RETIREMENT_VERSION_ON_SALE: "Version {version} of {bundleKey} is still on sale. Publish the version that replaces it, and retire this one once its sale has ended, so nobody books it after the announcement.",
+  BUNDLE_RETIREMENT_REPLACEMENT_NOT_ON_SALE: "Version {version} of {bundleKey} is not on sale, so bookings cannot continue on it.",
+  BUNDLE_RETIREMENT_REPLACEMENT_OF_ANOTHER_BUNDLE: "The replacement is a version of {replacementBundleKey}, not of {bundleKey}. A booking continues on a version of its own add-on.",
+  BUNDLE_RETIREMENT_REPLACEMENT_CANNOT_RUN: "{count} of these bookings run beside a plan that version {version} of {bundleKey} cannot run beside, so they cannot continue on it.",
+  BUNDLE_RETIREMENT_NOTHING_AFFECTED: "No running booking is on version {version} of {bundleKey}, so there is nobody to tell.",
+  BUNDLE_RETIREMENT_REINSTATE_REFUSED: "Version {version} of {bundleKey} is being retired, and this booking ends before it would move. Book version {replacementVersion} from {bookableFrom}, when this booking has ended.",
+  BUNDLE_RETIREMENT_REINSTATE_REPLACEMENT_CANNOT_RUN: "Version {version} of {bundleKey} is being retired, and this booking ends before it would move. Version {replacementVersion}, which replaces it, cannot run beside your plan, or beside one your subscription is set to move to.",
+  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.",
+  RETIREMENT_SWITCH_BUNDLE_REPLACEMENT_CANNOT_FOLLOW: "{bundleName} continues on version {version} from {from}, which cannot run on {planName}. Once it is cancelled, the switch can be made.",
   RETIREMENT_SWITCH_NOT_OPEN: "This subscription cannot switch now: a change is scheduled, it has ended, or its plan is held for a special contract.",
   RETIREMENT_SWITCH_CHANGED: "The retirement changed since it was shown. Look at it again before switching.",
   SUBSCRIPTION_ENDED: "This subscription has ended. Its plan can no longer be changed.",
@@ -1695,6 +2252,7 @@ var ERROR_MESSAGES_EN = {
   CYCLE_SHORTENS_AT_TERM_END: "A monthly {planName} cannot start inside the yearly term you are in. The upgrade takes effect when that term ends; to have it today, keep the yearly cycle.",
   BUNDLE_BOOKING_OUTLASTS_TARGET_CYCLE: "{bundleName} is billed yearly and runs until {until} at the earliest, which a monthly plan cannot carry. Once it is cancelled, a change that takes effect on or after that day goes through \u2014 or keep the yearly cycle.",
   BUNDLE_BOOKING_DOES_NOT_FIT_TARGET_PLAN: "{bundleName} cannot run on {planName} and runs until {until} at the earliest. Once it is cancelled, a change that takes effect on or after that day goes through \u2014 or choose another plan.",
+  BUNDLE_REPLACEMENT_DOES_NOT_FIT_TARGET_PLAN: "{bundleName} continues on version {version} from {from}, which cannot run on {planName}. Cancel it, and the change goes through \u2014 or choose another plan.",
   REDUNDANT_FEATURES: "The plan or another booked bundle already includes {count} of the features in this bundle \u2014 booking it pays for them twice.",
   MINIMUM_TERM_BINDS: "The minimum term extends beyond the end of the period \u2014 the cancellation only takes effect when the minimum term ends.",
   BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED: "The bundle requires [{features}] \u2014 present neither in the plan nor in the active bundles.",
@@ -1719,6 +2277,16 @@ var ERROR_MESSAGES_EN = {
   PROMO_WOULD_PRODUCE_ZERO_INVOICE: "For absolute amounts the discount must stay below the lowest applicable plan price, or allowZeroInvoice must be enabled.",
   PROMO_MAX_REDEMPTIONS_LOWERED: "maxRedemptions cannot be lowered.",
   // ── contract ──
+  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "The contract states {stated} % in {field}, and the tax adapter decides {decided} %.",
+  SUBSCRIPTION_INVOICE_CHARGE_INVOICED: "Charge '{chargeId}' already stands on an invoice.",
+  SUBSCRIPTION_INVOICE_CONTENT_INCOMPLETE: "The invoice lacks what the tax adapter {adapter} requires of it: {missing}. It is issued once that is supplied.",
+  SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED: "Contract {contractId} names no confirmed issuer and subscriber \u2014 a migration copied its parties, or it names no issuer \u2014 so its charges are not invoiced.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED: "The document of invoice {invoiceId} differs from the one recorded or archived for it ({rendered} instead of {recorded}); the first stays, and the next run settles which one the invoice keeps.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_REFUSED: "The tax adapter {adapter} refuses the rendered invoice: {missing}. The invoice keeps its number and waits for a document that passes.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_MISMATCH: "The archived document of invoice {invoiceId} does not match the checksum recorded when it was rendered, and is not handed out.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED: "The document of invoice {invoiceId} is not archived yet.",
+  SUBSCRIPTION_INVOICE_NOT_FOUND: "No invoice '{invoiceId}'.",
+  SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "Subscriber {subscriberId} has no invoice email, so its invoice cannot be sent; it is sent once one is entered.",
   CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "A checkout offer can yield only one contract, and only once its line items are frozen.",
   CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "A checkout offer requires a frozen plan line item.",
   CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Every selected bundle version requires a frozen bundle line item.",
@@ -1743,6 +2311,8 @@ var ERROR_MESSAGES_EN = {
   CHECKOUT_OFFER_ALREADY_CONSUMED: "Checkout offer '{offerId}' has already been consumed and cannot be {action}",
   CHECKOUT_OFFER_NOT_CONSUMED: "CheckoutOffer '{offerId}' must be consumed before the contract is created",
   CHECKOUT_OFFER_CHANGED: "Checkout offer '{offerId}' changed while it was being concluded. Load it again.",
+  CHECKOUT_OFFER_CONTRACT_IN_FORCE: "Checkout offer '{offerId}' concludes a first contract, and this tenant already has one. A running subscription changes through its plan and its add-ons.",
+  CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION: "Checkout offer '{offerId}' names version {offeredVersion} of add-on '{bundleKey}', which this tenant has booked in version {bookedVersion} (booking {subscriptionBundleId}). Its version changes through the offer beside the add-on.",
   SUBSCRIPTION_CONTRACT_NOT_FOUND: "SubscriptionContract '{contractId}' not found",
   NO_ACTIVE_SUBSCRIPTION_CONTRACT: "No active subscription contract for tenant {tenantId}",
   SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SubscriptionContract '{contractId}' is already closed",
@@ -1753,11 +2323,16 @@ var ERROR_MESSAGES_EN = {
   SUBSCRIBER_NOT_FOUND: "Subscriber '{subscriberId}' not found",
   SUBSCRIBER_LEGAL_NAME_REQUIRED: "A subscriber needs its legal name.",
   SUBSCRIBER_DETAIL_INVALID: "The subscriber's {field} is not valid.",
+  SUBSCRIBER_IDENTITY_INCOMPLETE: "The subscriber's billing address is not complete yet: a contract names it only with street and number, postal code, city and country.",
   SUBSCRIBER_IDENTITY_NOT_A_CONTACT: "{field} is part of the subscriber's legal identity and changes only as a correction, with a reason.",
+  SUBSCRIBER_BUSINESS_STATUS_REASON_REQUIRED: "A change of whether the subscriber is a business needs a reason.",
+  SUBSCRIBER_VAT_ID_MISSING: "The subscriber has no VAT identification number to check.",
   SUBSCRIBER_CORRECTION_REASON_REQUIRED: "A correction of the legal identity needs a reason.",
   SUBSCRIBER_CORRECTION_ACTOR_REQUIRED: "A correction of the legal identity has to say who makes it.",
   SUBSCRIBER_CORRECTION_CHANGES_NOTHING: "The correction changes nothing: every value it names is already recorded.",
   SUBSCRIBER_TAKEOVER_IS_A_TRANSFER: "Another legal entity taking over a subscriber is a transfer, not a correction, and cannot be recorded as an edit.",
+  SUBSCRIBER_BUSINESS_STATUS_NOT_A_CONTACT: "Whether the subscriber is a business is part of its tax origin and changes only as a recorded change that names who made it.",
+  SUBSCRIBER_CHANGE_ACTOR_REQUIRED: "A change of the subscriber's details has to say who makes it.",
   // ── registration ──
   PENDING_REGISTRATION_NOT_FOUND: "This registration could not be found. It may have already been completed or discarded.",
   PENDING_REGISTRATION_EXPIRED: "This registration has expired. Please start again.",
@@ -1791,7 +2366,11 @@ var ERROR_MESSAGES_EN = {
   MAINTENANCE_WINDOW_END_NOT_AFTER_START: "The end of a maintenance window has to be after its start.",
   MAINTENANCE_WINDOW_END_IN_PAST: "The end of a maintenance window cannot be in the past.",
   MAINTENANCE_TIME_INVALID: "The {field} has to be a date and time with its zone, such as 2026-10-02T22:00+02:00.",
-  MAINTENANCE_MESSAGE_TOO_LONG: "The message may be at most {max} characters long."
+  MAINTENANCE_MESSAGE_TOO_LONG: "The message may be at most {max} characters long.",
+  // ── tax ──
+  TAX_TREATMENT_NOT_SUPPORTED: "The tax adapter {adapter} does not support this case: {reason}",
+  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 formatErrorMessage(template, params = {}) {
   return template.replace(/\{(\w+)\}/g, (match, name) => {
@@ -2148,18 +2727,22 @@ var ORIGINS = {
   renewal: true,
   planChange: true,
   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,
@@ -2167,8 +2750,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,
@@ -2208,6 +2791,560 @@ function keysOf(record) {
 // src/subscriber-ledger.types.ts
 var SUBSCRIBER_ACCOUNT_CAPABILITY = "charges.read";
 
+// src/subscription-invoice.types.ts
+var INVOICE_SEQUENCE_DIGITS = 6;
+function formatInvoiceNumber(prefix, year, sequence) {
+  if (!Number.isInteger(sequence) || sequence < 1) {
+    throw new RangeError(`An invoice number's sequence starts at 1; ${sequence} is not one.`);
+  }
+  return `${prefix}-${year}-${String(sequence).padStart(INVOICE_SEQUENCE_DIGITS, "0")}`;
+}
+
+// src/subscriber.types.ts
+var SUBSCRIBER_INVOICE_ADDRESS_FIELDS = [
+  "addressLine1",
+  "postalCode",
+  "city",
+  "country"
+];
+var SUBSCRIBER_STANDING_CAPABILITY = "subscribers.read";
+var SUBSCRIBER_ATTENTION_CAPABILITY = "subscribers.attention";
+var SUBSCRIBER_ATTENTION_PAGE_SIZE = 200;
+var SUBSCRIBER_CORRECTION_CAPABILITY = "subscribers.correct";
+var SUBSCRIBER_TAX_ORIGIN_FIELDS = ["country", "business", "vatId"];
+
+// src/tax.types.ts
+var TAX_TREATMENT_KINDS = [
+  "standard",
+  "reduced",
+  "exempt",
+  "reverse-charge",
+  "not-taxable",
+  "small-business"
+];
+
+// src/tax-origin.ts
+var VAT_ID_SEPARATORS = /[\s.-]/g;
+function canonicalVatId(written) {
+  const vatId = written.replace(VAT_ID_SEPARATORS, "").toUpperCase();
+  return vatId === "" ? null : vatId;
+}
+function taxOriginOf(subscriber, currentCheck) {
+  const validated = subscriber.vatId !== null && currentCheck?.valid === true && currentCheck.vatId === subscriber.vatId;
+  return {
+    country: subscriber.country,
+    business: subscriber.business,
+    vatId: subscriber.vatId,
+    validatedVatId: validated ? subscriber.vatId : null
+  };
+}
+function keepsVatIdCheck(held, counting, check) {
+  if (held.vatId === null || check.vatId !== held.vatId) return false;
+  if (held.vatIdSince !== null && check.checkedAt.getTime() < held.vatIdSince.getTime()) {
+    return false;
+  }
+  if (counting === null || counting.vatId !== held.vatId) return true;
+  return counting.checkedAt.getTime() <= check.checkedAt.getTime();
+}
+function toSubscriberVatIdCheckRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    vatId: row.vatId,
+    checkedAt: row.checkedAt,
+    valid: row.valid,
+    service: row.service,
+    confirmation: textEntries(row.confirmation),
+    recordedAt: row.recordedAt
+  };
+}
+function taxTreatmentToJson(treatment) {
+  return {
+    kind: treatment.kind,
+    rate: treatment.rate,
+    note: treatment.note,
+    adapter: { name: treatment.adapter.name, version: treatment.adapter.version }
+  };
+}
+function toTaxTreatment(value) {
+  if (!isObject(value)) return null;
+  const { kind, rate, note, adapter } = value;
+  if (!isTreatmentKind(kind)) return null;
+  if (typeof rate !== "number" || !Number.isFinite(rate)) return null;
+  if (note !== null && typeof note !== "string") return null;
+  if (!isObject(adapter)) return null;
+  if (typeof adapter.name !== "string" || typeof adapter.version !== "string") return null;
+  return { kind, rate, note, adapter: { name: adapter.name, version: adapter.version } };
+}
+function taxOriginWrite(current, next) {
+  const previous = {};
+  const changed = {};
+  for (const field of SUBSCRIBER_TAX_ORIGIN_FIELDS) {
+    const value = next[field];
+    if (value === void 0 || value === current[field]) continue;
+    previous[field] = current[field];
+    changed[field] = value;
+  }
+  return {
+    previous,
+    changed,
+    moved: Object.keys(changed).length > 0,
+    endsCountingVatIdCheck: Object.prototype.hasOwnProperty.call(changed, "vatId")
+  };
+}
+function toTaxOriginValues(value) {
+  if (!isObject(value)) return {};
+  const values = {};
+  for (const field of SUBSCRIBER_TAX_ORIGIN_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(value, field)) continue;
+    const entry = value[field];
+    if (field === "business") {
+      values[field] = typeof entry === "boolean" ? entry : null;
+    } else {
+      values[field] = typeof entry === "string" ? entry : null;
+    }
+  }
+  return values;
+}
+function isTreatmentKind(value) {
+  return TAX_TREATMENT_KINDS.includes(value);
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function vatIdCheckFromStore(value) {
+  if (!isObject(value)) return null;
+  const { vatId, checkedAt, valid, service, confirmation } = value;
+  const at = checkedAt instanceof Date ? checkedAt : new Date(String(checkedAt));
+  if (typeof vatId !== "string" || typeof valid !== "boolean" || typeof service !== "string") {
+    return null;
+  }
+  if (checkedAt === void 0 || checkedAt === null || Number.isNaN(at.getTime())) return null;
+  return { vatId, checkedAt: at, valid, service, confirmation: textEntries(confirmation) };
+}
+function textEntries(value) {
+  if (!isObject(value)) return {};
+  const entries = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") entries[key] = entry;
+  }
+  return entries;
+}
+
+// src/subscription-invoice-mapping.ts
+var INVOICES = "subscription_invoices";
+var LINES = "subscription_invoice_lines";
+var CENT_TOLERANCE2 = 1e-6;
+function toSubscriptionInvoiceRecord(row, lines) {
+  const where = (column) => ({ table: INVOICES, column, id: row.id });
+  const treatment = toTaxTreatment(row.taxTreatment);
+  if (!treatment) {
+    throw new Error(`${INVOICES}.taxTreatment of ${row.id} is not a tax treatment.`);
+  }
+  return {
+    id: row.id,
+    number: row.number,
+    numberPrefix: row.numberPrefix,
+    numberYear: row.numberYear,
+    numberSequence: row.numberSequence,
+    tenantId: row.tenantId,
+    subscriberId: row.subscriberId,
+    subscriptionId: row.subscriptionId,
+    contractId: row.contractId,
+    issuedAt: row.issuedAt,
+    issueDate: dayOf2(row.issueDate, where("issueDate")),
+    dueDate: dayOf2(row.dueDate, where("dueDate")),
+    servicePeriodFrom: dayOf2(row.servicePeriodFrom, where("servicePeriodFrom")),
+    servicePeriodUntil: dayOf2(row.servicePeriodUntil, where("servicePeriodUntil")),
+    currency: row.currency,
+    issuer: issuerOf(row.issuerParty, where("issuerParty")),
+    subscriber: subscriberOf(row.subscriberParty, where("subscriberParty")),
+    footer: footerOf(row.footer, where("footer")),
+    taxTreatment: treatment,
+    taxes: taxesOf(row.taxes, where("taxes")),
+    totalNet: amountOf2(row.totalNet, where("totalNet")),
+    totalTax: amountOf2(row.totalTax, where("totalTax")),
+    totalGross: amountOf2(row.totalGross, where("totalGross")),
+    lines: [...lines].sort((a, b) => a.position - b.position).map((line) => toSubscriptionInvoiceLineRecord(line)),
+    createdAt: row.createdAt
+  };
+}
+function toSubscriptionInvoiceLineRecord(row) {
+  const where = (column) => ({ table: LINES, column, id: row.id });
+  return {
+    id: row.id,
+    invoiceId: row.invoiceId,
+    position: row.position,
+    chargeId: row.chargeId,
+    contractLineItemId: row.contractLineItemId,
+    title: row.title,
+    origin: oneOf(SUBSCRIBER_CHARGE_ORIGINS, row.origin, where("origin")),
+    source: oneOf(SUBSCRIBER_CHARGE_SOURCES, row.source, where("source")),
+    periodFrom: dayOf2(row.periodFrom, where("periodFrom")),
+    periodUntil: dayOf2(row.periodUntil, where("periodUntil")),
+    amountNet: amountOf2(row.amountNet, where("amountNet")),
+    taxRate: amountOf2(row.taxRate, where("taxRate"))
+  };
+}
+function subscriptionInvoiceColumns(invoice, drawn) {
+  return {
+    number: drawn.number,
+    numberPrefix: invoice.numberPrefix,
+    numberYear: invoice.numberYear,
+    numberSequence: drawn.numberSequence,
+    tenantId: invoice.tenantId,
+    subscriberId: invoice.subscriberId,
+    subscriptionId: invoice.subscriptionId,
+    contractId: invoice.contractId,
+    issuedAt: invoice.issuedAt,
+    issueDate: invoice.issueDate,
+    dueDate: invoice.dueDate,
+    servicePeriodFrom: invoice.servicePeriodFrom,
+    servicePeriodUntil: invoice.servicePeriodUntil,
+    currency: invoice.currency,
+    issuerParty: { ...invoice.issuer },
+    subscriberParty: { ...invoice.subscriber },
+    footer: [...invoice.footer],
+    taxTreatment: taxTreatmentToJson(invoice.taxTreatment),
+    taxes: invoice.taxes.map((entry) => ({ rate: entry.rate, net: entry.net, tax: entry.tax })),
+    totalNet: centsText(invoice.totalNet, "totalNet"),
+    totalTax: centsText(invoice.totalTax, "totalTax"),
+    totalGross: centsText(invoice.totalGross, "totalGross")
+  };
+}
+function subscriptionInvoiceLineColumns(line, invoiceId) {
+  return {
+    invoiceId,
+    position: line.position,
+    chargeId: line.chargeId,
+    contractLineItemId: line.contractLineItemId,
+    title: line.title,
+    origin: line.origin,
+    source: line.source,
+    periodFrom: line.periodFrom,
+    periodUntil: line.periodUntil,
+    amountNet: centsText(line.amountNet, "amountNet"),
+    taxRate: centsText(line.taxRate, "taxRate")
+  };
+}
+function utcMidnightOf(day) {
+  return /* @__PURE__ */ new Date(`${day}T00:00:00.000Z`);
+}
+var DAY_LENGTH = "YYYY-MM-DD".length;
+function dayOf2(value, where) {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString().slice(0, DAY_LENGTH);
+  }
+  if (typeof value === "string" && value.length === DAY_LENGTH && !Number.isNaN(Date.parse(value))) {
+    return value;
+  }
+  throw new Error(`${where.table}.${where.column} of ${where.id} is not a day.`);
+}
+function footerOf(value, where) {
+  if (!Array.isArray(value) || !value.every((line) => typeof line === "string")) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} is not a list of lines.`);
+  }
+  return [...value];
+}
+function amountOf2(value, where) {
+  const amount = Number(value === null || value === void 0 ? NaN : String(value));
+  if (!Number.isFinite(amount)) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} is not an amount.`);
+  }
+  return amount;
+}
+function centsText(amount, field) {
+  const cents2 = amount * 100;
+  if (!Number.isFinite(cents2) || Math.abs(cents2 - Math.round(cents2)) > CENT_TOLERANCE2) {
+    throw new Error(
+      `An invoice's ${field} of ${amount} is not a whole number of cents; it is rounded once, where the invoice is drafted, before it is written.`
+    );
+  }
+  return amount.toFixed(2);
+}
+function textOrNull2(source, key, where) {
+  const value = source[key];
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "string") {
+    throw new Error(`${where.table}.${where.column}.${key} of ${where.id} is not text.`);
+  }
+  return value;
+}
+function partyOf(value, where) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} is not a party.`);
+  }
+  const source = value;
+  const legalName = textOrNull2(source, "legalName", where);
+  if (legalName === null) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} names no legal name.`);
+  }
+  return {
+    legalName,
+    vatId: textOrNull2(source, "vatId", where),
+    taxNumber: textOrNull2(source, "taxNumber", where),
+    addressLine1: textOrNull2(source, "addressLine1", where),
+    addressLine2: textOrNull2(source, "addressLine2", where),
+    postalCode: textOrNull2(source, "postalCode", where),
+    city: textOrNull2(source, "city", where),
+    country: textOrNull2(source, "country", where)
+  };
+}
+function issuerOf(value, where) {
+  return partyOf(value, where);
+}
+function subscriberOf(value, where) {
+  const party = partyOf(value, where);
+  const customerNumber = textOrNull2(value, "customerNumber", where);
+  if (customerNumber === null) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} names no customer number.`);
+  }
+  return { ...party, customerNumber };
+}
+function taxesOf(value, where) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${where.table}.${where.column} of ${where.id} is not a list of rates.`);
+  }
+  return value.map((entry) => {
+    const item = entry ?? {};
+    return {
+      rate: amountOf2(item.rate, where),
+      net: amountOf2(item.net, where),
+      tax: amountOf2(item.tax, where)
+    };
+  });
+}
+
+// src/subscription-invoice-refusals.ts
+function subscriptionInvoiceChargeInvoiced(chargeId) {
+  return new PersistenceRefusal(
+    INVOICE_ERROR_CODES.SUBSCRIPTION_INVOICE_CHARGE_INVOICED,
+    "moved",
+    `Charge '${chargeId}' already stands on an invoice.`,
+    { chargeId }
+  );
+}
+function subscriptionInvoiceDocumentChanged(invoiceId, recorded, rendered) {
+  return new PersistenceRefusal(
+    INVOICE_ERROR_CODES.SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED,
+    "moved",
+    `The document rendered for invoice '${invoiceId}' differs from the one recorded for it.`,
+    { invoiceId, recorded, rendered }
+  );
+}
+
+// src/subscription-invoice-draft.ts
+function invoiceGroupsOf(charges) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const charge of charges) {
+    const key = `${charge.contractId}|${charge.bookedAt.toISOString()}`;
+    const group = groups.get(key);
+    if (group) group.charges.push(charge);
+    else
+      groups.set(key, {
+        contractId: charge.contractId,
+        bookedAt: charge.bookedAt,
+        charges: [charge]
+      });
+  }
+  return [...groups.values()].filter((group) => group.charges.some((charge) => charge.amountNet !== 0)).sort(
+    (a, b) => a.bookedAt.getTime() - b.bookedAt.getTime() || a.contractId.localeCompare(b.contractId)
+  );
+}
+function draftSubscriptionInvoice(input) {
+  const { group, treatment, timeZone } = input;
+  const lines = linesOf(input);
+  const issueDate = dayInZone(input.issuedAt, timeZone);
+  const tax = input.tax(lines.map((line) => ({ net: line.amountNet, rate: line.taxRate })));
+  return {
+    numberPrefix: input.numberPrefix,
+    numberYear: yearOfDay(issueDate),
+    tenantId: input.tenantId,
+    subscriberId: input.subscriberId,
+    subscriptionId: group.charges[0].subscriptionId,
+    contractId: group.contractId,
+    issuedAt: input.issuedAt,
+    issueDate,
+    dueDate: addDaysToDay(issueDate, input.paymentTermDays),
+    servicePeriodFrom: lines.map((line) => line.periodFrom).sort()[0],
+    servicePeriodUntil: lines.map((line) => line.periodUntil).sort().at(-1),
+    currency: currencyOf(group),
+    issuer: input.issuer,
+    subscriber: input.subscriber,
+    footer: [...input.footer],
+    taxTreatment: treatment,
+    taxes: tax.rates,
+    totalNet: tax.net,
+    totalTax: tax.tax,
+    totalGross: tax.gross,
+    lines
+  };
+}
+function invoiceContentDraftOf(invoice) {
+  return {
+    issuer: invoice.issuer,
+    subscriber: invoice.subscriber,
+    treatment: invoice.taxTreatment,
+    issueDate: invoice.issueDate,
+    dueDate: invoice.dueDate,
+    servicePeriod: { from: invoice.servicePeriodFrom, until: invoice.servicePeriodUntil },
+    lines: invoice.lines.map((line) => ({
+      title: line.title,
+      net: line.amountNet,
+      rate: line.taxRate
+    }))
+  };
+}
+function linesOf(input) {
+  const placeOf = new Map(input.contractLines.map((line, index) => [line.id, index]));
+  const place = (charge) => {
+    const index = placeOf.get(charge.contractLineItemId);
+    if (index === void 0) {
+      throw new Error(
+        `Charge ${charge.id} names contract line ${charge.contractLineItemId}, which contract ${input.group.contractId} does not have.`
+      );
+    }
+    return index;
+  };
+  return [...input.group.charges].sort(
+    (a, b) => place(a) - place(b) || a.periodStart.getTime() - b.periodStart.getTime() || a.origin.localeCompare(b.origin)
+  ).map((charge, index) => ({
+    position: index + 1,
+    chargeId: charge.id,
+    contractLineItemId: charge.contractLineItemId,
+    title: input.contractLines[place(charge)].titleSnapshot,
+    origin: charge.origin,
+    source: charge.source,
+    periodFrom: dayInZone(charge.periodStart, input.timeZone),
+    periodUntil: lastDayInZone(
+      { from: charge.periodStart, until: charge.periodEnd },
+      input.timeZone
+    ),
+    amountNet: charge.amountNet,
+    taxRate: input.treatment.rate
+  }));
+}
+function currencyOf(group) {
+  const currencies = new Set(group.charges.map((charge) => charge.currency));
+  if (currencies.size !== 1) {
+    throw new Error(
+      `The charges of contract ${group.contractId} booked at ${group.bookedAt.toISOString()} are in ${[...currencies].join(" and ")}; an invoice is in one currency.`
+    );
+  }
+  return [...currencies][0];
+}
+
+// src/invoice-issuer.ts
+function invoiceIssuerOf(copy, configured, history) {
+  const target = configured && identityOf2(configured);
+  let reached = identityOf2(copy);
+  if (!target || !reached) return { ...copy };
+  for (const step of history) {
+    if (sameLegalIdentity(reached, target)) break;
+    const change = classifyIssuerChange(
+      recordedIssuerIdentity(step.previous),
+      issuerBlockOf(step.current)
+    );
+    if (change.kind === "corrected" && sameLegalIdentity(change.recorded, reached)) {
+      reached = change.current;
+    }
+  }
+  return sameLegalIdentity(reached, target) ? { ...configured } : { ...copy };
+}
+function invoiceFooterOf(issuer, configured, footer) {
+  const named = identityOf2(issuer);
+  const target = configured && identityOf2(configured);
+  return named && target && sameLegalIdentity(named, target) ? [...footer] : [];
+}
+function identityOf2(party) {
+  return recordedIssuerIdentity({ issuer: party });
+}
+function issuerBlockOf(values) {
+  const issuer = values.issuer;
+  if (issuer === null || typeof issuer !== "object" || Array.isArray(issuer)) return void 0;
+  return issuer;
+}
+
+// src/invoice-document.types.ts
+var INVOICE_DOCUMENT_CAPABILITY = "invoices.read";
+
+// src/invoice-document-mapping.ts
+var DOCUMENTS = "subscription_invoice_documents";
+var ARCHIVE = "subscription_invoice_archive";
+var CHECKSUM = /^[0-9a-f]{64}$/;
+function isInvoiceDocumentChecksum(value) {
+  return typeof value === "string" && CHECKSUM.test(value);
+}
+function toSubscriptionInvoiceDocumentRecord(row) {
+  if (!isInvoiceDocumentChecksum(row.checksum)) {
+    throw new Error(`${DOCUMENTS}.checksum of ${row.invoiceId} is not a SHA-256 digest.`);
+  }
+  const size = Number(row.size);
+  if (!Number.isSafeInteger(size) || size < 0) {
+    throw new Error(`${DOCUMENTS}.size of ${row.invoiceId} is not a size in bytes.`);
+  }
+  return {
+    invoiceId: row.invoiceId,
+    checksum: row.checksum,
+    mediaType: row.mediaType,
+    fileName: row.fileName,
+    size,
+    renderedAt: row.renderedAt,
+    archivedAt: row.archivedAt,
+    deliveryClaimedAt: row.deliveryClaimedAt,
+    deliveredAt: row.deliveredAt,
+    deliveredTo: row.deliveredTo
+  };
+}
+function toArchivedInvoiceDocument(row) {
+  if (!isInvoiceDocumentChecksum(row.checksum)) {
+    throw new Error(`${ARCHIVE}.checksum of ${row.invoiceId} is not a SHA-256 digest.`);
+  }
+  if (!(row.content instanceof Uint8Array)) {
+    throw new Error(`${ARCHIVE}.content of ${row.invoiceId} is not a file.`);
+  }
+  return {
+    invoiceId: row.invoiceId,
+    checksum: row.checksum,
+    mediaType: row.mediaType,
+    fileName: row.fileName,
+    // A copy that owns its bytes: a driver's `Buffer` may be a view into a
+    // pooled allocation, and a caller handing it on must not see that pool.
+    content: new Uint8Array(row.content),
+    archivedAt: row.archivedAt
+  };
+}
+var INVOICE_ARCHIVE_TRIGGERS = [
+  "subscription_invoice_archive_is_kept",
+  "subscription_invoice_archive_is_not_emptied"
+];
+function invoiceArchiveProtectionProblem(enabledTriggers) {
+  const missing = INVOICE_ARCHIVE_TRIGGERS.filter((name) => !enabledTriggers.includes(name));
+  if (missing.length === 0) return null;
+  return `${ARCHIVE} lacks ${missing.join(" and ")}, which keep an archived invoice document as it was issued: run @saasicat/spec/sql/1.0-an-invoice-document-is-archived.postgres.sql after db push, and enable the triggers where they were disabled.`;
+}
+
+// src/e-invoice-format.ts
+var CATEGORY = {
+  standard: "S",
+  reduced: "S",
+  exempt: "E",
+  "small-business": "E",
+  "reverse-charge": "AE",
+  "not-taxable": "O"
+};
+function vatCategoryOf(kind) {
+  return CATEGORY[kind];
+}
+var NOT_XML = /[^\t\n\r\u0020-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}]/gu;
+function holdsOnlyXmlCharacters(text) {
+  return text.search(NOT_XML) === -1;
+}
+var CARRIAGE_RETURN = /\r\n?/g;
+function asXmlReadsIt(text) {
+  return text.replace(NOT_XML, "?").replace(CARRIAGE_RETURN, "\n");
+}
+
 // src/subscriber-mapping.ts
 function formatCustomerNumber(prefix, sequence) {
   return `${prefix}${sequence}`;
@@ -2225,6 +3362,7 @@ function toSubscriberRecord(row, tenantId) {
     vatId: row.vatId,
     taxNumber: row.taxNumber,
     invoiceEmail: row.invoiceEmail,
+    business: row.business,
     tenantId,
     migrated: row.migrated,
     createdAt: row.createdAt,
@@ -2242,6 +3380,17 @@ function toSubscriberCorrectionRecord(row) {
     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 = {};
@@ -2305,7 +3454,9 @@ function subscriberFromRegistration(pending) {
     city: pending.city,
     country: pending.country,
     vatId: pending.vatId,
-    taxNumber: pending.taxNumber
+    taxNumber: pending.taxNumber,
+    business: pending.business,
+    vatIdCheck: vatIdCheckFromStore(pending.vatIdCheck)
   };
 }
 function toIdentityValues(value) {
@@ -2323,7 +3474,7 @@ function toIdentityValues(value) {
 // src/subscriber-payment-method-mapping.ts
 var PAYMENT_METHOD_TYPES = ["card", "sepa_debit"];
 var STATUSES = ["ACTIVE", "REPLACED"];
-var TABLE3 = "subscriber_payment_methods";
+var TABLE4 = "subscriber_payment_methods";
 function toSubscriberPaymentMethodRecord(row) {
   return {
     id: row.id,
@@ -2332,7 +3483,7 @@ function toSubscriberPaymentMethodRecord(row) {
     provider: row.provider,
     customerRef: row.customerRef,
     paymentMethodRef: row.paymentMethodRef,
-    type: oneOf(PAYMENT_METHOD_TYPES, row.type, { table: TABLE3, column: "type", id: row.id }),
+    type: oneOf(PAYMENT_METHOD_TYPES, row.type, { table: TABLE4, column: "type", id: row.id }),
     brand: row.brand,
     last4: row.last4,
     expiryMonth: row.expiryMonth,
@@ -2340,7 +3491,7 @@ function toSubscriberPaymentMethodRecord(row) {
     country: row.country,
     bankCode: row.bankCode,
     mandateReference: row.mandateReference,
-    status: oneOf(STATUSES, row.status, { table: TABLE3, column: "status", id: row.id }),
+    status: oneOf(STATUSES, row.status, { table: TABLE4, column: "status", id: row.id }),
     confirmedAt: row.confirmedAt,
     replacedAt: row.replacedAt,
     createdAt: row.createdAt
@@ -2406,6 +3557,8 @@ function toSubscriptionBundleRecord(row) {
     }),
     currentPeriodStart: row.currentPeriodStart ?? null,
     currentPeriodEnd: row.currentPeriodEnd ?? null,
+    pendingBundleVersionId: row.pendingBundleVersionId ?? null,
+    pendingVersionEffectiveAt: row.pendingVersionEffectiveAt ?? null,
     canceledAt: row.canceledAt,
     canceledEffectiveAt: row.canceledEffectiveAt,
     createdAt: row.createdAt,
@@ -2422,6 +3575,7 @@ function toSubscriptionContractRecord(row, lineItems) {
     subscriber: toSubscriberParty(row.subscriberSnapshot),
     issuer: isPlainObject2(row.issuerSnapshot) ? toIssuerParty(row.issuerSnapshot) : null,
     partiesMigrated: row.partiesMigrated,
+    taxTreatment: toTaxTreatment(row.taxTreatment),
     status: row.status,
     effectiveFrom: row.effectiveFrom,
     effectiveUntil: row.effectiveUntil,
@@ -2669,6 +3823,7 @@ var ERROR_MESSAGES_DE = {
   PLAN_NOT_FOUND: "Plan '{planId}' nicht gefunden",
   PLAN_VERSION_NOT_FOUND: "PlanVersion '{versionId}' nicht gefunden",
   BUNDLE_NOT_FOUND: "Bundle '{bundleId}' nicht gefunden",
+  BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING: "{count} Buchungen ziehen noch auf eine Version von {bundleKey} um, wie eine Stilllegung es ihnen mitgeteilt hat. Das Add-on l\xE4sst sich l\xF6schen, sobald sie umgezogen sind.",
   BUNDLE_VERSION_NOT_FOUND: "BundleVersion '{bundleVersionId}' nicht gefunden",
   FEATURE_NOT_FOUND: "Feature '{featureKey}' nicht gefunden",
   QUOTA_NOT_FOUND: "Quota '{quotaKey}' nicht gefunden",
@@ -2724,9 +3879,37 @@ var ERROR_MESSAGES_DE = {
   RETIREMENT_NOTHING_AFFECTED: "Kein laufendes Abonnement nutzt Version {version} von {planKey}. Es gibt niemanden zu benachrichtigen.",
   RETIREMENT_WITHIN_TWELVE_MONTHS: "{count} dieser Abonnements waren in den letzten zw\xF6lf Monaten schon von einer Stilllegung betroffen. Ein Abonnement ist h\xF6chstens einmal im Jahr betroffen.",
   RETIREMENT_PREVIEW_CHANGED: "Die Abonnements, die diese Stilllegung betrifft, haben sich seit der Anzeige ge\xE4ndert. Sieh sie dir noch einmal an, bevor du sie ank\xFCndigst.",
+  BUNDLE_RETIREMENT_VERSION_ON_SALE: "Version {version} von {bundleKey} wird noch verkauft. Ver\xF6ffentliche die Version, die sie ersetzt, und lege diese still, sobald ihr Verkauf geendet hat, damit sie nach der Ank\xFCndigung niemand mehr bucht.",
+  BUNDLE_RETIREMENT_REPLACEMENT_NOT_ON_SALE: "Version {version} von {bundleKey} wird nicht verkauft. Buchungen k\xF6nnen nicht auf ihr weiterlaufen.",
+  BUNDLE_RETIREMENT_REPLACEMENT_OF_ANOTHER_BUNDLE: "Der Ersatz ist eine Version von {replacementBundleKey}, nicht von {bundleKey}. Eine Buchung l\xE4uft auf einer Version ihres eigenen Add-ons weiter.",
+  BUNDLE_RETIREMENT_REPLACEMENT_CANNOT_RUN: "{count} dieser Buchungen laufen neben einem Plan, neben dem Version {version} von {bundleKey} nicht laufen kann. Sie k\xF6nnen nicht auf ihr weiterlaufen.",
+  BUNDLE_RETIREMENT_NOTHING_AFFECTED: "Keine laufende Buchung nutzt Version {version} von {bundleKey}. Es gibt niemanden zu benachrichtigen.",
+  BUNDLE_RETIREMENT_REINSTATE_REFUSED: "Version {version} von {bundleKey} wird stillgelegt, und diese Buchung endet, bevor sie umziehen w\xFCrde. Buchen Sie Version {replacementVersion} ab dem {bookableFrom}, wenn diese Buchung beendet ist.",
+  BUNDLE_RETIREMENT_REINSTATE_REPLACEMENT_CANNOT_RUN: "Version {version} von {bundleKey} wird stillgelegt, und diese Buchung endet, bevor sie umziehen w\xFCrde. Version {replacementVersion}, die sie ersetzt, kann neben Ihrem Paket oder einem Paket, zu dem Ihr Abonnement wechselt, nicht laufen.",
+  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.",
+  RETIREMENT_SWITCH_BUNDLE_REPLACEMENT_CANNOT_FOLLOW: "{bundleName} l\xE4uft ab dem {from} auf Version {version} weiter, die im Paket {planName} nicht laufen kann. Ist es gek\xFCndigt, ist der Wechsel m\xF6glich.",
   RETIREMENT_SWITCH_NOT_OPEN: "Dieses Abonnement kann gerade nicht wechseln: Eine \xC4nderung ist geplant, es ist beendet, oder sein Paket gilt f\xFCr einen Sondervertrag.",
   RETIREMENT_SWITCH_CHANGED: "Die Einstellung hat sich seit der Anzeige ge\xE4ndert. Sehen Sie sie sich noch einmal an, bevor Sie wechseln.",
   SUBSCRIPTION_ENDED: "Dieses Abonnement ist beendet. Sein Paket kann nicht mehr gewechselt werden.",
@@ -2739,6 +3922,7 @@ var ERROR_MESSAGES_DE = {
   CYCLE_SHORTENS_AT_TERM_END: "Ein monatlich abgerechnetes {planName} kann nicht innerhalb der laufenden Jahreslaufzeit beginnen. Das Upgrade greift zum Ende dieser Laufzeit; wer es sofort m\xF6chte, beh\xE4lt den j\xE4hrlichen Rhythmus.",
   BUNDLE_BOOKING_OUTLASTS_TARGET_CYCLE: "{bundleName} wird j\xE4hrlich abgerechnet und l\xE4uft fr\xFChestens bis {until}; ein monatlich abgerechnetes Paket kann es nicht tragen. Ist es gek\xFCndigt, geht ein Wechsel durch, der an diesem Tag oder sp\xE4ter wirksam wird \u2014 oder behalten Sie den j\xE4hrlichen Rhythmus.",
   BUNDLE_BOOKING_DOES_NOT_FIT_TARGET_PLAN: "{bundleName} kann im Paket {planName} nicht laufen und l\xE4uft fr\xFChestens bis {until}. Ist es gek\xFCndigt, geht ein Wechsel durch, der an diesem Tag oder sp\xE4ter wirksam wird \u2014 oder w\xE4hlen Sie ein anderes Paket.",
+  BUNDLE_REPLACEMENT_DOES_NOT_FIT_TARGET_PLAN: "{bundleName} l\xE4uft ab dem {from} auf Version {version} weiter, die im Paket {planName} nicht laufen kann. K\xFCndigen Sie es, dann geht der Wechsel durch \u2014 oder w\xE4hlen Sie ein anderes Paket.",
   REDUNDANT_FEATURES: "Der Plan oder ein anderes gebuchtes Bundle enth\xE4lt bereits {count} der Funktionen aus diesem Bundle \u2014 mit der Buchung werden sie doppelt bezahlt.",
   MINIMUM_TERM_BINDS: "Die Mindestlaufzeit reicht \xFCber das Ende der Periode hinaus \u2014 die K\xFCndigung wird erst zum Ende der Mindestlaufzeit wirksam.",
   BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED: "Das Bundle setzt [{features}] voraus \u2014 weder im Plan noch in den aktiven Bundles vorhanden.",
@@ -2763,6 +3947,16 @@ var ERROR_MESSAGES_DE = {
   PROMO_WOULD_PRODUCE_ZERO_INVOICE: "Bei absoluten Betr\xE4gen muss der Rabatt unter dem niedrigsten anwendbaren Planpreis bleiben, oder allowZeroInvoice muss aktiviert sein.",
   PROMO_MAX_REDEMPTIONS_LOWERED: "maxRedemptions l\xE4sst sich nicht senken.",
   // ── contract ──
+  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "Der Vertrag nennt in {field} {stated} %, der Steueradapter entscheidet {decided} %.",
+  SUBSCRIPTION_INVOICE_CHARGE_INVOICED: "Die Forderung '{chargeId}' steht bereits auf einer Rechnung.",
+  SUBSCRIPTION_INVOICE_CONTENT_INCOMPLETE: "Der Rechnung fehlt, was der Steueradapter {adapter} verlangt: {missing}. Sie wird ausgestellt, sobald es erg\xE4nzt ist.",
+  SUBSCRIPTION_INVOICE_PARTIES_UNCONFIRMED: "Der Vertrag {contractId} nennt keinen best\xE4tigten Aussteller und Abonnenten \u2013 eine Migration hat seine Parteien \xFCbernommen, oder er nennt keinen Aussteller \u2013, deshalb werden seine Forderungen nicht in Rechnung gestellt.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED: "Das Dokument der Rechnung {invoiceId} weicht vom festgehaltenen oder archivierten ab ({rendered} statt {recorded}); das erste bleibt, und der n\xE4chste Lauf kl\xE4rt, welches die Rechnung beh\xE4lt.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_REFUSED: "Der Steueradapter {adapter} weist die gerenderte Rechnung zur\xFCck: {missing}. Die Rechnung beh\xE4lt ihre Nummer und wartet auf ein Dokument, das die Pr\xFCfung besteht.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_MISMATCH: "Das archivierte Dokument der Rechnung {invoiceId} passt nicht zur beim Rendern festgehaltenen Pr\xFCfsumme und wird nicht herausgegeben.",
+  SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED: "Das Dokument der Rechnung {invoiceId} ist noch nicht archiviert.",
+  SUBSCRIPTION_INVOICE_NOT_FOUND: "Keine Rechnung '{invoiceId}'.",
+  SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "Der Abonnent {subscriberId} hat keine Rechnungs-E-Mail; seine Rechnung wird versendet, sobald eine eingetragen ist.",
   CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "Aus einem Checkout-Angebot entsteht nur ein einziger Vertrag, und das erst, wenn seine Positionen eingefroren sind.",
   CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "Ein Checkout-Angebot braucht eine eingefrorene Plan-Position.",
   CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Jede gew\xE4hlte Bundle-Version braucht eine eingefrorene Bundle-Position.",
@@ -2787,6 +3981,8 @@ var ERROR_MESSAGES_DE = {
   CHECKOUT_OFFER_ALREADY_CONSUMED: "Checkout-Angebot '{offerId}' wurde bereits eingel\xF6st \u2014 '{action}' ist nicht mehr m\xF6glich",
   CHECKOUT_OFFER_NOT_CONSUMED: "CheckoutOffer '{offerId}' muss eingel\xF6st sein, bevor der Vertrag entsteht",
   CHECKOUT_OFFER_CHANGED: "Checkout-Angebot '{offerId}' hat sich w\xE4hrend des Abschlusses ge\xE4ndert. Bitte neu laden.",
+  CHECKOUT_OFFER_CONTRACT_IN_FORCE: "Checkout-Angebot '{offerId}' schlie\xDFt einen ersten Vertrag ab, und dieser Mandant hat bereits einen. Ein laufendes Abo \xE4ndert sich \xFCber seinen Plan und seine Add-ons.",
+  CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION: "Checkout-Angebot '{offerId}' nennt Version {offeredVersion} des Add-ons '{bundleKey}', das dieser Mandant in Version {bookedVersion} gebucht hat (Buchung {subscriptionBundleId}). Die Version wechselt \xFCber das Angebot neben dem Add-on.",
   SUBSCRIPTION_CONTRACT_NOT_FOUND: "SubscriptionContract '{contractId}' nicht gefunden",
   NO_ACTIVE_SUBSCRIPTION_CONTRACT: "Kein aktiver Abo-Vertrag f\xFCr Mandant {tenantId}",
   SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SubscriptionContract '{contractId}' ist bereits geschlossen",
@@ -2797,11 +3993,16 @@ var ERROR_MESSAGES_DE = {
   SUBSCRIBER_NOT_FOUND: "Vertragspartner '{subscriberId}' nicht gefunden",
   SUBSCRIBER_LEGAL_NAME_REQUIRED: "Ein Vertragspartner braucht seinen rechtlichen Namen.",
   SUBSCRIBER_DETAIL_INVALID: "Das Feld {field} des Vertragspartners ist ung\xFCltig.",
+  SUBSCRIBER_IDENTITY_INCOMPLETE: "Die Rechnungsadresse des Vertragspartners ist noch nicht vollst\xE4ndig: Ein Vertrag nennt ihn nur mit Stra\xDFe und Hausnummer, PLZ, Ort und Land.",
+  SUBSCRIBER_BUSINESS_STATUS_REASON_REQUIRED: "Eine \xC4nderung, ob der Vertragspartner ein Unternehmen ist, braucht eine Begr\xFCndung.",
+  SUBSCRIBER_VAT_ID_MISSING: "Der Vertragspartner hat keine Umsatzsteuer-Identifikationsnummer, die sich pr\xFCfen lie\xDFe.",
   SUBSCRIBER_IDENTITY_NOT_A_CONTACT: "{field} geh\xF6rt zur rechtlichen Identit\xE4t des Vertragspartners und \xE4ndert sich nur als Korrektur mit Begr\xFCndung.",
   SUBSCRIBER_CORRECTION_REASON_REQUIRED: "Eine Korrektur der rechtlichen Identit\xE4t braucht eine Begr\xFCndung.",
   SUBSCRIBER_CORRECTION_ACTOR_REQUIRED: "Eine Korrektur der rechtlichen Identit\xE4t muss nennen, wer sie vornimmt.",
   SUBSCRIBER_CORRECTION_CHANGES_NOTHING: "Die Korrektur \xE4ndert nichts: Jeder genannte Wert ist bereits erfasst.",
   SUBSCRIBER_TAKEOVER_IS_A_TRANSFER: "\xDCbernimmt eine andere Rechtsperson, ist das eine \xDCbertragung und keine Korrektur; sie l\xE4sst sich nicht als \xC4nderung erfassen.",
+  SUBSCRIBER_BUSINESS_STATUS_NOT_A_CONTACT: "Ob der Vertragspartner ein Unternehmen ist, geh\xF6rt zu seiner steuerlichen Herkunft und \xE4ndert sich nur als erfasste \xC4nderung, die nennt, wer sie vornimmt.",
+  SUBSCRIBER_CHANGE_ACTOR_REQUIRED: "Eine \xC4nderung der Angaben des Vertragspartners muss nennen, wer sie vornimmt.",
   // ── registration ──
   PENDING_REGISTRATION_NOT_FOUND: "Diese Registrierung konnten wir nicht finden. Vielleicht ist sie bereits abgeschlossen oder verworfen.",
   PENDING_REGISTRATION_EXPIRED: "Diese Registrierung ist abgelaufen. Bitte fange noch einmal von vorn an.",
@@ -2835,7 +4036,11 @@ var ERROR_MESSAGES_DE = {
   MAINTENANCE_WINDOW_END_NOT_AFTER_START: "Das Ende eines Wartungsfensters muss nach seinem Beginn liegen.",
   MAINTENANCE_WINDOW_END_IN_PAST: "Das Ende eines Wartungsfensters darf nicht in der Vergangenheit liegen.",
   MAINTENANCE_TIME_INVALID: "{field} muss Datum und Uhrzeit mit Zeitzone sein, etwa 2026-10-02T22:00+02:00.",
-  MAINTENANCE_MESSAGE_TOO_LONG: "Die Nachricht darf h\xF6chstens {max} Zeichen lang sein."
+  MAINTENANCE_MESSAGE_TOO_LONG: "Die Nachricht darf h\xF6chstens {max} Zeichen lang sein.",
+  // ── tax ──
+  TAX_TREATMENT_NOT_SUPPORTED: "Der Steueradapter {adapter} unterst\xFCtzt diesen Fall nicht: {reason}",
+  TAX_VAT_ID_CHECK_NOT_COMPLETED: "Die Umsatzsteuer-Identifikationsnummer lie\xDF sich gerade nicht pr\xFCfen ({reason}). Bitte sp\xE4ter erneut versuchen.",
+  TAX_VAT_ID_CHECK_NOT_AVAILABLE: "Diese Installation nennt keinen Steueradapter, darum wird keine Umsatzsteuer-Identifikationsnummer gepr\xFCft."
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2843,6 +4048,7 @@ var ERROR_MESSAGES_DE = {
   AUTH_ERROR_CODES,
   BILLING_ERROR_CODES,
   BUNDLE_PRICE_LOOKUP_LIMIT,
+  BUNDLE_VERSION_RETIREMENT_CAPABILITY,
   CATALOGUE_KEYS,
   CATALOG_ERROR_CODES,
   CONTRACT_ERROR_CODES,
@@ -2850,7 +4056,13 @@ var ERROR_MESSAGES_DE = {
   ERROR_MESSAGES_DE,
   ERROR_MESSAGES_EN,
   FEATURE_NOT_LICENSED,
+  FEATURE_WITHDRAWAL_CAPABILITY,
+  FEATURE_WITHDRAWAL_REASON_MAX_LENGTH,
   ForeignPaymentMethodReferenceError,
+  INVOICE_ARCHIVE_TRIGGERS,
+  INVOICE_DOCUMENT_CAPABILITY,
+  INVOICE_ERROR_CODES,
+  INVOICE_SEQUENCE_DIGITS,
   LEGAL_IDENTITY_FIELDS,
   MAINTENANCE_CAPABILITY,
   MAINTENANCE_ERROR_CODES,
@@ -2883,9 +4095,21 @@ var ERROR_MESSAGES_DE = {
   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_ERROR_CODES,
+  SUBSCRIBER_INVOICE_ADDRESS_FIELDS,
+  SUBSCRIBER_STANDING_CAPABILITY,
+  SUBSCRIBER_TAX_ORIGIN_FIELDS,
+  TAX_ERROR_CODES,
+  TAX_TREATMENT_KINDS,
   VERSION_RETIREMENT_CAPABILITY,
+  addDaysToDay,
   applyPromo,
+  asXmlReadsIt,
   assertPersistenceCapabilities,
   buildActivePlanVersionWhere,
   buildActiveVersionWhere,
@@ -2894,6 +4118,7 @@ var ERROR_MESSAGES_DE = {
   bundleKeyTaken,
   bundleStemDefaults,
   canonicalJson,
+  canonicalVatId,
   catalogDraftExists,
   catalogVersionAlreadyPublished,
   catalogVersionGone,
@@ -2908,14 +4133,28 @@ var ERROR_MESSAGES_DE = {
   contractPartiesOf,
   coverageExcludingSelf,
   customLimitsReader,
+  dayInZone,
   definedFields,
   diffSettings,
+  draftSubscriptionInvoice,
+  endedAtOnceSubjectOf,
+  featureWithdrawalRowOf,
+  featuresWithdrawnAt,
   formatCustomerNumber,
   formatErrorMessage,
+  formatInvoiceNumber,
   grossFromNet,
+  holdsOnlyXmlCharacters,
   identityCorrectionDelta,
+  invoiceArchiveProtectionProblem,
+  invoiceContentDraftOf,
+  invoiceFooterOf,
+  invoiceGroupsOf,
+  invoiceIssuerOf,
   isBundleRedundant,
+  isFeatureWithdrawnAt,
   isForeignPaymentMethodReferenceError,
+  isInvoiceDocumentChecksum,
   isMaintenanceAnnouncementLapsed,
   isMaintenanceOverrun,
   isPaymentCallbackRejectedError,
@@ -2925,6 +4164,8 @@ var ERROR_MESSAGES_DE = {
   isVersionEditable,
   issuerIdentityOf,
   keepOneRecommended,
+  keepsVatIdCheck,
+  lastDayInZone,
   maintenanceRetryAfterSeconds,
   maintenanceStatusOf,
   maintenanceWindowStatusOf,
@@ -2934,6 +4175,7 @@ var ERROR_MESSAGES_DE = {
   missingRequiresFor,
   movedIdentityFields,
   netFromGross,
+  nextWithdrawalChange,
   noActivePlanVersion,
   parseZonedInstant,
   percentOf,
@@ -2970,11 +4212,22 @@ var ERROR_MESSAGES_DE = {
   subscriptionBundleGone,
   subscriptionContractGone,
   subscriptionGone,
+  subscriptionInvoiceChargeInvoiced,
+  subscriptionInvoiceColumns,
+  subscriptionInvoiceDocumentChanged,
+  subscriptionInvoiceLineColumns,
   sumToCents,
+  taxOriginOf,
+  taxOriginWrite,
+  taxPerRate,
+  taxTreatmentToJson,
+  toArchivedInvoiceDocument,
   toBundleStemRow,
+  toBundleVersionRetirementRecord,
   toCents,
   toContractLineItemRecord,
   toDecimalString,
+  toFeatureWithdrawalRecord,
   toMaintenanceWindowRecord,
   toPlanRow,
   toPlanVersionRow,
@@ -2983,11 +4236,22 @@ var ERROR_MESSAGES_DE = {
   toSubscriberCorrectionRecord,
   toSubscriberPaymentMethodRecord,
   toSubscriberRecord,
+  toSubscriberTaxOriginChangeRecord,
+  toSubscriberVatIdCheckRecord,
   toSubscriptionBundleRecord,
   toSubscriptionContractRecord,
+  toSubscriptionInvoiceDocumentRecord,
+  toSubscriptionInvoiceRecord,
   toSubscriptionNoticeRecord,
+  toTaxOriginValues,
+  toTaxTreatment,
   toVersionRetirementRecord,
+  utcMidnightOf,
+  vatCategoryOf,
+  vatIdCheckFromStore,
   versionOnSale,
   versionOnSaleOrNext,
-  versionSale
+  versionSale,
+  withdrawnFeaturesOf,
+  yearOfDay
 });