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

package/dist/index.d.ts

@@ -859,6 +859,18 @@ interface PlanCatalogSubscribers {
      */
     customerNumberPrefix?: string;
 }
+/** `config/saas.yaml#invoicing`: how the invoices issued from the charge journal are numbered and when they are due. */
+interface PlanCatalogInvoicing {
+    /** Put in front of every invoice number: `AHP` gives `AHP-2026-000123`. */
+    numberPrefix: string;
+    /** Days from an invoice's issue date to the day it is due (`SC-PRIC-046`). */
+    paymentTermDays: number;
+    /**
+     * What a business letter of the issuer states beyond the invoice's own
+     * content, line by line — copied onto every invoice issued (`SC-PRIC-077`).
+     */
+    footer?: string[];
+}
 /** One account at a payment gateway, by the name `PlanCatalogPayments.accounts` gives it. */
 interface PlanCatalogPaymentAccount {
     /** The provider its bound adapter names itself as, e.g. `stripe`. */
@@ -878,6 +890,13 @@ interface PlanCatalogPayments {
     /** Every account taking new payment methods or holding a reference in use. */
     accounts: Record<string, PlanCatalogPaymentAccount>;
 }
+/** `config/saas.yaml#tax`: the adapter an installation names, and what the operator declares to it. */
+interface PlanCatalogTax {
+    /** The adapter's package name, such as `@saasicat/tax-de`. */
+    adapter: string;
+    /** The options the adapter's factory builds it with; the factory checks them. */
+    options?: Record<string, unknown>;
+}
 /**
  * The part of `config/saas.yaml` that is configuration rather than catalogue.
  *
@@ -890,8 +909,15 @@ interface PlanCatalogSettings {
     app: PlanCatalogApp;
     /** ISO-4217 currency code. */
     currency: string;
-    /** VAT rate in percent. */
-    vatRate: number;
+    /**
+     * VAT rate in percent. Every installation names it unless `tax` names a
+     * tax adapter, which is then the one source of every rate.
+     */
+    vatRate?: number;
+    /** The tax adapter that decides each charge's treatment, and its options. */
+    tax?: PlanCatalogTax;
+    /** The installation's time zone, an IANA name; required with `tax` (`SC-PRIC-045`). */
+    timeZone?: string;
     /** Commercial settings for the tenant self-service routes. */
     tenantBilling: PlanCatalogTenantBilling;
     /** App-wide marketing configuration. Optional. */
@@ -902,6 +928,8 @@ interface PlanCatalogSettings {
     issuer?: PlanCatalogIssuer;
     /** How subscribers are numbered. Optional. */
     subscribers?: PlanCatalogSubscribers;
+    /** How invoices are numbered and when they are due; named exactly where invoices are issued. */
+    invoicing?: PlanCatalogInvoicing;
     /** The payment gateway accounts. Optional until payment methods are taken. */
     payments?: PlanCatalogPayments;
 }
@@ -1008,46 +1036,572 @@ interface PromoCodeValidationLog {
 }
 
 /**
- * A tenant's own limits beside its plan — a negotiated contract, a pilot.
- * `quotas[key]` replaces the plan's value for that quota, `-1` meaning
- * unlimited; `features` adds to the plan's. Stored as JSON in
- * `subscriptions.customLimits`.
+ * A tenant's own limits beside its plan — a negotiated contract, a pilot.
+ * `quotas[key]` replaces the plan's value for that quota, `-1` meaning
+ * unlimited; `features` adds to the plan's. Stored as JSON in
+ * `subscriptions.customLimits`.
+ */
+interface CustomLimits {
+    quotas?: Record<QuotaKey, number>;
+    features?: FeatureKey[];
+}
+/**
+ * The keys a stored `customLimits` value is read by. The normative admin API
+ * schema (`CustomLimits` in `@saasicat/spec`) is held to the same list.
+ */
+declare const CUSTOM_LIMITS_KEYS: readonly ["quotas", "features"];
+/** What a stored `customLimits` value gave, and what in it went unread. */
+interface ReadCustomLimits {
+    limits: CustomLimits | null;
+    /**
+     * The parts of the stored value the platform does not read — a key it does
+     * not know, or a `quotas`/`features` of the wrong kind. Empty when every
+     * part was read.
+     */
+    unread: string[];
+}
+/**
+ * Reads a stored `customLimits` value the way the platform applies it.
+ *
+ * A shape the platform does not read is reported rather than refused: the
+ * tenant keeps its plan's limits and goes on working, as a limit nothing can
+ * count does not block anybody (`SC-ENTL-010`), and the caller says out loud
+ * which limits were not applied. Each quota value goes through
+ * `readQuotaValue`, the one reading of a quota in JSON.
+ */
+declare function readCustomLimits(value: unknown): ReadCustomLimits;
+/**
+ * Reads stored limits for an adapter, and reports what went unread once per
+ * subscription — every entitlement read passes through here, so reporting on
+ * each would bury the one line an operator needs under thousands.
+ */
+declare function customLimitsReader(report: (line: string) => void): (subscriptionId: string, stored: unknown) => CustomLimits | null;
+
+/** Alias for historical compatibility — equivalent to VersionChangeDirection. */
+type ChangeDirection = VersionChangeDirection;
+interface DiffResult {
+    nonRegressive: boolean;
+    changes: VersionChange[];
+}
+/**
+ * `Decimal | string | number` — the three forms in which prices appear
+ * in the platform. `Decimal` is the Prisma class (with
+ * `.toNumber()`), which is not imported directly in order to keep the
+ * platform Prisma-free — a structural view suffices.
+ */
+type DecimalLike = number | string | {
+    toNumber(): number;
+};
+interface PlanVersionFields {
+    features: FeatureKey[];
+    /**
+     * Quotas of the version. -1 = unlimited; missing key = 0.
+     *
+     * Every key either side carries is compared. Which keys exist is the
+     * installation's decision — they come from `@DefinesQuota` — so a fixed
+     * set here would have compared the three the platform happened to know by
+     * name and let every other one be lowered without the confirmation
+     * publishing a regression asks for.
+     */
+    quotas: Record<QuotaKey, number>;
+    monthlyNet: DecimalLike;
+    yearlyNet: DecimalLike;
+}
+interface BundleVersionFields {
+    features: FeatureKey[];
+    /** Quota contributions of the bundle. -1 = unlimited; missing key = 0. */
+    quotas: Record<QuotaKey, number>;
+    /** Default pricing; null = only override pricing possible. */
+    monthlyNet: DecimalLike | null;
+    yearlyNet: DecimalLike | null;
+}
+declare function classifyPlanDiff(oldV: PlanVersionFields, newV: PlanVersionFields): DiffResult;
+/**
+ * Classification of a BundleVersion diff for contract protection.
+ *
+ * Quotas are compared exactly as they are for a plan.
+ *
+ * Pricing can be `null` (the bundle only has override pricing); a switch
+ * from value ↔ null is classified as REGRESSION (value dropped) or IMPROVEMENT
+ * (value added, lowerIsBetter inverted). Both null
+ * stay NEUTRAL.
+ */
+declare function classifyBundleVersionDiff(oldV: BundleVersionFields, newV: BundleVersionFields): DiffResult;
+
+/**
+ * - `improvement` — nothing dearer in any rhythm, no feature missing, no quota
+ *   lower. Taken at once and free, the term kept.
+ * - `more-for-more` — nothing missing or lower, but dearer in at least one
+ *   rhythm. Taken like an upgrade: at once, the difference prorated. The rule
+ *   reads every rhythm, so in the subscriber's own the difference can be zero
+ *   or below — monthly 49 to 45 with yearly 490 to 500 is more for more for a
+ *   monthly subscriber too.
+ * - `takes-something-away` — a feature missing or a quota lower, whatever the
+ *   price. Taken like a downgrade: at the end of the running term, and only
+ *   when the subscriber asks for it.
+ * - `same` — the two agree on everything compared: there is nothing to offer.
+ */
+type VersionOfferClass = 'improvement' | 'more-for-more' | 'takes-something-away' | 'same';
+/**
+ * A version as the comparison reads it. A price may be absent: that is a
+ * rhythm the version is not sold in, and a rhythm that stops being sold counts
+ * against the candidate like a price that went up.
+ */
+type VersionOfferFields = BundleVersionFields;
+interface VersionOffer {
+    readonly class: VersionOfferClass;
+    /** Every difference, bound to candidate, as the catalogue's diff states it. */
+    readonly changes: readonly VersionChange[];
+}
+/** One version as a subscriber compares it. A price of null is a rhythm it is not sold in. */
+interface VersionOfferSide {
+    readonly planVersionId: string;
+    readonly version: number;
+    readonly features: readonly string[];
+    readonly quotas: Readonly<Record<string, number>>;
+    readonly monthlyNet: number | null;
+    readonly yearlyNet: number | null;
+    /** The last day it is sold on, where a successor closes its window — ISO, the whole day included. */
+    readonly validUntil: string | null;
+    /** When an operator ended it, where one did — ISO; from then it is not sold. */
+    readonly endsAt: string | null;
+}
+/**
+ * A newer version of the subscriber's plan, offered: the version bound and the
+ * one offered side by side, what kind of offer it is, and when a switch taken
+ * now would take effect — at once, or, for one that takes something away, at
+ * the end of the running term. `GET billing/version-offer` answers with it.
+ */
+interface VersionOfferView {
+    readonly plan: string;
+    readonly bound: VersionOfferSide;
+    readonly offered: VersionOfferSide;
+    readonly class: Exclude<VersionOfferClass, 'same'>;
+    readonly changes: readonly VersionChange[];
+    /** ISO instant. */
+    readonly takesEffectAt: string;
+}
+/**
+ * What taking an offer did: the version left and the one taken, and whether it
+ * applied at once or waits for `takesEffectAt`. `POST billing/version-offer/accept`
+ * answers with it.
+ */
+interface VersionSwitchResult {
+    readonly class: Exclude<VersionOfferClass, 'same'>;
+    readonly fromPlanVersionId: string;
+    readonly planVersionId: string;
+    readonly immediate: boolean;
+    /** ISO instant. */
+    readonly takesEffectAt: string;
+}
+/**
+ * Classifies `candidate` against `bound`. The comparison is the catalogue's
+ * own diff — prices with a rhythm that may be absent, as a bundle version's
+ * are — so an offer and a published version describe their changes alike.
+ */
+declare function classifyVersionOffer(bound: VersionOfferFields, candidate: VersionOfferFields): VersionOffer;
+
+/** A version, as an announcement names it. */
+interface RetiredVersionRef {
+    readonly planVersionId: string;
+    readonly planKey: string;
+    readonly version: number;
+}
+/** An announcement as it is kept: one per retirement, whoever it reaches. */
+interface VersionRetirementRecord {
+    readonly id: string;
+    /** The version retired. */
+    readonly retired: RetiredVersionRef;
+    /** The version its subscriptions continue on, named by the operator. */
+    readonly replacement: RetiredVersionRef;
+    readonly announcedAt: Date;
+    /** Who announced it — an actor tag, as the audit log writes it. */
+    readonly announcedBy: string;
+}
+type NewVersionRetirement = Omit<VersionRetirementRecord, 'id'>;
+/**
+ * The manifest capability that announces retiring a version. The platform sets
+ * it where it serves the routes, and the admin UI offers the action only where
+ * it is set. Whether the operator's terms allow it is a blocker the preview
+ * reports, so an operator who has not confirmed them learns what is missing.
+ */
+declare const VERSION_RETIREMENT_CAPABILITY = "planVersions.retire";
+/**
+ * One of the two versions of a retirement, as the subscriber compares them:
+ * price in each rhythm, quotas and features, with the plan it belongs to — the
+ * replacement may be a version of another plan.
+ */
+interface RetirementSide extends VersionOfferSide {
+    readonly planKey: string;
+}
+/**
+ * A plan version a subscription is on is being retired, and the subscription
+ * continues on the named replacement from its effective date. Sent once per
+ * subscription and retirement, when the retirement is announced, and kept as
+ * it was sent: the record shows what the subscriber was told, prices included.
+ */
+interface VersionRetiredNotice {
+    readonly kind: 'version-retired';
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly retirementId: string;
+    readonly retired: RetirementSide;
+    readonly replacement: RetirementSide;
+    /** Every difference, retired to replacement, as the catalogue's diff states it. */
+    readonly changes: readonly VersionChange[];
+    /**
+     * The rhythm the subscription is billed in when the retirement takes
+     * effect — a change of rhythm scheduled by then included — which says
+     * which of the two prices applies.
+     */
+    readonly billingCycle: string;
+    /** ISO 8601. */
+    readonly effectiveAt: string;
+    /** ISO date (`YYYY-MM-DD`), UTC. */
+    readonly lastDayToCancel: string;
+}
+/**
+ * The one reminder of a retirement, where staying put costs the subscription
+ * something (`SC-SUB-034`): sent 14 days before the retirement takes effect,
+ * once per subscription and retired version. It says again what the
+ * retirement notice said, and what a switch taken now would cost. Its
+ * `billingCycle` is still the rhythm billed at the date, read again from the
+ * subscription as it stands when the reminder is sent: a change of rhythm
+ * scheduled since the announcement is in it.
+ */
+interface VersionRetirementReminder extends Omit<VersionRetiredNotice, 'kind'> {
+    readonly kind: 'version-retirement-reminder';
+    /**
+     * What switching to the replacement now costs in the subscription's rhythm
+     * (`SC-SUB-032`), or null where it cannot switch now: in a trial, with a
+     * change scheduled, or where either plan is held for a special contract.
+     */
+    readonly switchTerms: RetirementSwitchTerms | null;
+}
+/**
+ * Why a retirement does not reach a subscription on the version:
+ *
+ * - `ended` — the subscription is over.
+ * - `cancelled-before` — its cancellation lands by the effective date.
+ * - `changes-before` — a scheduled change moves it to another plan, or to
+ *   another version of this one, by then.
+ * - `no-term` — it carries no date a term can be counted from.
+ * - `already-told` — an earlier announcement of this version reached it, and
+ *   stands.
+ */
+type RetirementSkipReason = 'ended' | 'cancelled-before' | 'changes-before' | 'no-term' | 'already-told';
+/** A refusal as the preview reports it and the announcement throws it. */
+interface RetirementBlocker {
+    readonly code: string;
+    readonly message: string;
+    readonly params: Record<string, string | number>;
+}
+/** A subscription a retirement reaches, with what it means there. */
+interface RetirementReachedRow {
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly status: string;
+    /** The rhythm it is billed in when the retirement takes effect. */
+    readonly billingCycle: string;
+    /** ISO 8601. */
+    readonly effectiveAt: string;
+    /** ISO date, UTC. */
+    readonly lastDayToCancel: string;
+    /** Reached by another retirement within the last twelve months: the announcement waits. */
+    readonly reachedRecently: boolean;
+}
+/** A subscription on the version a retirement does not reach, and why. */
+interface RetirementSkippedRow {
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly reason: RetirementSkipReason;
+}
+/** What announcing a retirement now would do. */
+interface RetirementPreview {
+    readonly retired: RetirementSide;
+    readonly replacement: RetirementSide;
+    /** Every difference, retired to replacement, as the subscribers will be told it. */
+    readonly changes: readonly VersionChange[];
+    /** ISO 8601: the moment it is computed for. */
+    readonly asOf: string;
+    readonly reached: readonly RetirementReachedRow[];
+    readonly skipped: readonly RetirementSkippedRow[];
+    /** Empty where it may be announced as it stands. */
+    readonly blockers: readonly RetirementBlocker[];
+}
+/** What an announcement did. */
+interface RetirementAnnounced {
+    readonly retirement: VersionRetirementRecord;
+    /** Notices sent now; the rest are sent by the next run. */
+    readonly told: number;
+    readonly failed: number;
+}
+/**
+ * Why a notice not told yet waits — for a subscription a plan version's
+ * retirement reached, or a booking an add-on version's did. The run that sends
+ * the notices asks the same questions in the same order.
+ */
+interface NotToldReasons {
+    /**
+     * What the notice announces would not fit at its date: the replacement's
+     * plan could not carry the add-ons held then, or the replacement add-on
+     * could not run beside a plan the booking meets. It waits until it would.
+     */
+    readonly doesNotFit: number;
+    /** Told of another retirement within the last twelve months: it waits until those are over. */
+    readonly twelveMonths: number;
+    /**
+     * No longer reached: something of the subscriber's own — a change taking
+     * it off the version, a cancellation landing first — came before the date.
+     * It will not be sent.
+     */
+    readonly noLongerReached: number;
+    /** Nothing holds it back: it has reached nobody yet, and the next run tries again. */
+    readonly nobodyYet: number;
+}
+/**
+ * How far a retirement has come, counted over the subscriptions — or, for an
+ * add-on version, the bookings — it reached (`SC-SUB-033`, `SC-BUN-053`).
+ */
+interface RetirementProgress {
+    /** Off the retired version: moved at their date, switched early, or changed on their own. */
+    readonly moved: number;
+    /** Still on the retired version, before their date. */
+    readonly waiting: number;
+    /** Still on the retired version after their date: the run has not moved them yet, or cannot. */
+    readonly overdue: number;
+    /**
+     * Still on the retired version, and ended by their date: there is nothing
+     * to move. A booking that ended after its date, before a move came, counts
+     * here too: nothing moves a booking that has ended.
+     */
+    readonly ended: number;
+    /**
+     * Still on the retired version, and not told yet: their notice has reached
+     * nobody, so their date is not set and nothing moves them (`SC-SUB-038`).
+     */
+    readonly notTold: number;
+    /**
+     * Why those counted `notTold` are not told yet, each counted once. Absent
+     * from a server that does not count them.
+     */
+    readonly notToldReasons?: NotToldReasons;
+    /**
+     * Reminded 14 days before their date (`SC-SUB-034`) — counted beside the
+     * four above, not instead of one: a subscription reminded moves later.
+     */
+    readonly reminded: number;
+}
+/** An announcement as the administration lists it, with how far it has come. */
+interface VersionRetirementView extends VersionRetirementRecord {
+    readonly progress: RetirementProgress;
+}
+/** What one run of the moves at the date did. */
+interface RetirementMoveRun {
+    /**
+     * Subscriptions, or bookings, moved onto their replacement, with the
+     * contract the move writes.
+     */
+    readonly moved: number;
+    /** Moves that could not be made, and are tried again by the next run. */
+    readonly failed: number;
+}
+/** What switching to the replacement before the date did (`SC-SUB-032`). */
+interface RetirementSwitchResult {
+    readonly fromPlanVersionId: string;
+    readonly planVersionId: string;
+    /** ISO date of the last day the price is held, or null where none is. */
+    readonly heldUntilDay: string | null;
+}
+
+/** What the switch costs, per period of the subscriber's rhythm. */
+interface RetirementSwitchTerms {
+    /** The replacement's net price. */
+    readonly priceNet: number;
+    /**
+     * Where the replacement costs more: the price the subscriber goes on paying,
+     * the difference that is held, and the last day it is held — the day before
+     * the date they were told. Null where it costs the same or less: its price
+     * then applies from the subscriber's next period.
+     */
+    readonly held: {
+        readonly priceNet: number;
+        readonly amountNet: number;
+        readonly lastDay: string;
+    } | null;
+}
+/**
+ * A side of a retirement as its prices are compared: what it costs in each
+ * rhythm, for a plan version or for an add-on version beside a plan.
  */
-interface CustomLimits {
-    quotas?: Record<QuotaKey, number>;
-    features?: FeatureKey[];
+type RetirementPricedSide = Pick<RetirementSide, 'monthlyNet' | 'yearlyNet'>;
+/**
+ * What switching to the replacement now costs in `billingCycle`, or null where
+ * the replacement has no price in it. A plan version's retirement and an add-on
+ * version's are priced alike: each side by what it costs in each rhythm.
+ */
+declare function retirementSwitchTerms(notice: {
+    readonly retired: RetirementPricedSide;
+    readonly replacement: RetirementPricedSide;
+    readonly lastDayToCancel: string;
+}, billingCycle: string): RetirementSwitchTerms | null;
+
+/** An add-on version, as an announcement names it. */
+interface RetiredBundleVersionRef {
+    readonly bundleVersionId: string;
+    readonly bundleKey: string;
+    readonly version: number;
+}
+/** An add-on retirement as it is kept: one per announcement, whichever bookings it reaches. */
+interface BundleVersionRetirementRecord {
+    readonly id: string;
+    /** The version retired. */
+    readonly retired: RetiredBundleVersionRef;
+    /** The version of the same add-on its bookings continue on, named by the operator. */
+    readonly replacement: RetiredBundleVersionRef;
+    readonly announcedAt: Date;
+    /** Who announced it — an actor tag, as the audit log writes it. */
+    readonly announcedBy: string;
 }
+type NewBundleVersionRetirement = Omit<BundleVersionRetirementRecord, 'id'>;
 /**
- * The keys a stored `customLimits` value is read by. The normative admin API
- * schema (`CustomLimits` in `@saasicat/spec`) is held to the same list.
+ * The manifest capability that announces retiring an add-on version. The
+ * platform sets it where it serves the routes, and the admin UI offers the
+ * action only where it is set.
  */
-declare const CUSTOM_LIMITS_KEYS: readonly ["quotas", "features"];
-/** What a stored `customLimits` value gave, and what in it went unread. */
-interface ReadCustomLimits {
-    limits: CustomLimits | null;
-    /**
-     * The parts of the stored value the platform does not read — a key it does
-     * not know, or a `quotas`/`features` of the wrong kind. Empty when every
-     * part was read.
-     */
-    unread: string[];
+declare const BUNDLE_VERSION_RETIREMENT_CAPABILITY = "bundleVersions.retire";
+/**
+ * An add-on version as the subscriber compares it with another — the one
+ * retired and its replacement, or the one booked and the one offered: what it
+ * grants, and its price beside the subscription's plan in each rhythm —
+ * `pricingOverrides` included — or null where it has none there.
+ */
+interface BundleVersionSide {
+    readonly bundleVersionId: string;
+    readonly bundleKey: string;
+    readonly label: string;
+    readonly version: number;
+    readonly features: readonly string[];
+    readonly quotas: Readonly<Record<string, number>>;
+    readonly monthlyNet: number | null;
+    readonly yearlyNet: number | null;
 }
 /**
- * Reads a stored `customLimits` value the way the platform applies it.
+ * An add-on version a booking is on is being retired, and the booking
+ * continues on the named replacement from its effective date. Sent once per
+ * booking and retirement, and kept as it was sent: the record shows what the
+ * subscriber was told, prices included.
+ */
+interface BundleVersionRetiredNotice {
+    readonly kind: 'bundle-version-retired';
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly subscriptionBundleId: string;
+    readonly retirementId: string;
+    /** The plan the add-on runs beside at the date, which both sides are priced for. */
+    readonly planKey: string;
+    readonly retired: BundleVersionSide;
+    readonly replacement: BundleVersionSide;
+    /** Every difference, retired to replacement, at the prices for `planKey`. */
+    readonly changes: readonly VersionChange[];
+    /** The rhythm the booking is billed in, which says which of the two prices applies. */
+    readonly billingCycle: string;
+    /** ISO 8601. */
+    readonly effectiveAt: string;
+    /** ISO date (`YYYY-MM-DD`), UTC: the last day it may be cancelled without its minimum term. */
+    readonly lastDayToCancel: string;
+}
+/**
+ * Why an add-on retirement does not reach a booking of the version:
  *
- * A shape the platform does not read is reported rather than refused: the
- * tenant keeps its plan's limits and goes on working, as a limit nothing can
- * count does not block anybody (`SC-ENTL-010`), and the caller says out loud
- * which limits were not applied. Each quota value goes through
- * `readQuotaValue`, the one reading of a quota in JSON.
+ * - `ended` — the subscription is over, or the booking's cancellation has
+ *   already landed.
+ * - `cancelled-before` — the booking's cancellation lands by the effective date.
+ * - `changes-before` — the booking's switch to a newer version, taken for the
+ *   end of its term, lands by the effective date.
+ * - `no-term` — it carries no period an end can be counted from.
+ * - `already-told` — an earlier announcement of this version reached it, and
+ *   stands.
  */
-declare function readCustomLimits(value: unknown): ReadCustomLimits;
+type BundleRetirementSkipReason = 'ended' | 'cancelled-before' | 'changes-before' | 'no-term' | 'already-told';
 /**
- * Reads stored limits for an adapter, and reports what went unread once per
- * subscription — every entitlement read passes through here, so reporting on
- * each would bury the one line an operator needs under thousands.
+ * What switching a booking to its retirement's replacement now would cost
+ * (`SC-BUN-054`), in the rhythm the booking is billed in now — its own, or
+ * else its plan's — which need not be the one its notice was told in.
  */
-declare function customLimitsReader(report: (line: string) => void): (subscriptionId: string, stored: unknown) => CustomLimits | null;
+interface BundleRetirementSwitchTerms extends RetirementSwitchTerms {
+    readonly billingCycle: string;
+}
+/**
+ * The one reminder of an add-on retirement (`SC-BUN-056`): sent once, 14 days
+ * before the booking's date, where staying put costs it something. It says
+ * again what the booking was told, with both versions priced for the plan the
+ * add-on runs beside at the date as the catalogue prices them when it is sent,
+ * in the rhythm the booking is billed in then.
+ */
+interface BundleVersionRetirementReminder extends Omit<BundleVersionRetiredNotice, 'kind'> {
+    readonly kind: 'bundle-version-retirement-reminder';
+    /** What switching to the replacement now costs (`SC-BUN-054`), or null where the booking cannot. */
+    readonly switchTerms: BundleRetirementSwitchTerms | null;
+}
+/** What switching a booking to its retirement's replacement before the date did. */
+interface BundleRetirementSwitchResult {
+    readonly subscriptionBundleId: string;
+    readonly fromBundleVersionId: string;
+    readonly bundleVersionId: string;
+    /** ISO date of the last day the price is held, or null where none is. */
+    readonly heldUntilDay: string | null;
+}
+/** A booking an add-on retirement reaches, with what it means there. */
+interface BundleRetirementReachedRow {
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly subscriptionBundleId: string;
+    /** The plan the add-on runs beside when the retirement takes effect. */
+    readonly planKey: string;
+    /** The rhythm the plan is billed in then. */
+    readonly planCycle: string;
+    /** The rhythm the booking is billed in. */
+    readonly billingCycle: string;
+    /** ISO 8601. */
+    readonly effectiveAt: string;
+    /** ISO date, UTC. */
+    readonly lastDayToCancel: string;
+    /** Its subscription was reached by a retirement within the last twelve months: the announcement waits. */
+    readonly reachedRecently: boolean;
+}
+/** A booking of the version an add-on retirement does not reach, and why. */
+interface BundleRetirementSkippedRow {
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly subscriptionBundleId: string;
+    readonly reason: BundleRetirementSkipReason;
+}
+/** What announcing an add-on retirement now would do. */
+interface BundleRetirementPreview {
+    /** The two versions at their own prices, before any plan's override. */
+    readonly retired: BundleVersionSide;
+    readonly replacement: BundleVersionSide;
+    /** Every difference at those prices; each booking is told the one at its plan's. */
+    readonly changes: readonly VersionChange[];
+    /** ISO 8601: the moment it is computed for. */
+    readonly asOf: string;
+    readonly reached: readonly BundleRetirementReachedRow[];
+    readonly skipped: readonly BundleRetirementSkippedRow[];
+    /** Empty where it may be announced as it stands. */
+    readonly blockers: readonly RetirementBlocker[];
+}
+/** What an add-on announcement did. */
+interface BundleRetirementAnnounced {
+    readonly retirement: BundleVersionRetirementRecord;
+    /** Notices sent now; the rest are sent by the next run. */
+    readonly told: number;
+    readonly failed: number;
+}
+/** An add-on announcement as the administration lists it, with how far it has come. */
+interface BundleVersionRetirementView extends BundleVersionRetirementRecord {
+    readonly progress: RetirementProgress;
+}
 
 type SubscriptionStatus = 'TRIAL' | 'ACTIVE' | 'PAST_DUE' | 'CANCELED' | 'PENDING_SALES';
 interface Subscription {
@@ -1145,9 +1699,11 @@ interface VersionedEntityBase {
  * their own minimum term + their own cancellation (user requirement from
  * P11.7.3).
  *
- * - `bundleVersionId` binds the booking to an *exact* BundleVersion
- *   (immutable; bundle updates only take effect after a new version with its
- *   own migration).
+ * - `bundleVersionId` binds the booking to an *exact* BundleVersion. A newer
+ *   version of the add-on does not change it by being published: an add-on
+ *   retirement moves the booking onto its replacement at its date
+ *   (`SC-BUN-049`), and the subscriber moves it by taking a newer version
+ *   offered (`SC-BUN-058`).
  * - `startedAt` is the contract start of this booking.
  * - `minimumTermEndsAt` = end of the minimum term; `null` = no minimum term
  *   (platform default = no commitment, set service-side).
@@ -1179,6 +1735,15 @@ interface SubscriptionBundleRecord {
     billingCycle: BillingCycle | null;
     currentPeriodStart: Date | null;
     currentPeriodEnd: Date | null;
+    /**
+     * A switch to another version of the add-on, taken for the end of the
+     * booking's running term because it takes something away (`SC-BUN-058`):
+     * the version the booking continues on, and from when. Both null where
+     * none is scheduled. The run that makes the switch at that moment clears
+     * them; until then the booking stays on `bundleVersionId`.
+     */
+    pendingBundleVersionId: string | null;
+    pendingVersionEffectiveAt: Date | null;
     createdAt: Date;
     updatedAt: Date;
 }
@@ -1202,6 +1767,18 @@ interface SubscriptionBundleView extends SubscriptionBundleRecord {
      * defect: a field called `monthlyNet` on a yearly booking cannot be right.
      */
     priceNet: number | null;
+    /**
+     * The number of the version a switch scheduled for the end of the booking's
+     * term moves it to (`pendingBundleVersionId`); null where none is
+     * scheduled.
+     */
+    pendingVersion?: number | null;
+    /**
+     * The retirement of the add-on version this booking is on, as the
+     * subscriber was told it (`SC-BUN-046`); absent or null where none was
+     * told, or once the booking is on another version.
+     */
+    retirement?: BundleVersionRetiredNotice | null;
 }
 interface CreateSubscriptionBundleData {
     subscriptionId: string;
@@ -1580,7 +2157,7 @@ interface AdminManifest {
         actions?: AuditActionDef[];
     };
 }
-type StandardPageKey = 'dashboard' | 'tenants' | 'subscriptions' | 'promoCodes' | 'plans' | 'audit' | 'users' | 'pilots' | 'discovery' | 'bundles' | 'marketingCatalog' | 'platformEmail' | 'platformEmailHistory' | 'settings' | 'maintenance';
+type StandardPageKey = 'dashboard' | 'tenants' | 'subscriptions' | 'promoCodes' | 'plans' | 'audit' | 'users' | 'pilots' | 'discovery' | 'bundles' | 'marketingCatalog' | 'platformEmail' | 'platformEmailHistory' | 'settings' | 'maintenance' | 'featureWithdrawals';
 interface StandardPageDef {
     enabled: boolean;
     requiredCapability?: CapabilityKey;
@@ -1868,6 +2445,35 @@ declare function grossFromNet(net: number, vatRate: number): number;
 declare function netFromGross(gross: number, vatRate: number): number;
 /** The tax a gross amount includes at a rate in per cent: gross × rate / (100 + rate). */
 declare function computeIncludedVat(gross: number, vatRate: number): number;
+/** One tax rate's part of an invoice: the net of its lines and the tax on that net. */
+interface TaxAtRate {
+    /** In per cent. */
+    rate: number;
+    net: number;
+    tax: number;
+}
+/** An invoice's tax, rate by rate, and the totals it states. */
+interface TaxPerRate {
+    /** One entry per rate the lines carry, the lowest rate first. */
+    rates: TaxAtRate[];
+    net: number;
+    tax: number;
+    gross: number;
+}
+/**
+ * An invoice's tax by the rule of EN 16931: the lines' net is summed per rate,
+ * the rate is applied to each sum and rounded once, and the gross is the net
+ * plus that tax.
+ *
+ * Never the sum of the lines' own rounded taxes, which can differ by cents —
+ * ten lines of 12.34 at 19 % carry 2.34 each, 23.40 together, while 19 % of
+ * 123.40 is 23.45 — and an electronic invoice whose stated tax differs from
+ * the one its format computes is rejected.
+ */
+declare function taxPerRate(lines: readonly {
+    net: number;
+    rate: number;
+}[]): TaxPerRate;
 
 type CheckoutOfferLineItemKind = 'plan' | 'bundle' | 'discount';
 /** Frozen billable line item in the offer. */
@@ -2176,6 +2782,12 @@ interface PublicMarketingCatalogResponse {
     currency: string;
     /** VAT rate in percent — for the CheckoutOffer price breakdown. */
     vatRate: number;
+    /**
+     * The country the rate applies to: the issuer's, where a tax adapter
+     * decides and a subscriber elsewhere may be charged another — the page says
+     * so (`SC-PRIC-037`). `null` where the one rate of the file applies to all.
+     */
+    vatRateShownFor: string | null;
     /** What a new payment method is taken with here, if one is taken. */
     newPaymentMethods: PublicNewPaymentMethods;
     /** Visible, marketed plans — sorted by `priority` DESC. */
@@ -2299,171 +2911,64 @@ interface DiscoverySnapshot {
 }
 
 interface EffectiveLimitsSnapshot {
-    plan: string;
-    quotas: Record<string, number>;
-    features: string[];
-    /**
-     * The add-ons a contract left out of these entitlements because their
-     * cancellation was already declared when it was written. Each is granted by
-     * its booking until its effective date, and by this snapshot never.
-     *
-     * Absent where nothing was left out — and on a snapshot written by an
-     * application, or before the platform left anything out, which then counts
-     * every add-on it names as its own.
-     */
-    leftOutBundleVersionIds?: string[];
-}
-
-interface FeatureUiMeta {
-    /** Visible label for plan comparison tables, add-on lists. */
-    label: string;
-    /** Long description for tooltips, add-on cards. */
-    description: string;
-    /** Quasar icon name (e.g. 'directions_car', 'groups'). */
-    icon: string;
-    /** Mirror of `PlanCatalog.features[].plannedOnly` — cache for the UI without a catalog roundtrip. */
-    plannedOnly?: boolean;
-    /** true = base infrastructure, included in every plan (not bookable). */
-    core?: boolean;
-}
-/** Map FeatureKey → UI metadata. Consumer apps supply a complete table. */
-type FeatureUiRegistry = Record<string, FeatureUiMeta>;
-
-/** A quota as a finite number, or `null` where the value cannot be read as one. */
-declare function readQuotaValue(value: unknown): number | null;
-/**
- * Every quota in a JSON column, for a caller that computes with them.
- *
- * A key that is there stays there. Dropping an unreadable one made it *absent*,
- * and absent means undeclared: `enforceLimit` answers an undeclared dimension
- * with a 500, so every operation on that quota was refused — a fail-closed
- * answer to somebody else's corrupt row.
- */
-declare function readQuotaRecord(value: unknown): Record<string, number>;
-
-/** Alias for historical compatibility — equivalent to VersionChangeDirection. */
-type ChangeDirection = VersionChangeDirection;
-interface DiffResult {
-    nonRegressive: boolean;
-    changes: VersionChange[];
-}
-/**
- * `Decimal | string | number` — the three forms in which prices appear
- * in the platform. `Decimal` is the Prisma class (with
- * `.toNumber()`), which is not imported directly in order to keep the
- * platform Prisma-free — a structural view suffices.
- */
-type DecimalLike = number | string | {
-    toNumber(): number;
-};
-interface PlanVersionFields {
-    features: FeatureKey[];
-    /**
-     * Quotas of the version. -1 = unlimited; missing key = 0.
-     *
-     * Every key either side carries is compared. Which keys exist is the
-     * installation's decision — they come from `@DefinesQuota` — so a fixed
-     * set here would have compared the three the platform happened to know by
-     * name and let every other one be lowered without the confirmation
-     * publishing a regression asks for.
-     */
-    quotas: Record<QuotaKey, number>;
-    monthlyNet: DecimalLike;
-    yearlyNet: DecimalLike;
-}
-interface BundleVersionFields {
-    features: FeatureKey[];
-    /** Quota contributions of the bundle. -1 = unlimited; missing key = 0. */
-    quotas: Record<QuotaKey, number>;
-    /** Default pricing; null = only override pricing possible. */
-    monthlyNet: DecimalLike | null;
-    yearlyNet: DecimalLike | null;
-}
-declare function classifyPlanDiff(oldV: PlanVersionFields, newV: PlanVersionFields): DiffResult;
-/**
- * Classification of a BundleVersion diff for contract protection.
- *
- * Quotas are compared exactly as they are for a plan.
- *
- * Pricing can be `null` (the bundle only has override pricing); a switch
- * from value ↔ null is classified as REGRESSION (value dropped) or IMPROVEMENT
- * (value added, lowerIsBetter inverted). Both null
- * stay NEUTRAL.
- */
-declare function classifyBundleVersionDiff(oldV: BundleVersionFields, newV: BundleVersionFields): DiffResult;
-
-/**
- * - `improvement` — nothing dearer in any rhythm, no feature missing, no quota
- *   lower. Taken at once and free, the term kept.
- * - `more-for-more` — nothing missing or lower, but dearer in at least one
- *   rhythm. Taken like an upgrade: at once, the difference prorated. The rule
- *   reads every rhythm, so in the subscriber's own the difference can be zero
- *   or below — monthly 49 to 45 with yearly 490 to 500 is more for more for a
- *   monthly subscriber too.
- * - `takes-something-away` — a feature missing or a quota lower, whatever the
- *   price. Taken like a downgrade: at the end of the running term, and only
- *   when the subscriber asks for it.
- * - `same` — the two agree on everything compared: there is nothing to offer.
- */
-type VersionOfferClass = 'improvement' | 'more-for-more' | 'takes-something-away' | 'same';
-/**
- * A version as the comparison reads it. A price may be absent: that is a
- * rhythm the version is not sold in, and a rhythm that stops being sold counts
- * against the candidate like a price that went up.
- */
-type VersionOfferFields = BundleVersionFields;
-interface VersionOffer {
-    readonly class: VersionOfferClass;
-    /** Every difference, bound to candidate, as the catalogue's diff states it. */
-    readonly changes: readonly VersionChange[];
-}
-/** One version as a subscriber compares it. A price of null is a rhythm it is not sold in. */
-interface VersionOfferSide {
-    readonly planVersionId: string;
-    readonly version: number;
-    readonly features: readonly string[];
-    readonly quotas: Readonly<Record<string, number>>;
-    readonly monthlyNet: number | null;
-    readonly yearlyNet: number | null;
-    /** The last day it is sold on, where a successor closes its window — ISO, the whole day included. */
-    readonly validUntil: string | null;
-    /** When an operator ended it, where one did — ISO; from then it is not sold. */
-    readonly endsAt: string | null;
+    plan: string;
+    quotas: Record<string, number>;
+    features: string[];
+    /**
+     * The add-ons a contract left out of these entitlements because their
+     * cancellation was already declared when it was written. Each is granted by
+     * its booking until its effective date, and by this snapshot never.
+     *
+     * Absent where nothing was left out — and on a snapshot written by an
+     * application, or before the platform left anything out, which then counts
+     * every add-on it names as its own.
+     */
+    leftOutBundleVersionIds?: string[];
 }
-/**
- * A newer version of the subscriber's plan, offered: the version bound and the
- * one offered side by side, what kind of offer it is, and when a switch taken
- * now would take effect — at once, or, for one that takes something away, at
- * the end of the running term. `GET billing/version-offer` answers with it.
- */
-interface VersionOfferView {
-    readonly plan: string;
-    readonly bound: VersionOfferSide;
-    readonly offered: VersionOfferSide;
-    readonly class: Exclude<VersionOfferClass, 'same'>;
-    readonly changes: readonly VersionChange[];
-    /** ISO instant. */
-    readonly takesEffectAt: string;
+
+interface FeatureUiMeta {
+    /** Visible label for plan comparison tables, add-on lists. */
+    label: string;
+    /** Long description for tooltips, add-on cards. */
+    description: string;
+    /** Quasar icon name (e.g. 'directions_car', 'groups'). */
+    icon: string;
+    /** Mirror of `PlanCatalog.features[].plannedOnly` — cache for the UI without a catalog roundtrip. */
+    plannedOnly?: boolean;
+    /** true = base infrastructure, included in every plan (not bookable). */
+    core?: boolean;
+    /**
+     * Set where the feature is withdrawn now or from a date ahead: each
+     * withdrawal of it not over yet, the earliest first — why, from when, and
+     * until when where it is lifted from a date ahead. A feature withdrawn
+     * again from the day it returns carries both. A page that shows the
+     * feature as part of a plan or an add-on shows this beside it, so whoever
+     * concludes knows before they do.
+     */
+    withdrawn?: readonly FeatureWithdrawalMark[];
 }
-/**
- * What taking an offer did: the version left and the one taken, and whether it
- * applied at once or waits for `takesEffectAt`. `POST billing/version-offer/accept`
- * answers with it.
- */
-interface VersionSwitchResult {
-    readonly class: Exclude<VersionOfferClass, 'same'>;
-    readonly fromPlanVersionId: string;
-    readonly planVersionId: string;
-    readonly immediate: boolean;
-    /** ISO instant. */
-    readonly takesEffectAt: string;
+/** One withdrawal of a feature, as a catalogue marks it beside the feature. */
+interface FeatureWithdrawalMark {
+    readonly reason: string;
+    /** ISO 8601. */
+    readonly effectiveFrom: string;
+    /** ISO 8601, where it is lifted from a date ahead. */
+    readonly liftedFrom: string | null;
 }
+/** Map FeatureKey → UI metadata. Consumer apps supply a complete table. */
+type FeatureUiRegistry = Record<string, FeatureUiMeta>;
+
+/** A quota as a finite number, or `null` where the value cannot be read as one. */
+declare function readQuotaValue(value: unknown): number | null;
 /**
- * Classifies `candidate` against `bound`. The comparison is the catalogue's
- * own diff — prices with a rhythm that may be absent, as a bundle version's
- * are — so an offer and a published version describe their changes alike.
+ * Every quota in a JSON column, for a caller that computes with them.
+ *
+ * A key that is there stays there. Dropping an unreadable one made it *absent*,
+ * and absent means undeclared: `enforceLimit` answers an undeclared dimension
+ * with a 500, so every operation on that quota was refused — a fail-closed
+ * answer to somebody else's corrupt row.
  */
-declare function classifyVersionOffer(bound: VersionOfferFields, candidate: VersionOfferFields): VersionOffer;
+declare function readQuotaRecord(value: unknown): Record<string, number>;
 
 interface PromoPreviewRequest {
     /** Promo code (case-insensitive, normalized to uppercase in the service). */
@@ -2740,208 +3245,347 @@ interface MaintenanceUnlockView {
     wasLocked: boolean;
 }
 
-/** What the switch costs, per period of the subscriber's rhythm. */
-interface RetirementSwitchTerms {
-    /** The replacement's net price. */
-    readonly priceNet: number;
-    /**
-     * Where the replacement costs more: the price the subscriber goes on paying,
-     * the difference that is held, and the last day it is held — the day before
-     * the date they were told. Null where it costs the same or less: its price
-     * then applies from the subscriber's next period.
-     */
-    readonly held: {
-        readonly priceNet: number;
-        readonly amountNet: number;
-        readonly lastDay: string;
-    } | null;
+/**
+ * A newer version of a booked add-on, offered beside the booking: the version
+ * booked and the one on sale side by side, what kind of offer it is, and when
+ * a switch taken now would take effect — at once, or, for one that takes
+ * something away, at the end of the booking's running term. The list of the
+ * tenant's bookings carries it on each booking, as `offer`.
+ */
+interface BundleVersionOfferView {
+    readonly subscriptionBundleId: string;
+    /** The plan both versions are priced beside: the one the subscription is on. */
+    readonly planKey: string;
+    /** The rhythm the booking is billed in, which the kind of offer is judged in. */
+    readonly billingCycle: BillingCycle;
+    readonly bound: BundleVersionSide;
+    readonly offered: BundleVersionSide;
+    readonly class: Exclude<VersionOfferClass, 'same'>;
+    /** Every difference, bound to offered, with the price in the booking's rhythm alone. */
+    readonly changes: readonly VersionChange[];
+    /** ISO instant. */
+    readonly takesEffectAt: string;
 }
 /**
- * What switching to the replacement now costs in `billingCycle`, or null where
- * the replacement has no price in it.
+ * What taking an add-on offer did: the booking, the version left and the one
+ * taken, and whether it applied at once or waits for `takesEffectAt`.
  */
-declare function retirementSwitchTerms(notice: Pick<VersionRetiredNotice, 'retired' | 'replacement' | 'lastDayToCancel'>, billingCycle: string): RetirementSwitchTerms | null;
+interface BundleVersionSwitchResult {
+    readonly class: Exclude<VersionOfferClass, 'same'>;
+    readonly subscriptionBundleId: string;
+    readonly fromBundleVersionId: string;
+    readonly bundleVersionId: string;
+    readonly immediate: boolean;
+    /** ISO instant. */
+    readonly takesEffectAt: string;
+}
 
-/** A version, as an announcement names it. */
-interface RetiredVersionRef {
-    readonly planVersionId: string;
-    readonly planKey: string;
-    readonly version: number;
+/** What a reduction is named for: a plan, or an add-on, by its key. */
+type FeatureWithdrawalLineKind = 'plan' | 'bundle';
+/**
+ * The net amount the price of a plan, or of an add-on, is reduced by for one
+ * whole period of `billingCycle` without the feature. A plan or an add-on that
+ * grants the feature and is not named is not reduced.
+ */
+interface FeatureWithdrawalReduction {
+    readonly kind: FeatureWithdrawalLineKind;
+    /** The plan key, or the add-on's (bundle's) key. */
+    readonly key: string;
+    readonly billingCycle: BillingCycle;
+    readonly amountNet: number;
 }
-/** An announcement as it is kept: one per retirement, whoever it reaches. */
-interface VersionRetirementRecord {
+/** The longest reason a withdrawal carries: the operator's words to the subscribers, not a document. */
+declare const FEATURE_WITHDRAWAL_REASON_MAX_LENGTH = 1000;
+/** A withdrawal as it is kept: one per announcement. */
+interface FeatureWithdrawalRecord {
     readonly id: string;
-    /** The version retired. */
-    readonly retired: RetiredVersionRef;
-    /** The version its subscriptions continue on, named by the operator. */
-    readonly replacement: RetiredVersionRef;
+    readonly featureKey: string;
+    /** Why, in the operator's words, as the subscribers are shown it. */
+    readonly reason: string;
+    /** From when the feature is granted to nobody. */
+    readonly effectiveFrom: Date;
+    /** From when it is granted again, once the operator has lifted the withdrawal. */
+    readonly liftedFrom: Date | null;
+    readonly reductions: readonly FeatureWithdrawalReduction[];
     readonly announcedAt: Date;
     /** Who announced it — an actor tag, as the audit log writes it. */
     readonly announcedBy: string;
+    readonly liftedAt: Date | null;
+    readonly liftedBy: string | null;
+    /**
+     * When the subscriptions it reaches were read and their notices recorded;
+     * null until then. Announcing records the withdrawal first and reads who it
+     * reaches once it is recorded, so that a change concluded while it was
+     * being announced is not missed — the quarter-hourly run tells the ones
+     * still null.
+     */
+    readonly toldAt: Date | null;
+}
+type NewFeatureWithdrawal = Pick<FeatureWithdrawalRecord, 'featureKey' | 'reason' | 'effectiveFrom' | 'reductions' | 'announcedAt' | 'announcedBy'>;
+/** What lifting a withdrawal records. */
+interface FeatureWithdrawalLift {
+    readonly liftedFrom: Date;
+    readonly liftedAt: Date;
+    readonly liftedBy: string;
 }
-type NewVersionRetirement = Omit<VersionRetirementRecord, 'id'>;
 /**
- * The manifest capability that announces retiring a version. The platform sets
- * it where it serves the routes, and the admin UI offers the action only where
- * it is set. Whether the operator's terms allow it is a blocker the preview
- * reports, so an operator who has not confirmed them learns what is missing.
+ * Whether `withdrawal` takes its feature away at `at`. A withdrawal lifted
+ * before its date never does.
  */
-declare const VERSION_RETIREMENT_CAPABILITY = "planVersions.retire";
+declare function isFeatureWithdrawnAt(withdrawal: Pick<FeatureWithdrawalRecord, 'effectiveFrom' | 'liftedFrom'>, at: Date): boolean;
+/** The features `withdrawals` take away at `at`. */
+declare function featuresWithdrawnAt(withdrawals: readonly Pick<FeatureWithdrawalRecord, 'featureKey' | 'effectiveFrom' | 'liftedFrom'>[], at: Date): Set<string>;
 /**
- * One of the two versions of a retirement, as the subscriber compares them:
- * price in each rhythm, quotas and features, with the plan it belongs to — the
- * replacement may be a version of another plan.
+ * The first moment after `at` at which what `withdrawals` take away changes —
+ * one takes effect, or is lifted — or null where none is still to come.
  */
-interface RetirementSide extends VersionOfferSide {
-    readonly planKey: string;
+declare function nextWithdrawalChange(withdrawals: readonly Pick<FeatureWithdrawalRecord, 'effectiveFrom' | 'liftedFrom'>[], at: Date): Date | null;
+/**
+ * The manifest capability that announces withdrawing a feature. The platform
+ * sets it where it serves the routes, and the admin UI offers the action only
+ * where it is set.
+ */
+declare const FEATURE_WITHDRAWAL_CAPABILITY = "features.withdraw";
+/**
+ * A line of a subscription a withdrawal reaches: the plan in the rhythm it is
+ * billed in, or one booking of an add-on.
+ */
+interface FeatureWithdrawalLine {
+    readonly line: FeatureWithdrawalLineKind;
+    /** The plan key, or the add-on's key. */
+    readonly key: string;
+    /** The plan's or the add-on's name, as the subscriber reads it. */
+    readonly label: string;
+    /** The booking, where the line is an add-on's; null for the plan. */
+    readonly subscriptionBundleId: string | null;
+    readonly billingCycle: BillingCycle;
+}
+/** A line as the subscriber was told of it: with the reduction it carries, or null for none. */
+interface FeatureWithdrawalNoticeLine extends FeatureWithdrawalLine {
+    readonly reductionNet: number | null;
 }
 /**
- * A plan version a subscription is on is being retired, and the subscription
- * continues on the named replacement from its effective date. Sent once per
- * subscription and retirement, when the retirement is announced, and kept as
- * it was sent: the record shows what the subscriber was told, prices included.
+ * A feature the subscription holds is withdrawn. Sent once per subscription and
+ * withdrawal, at the announcement, and kept as it was sent: it is the record of
+ * which lines the withdrawal reached and what each is reduced by.
  */
-interface VersionRetiredNotice {
-    readonly kind: 'version-retired';
+interface FeatureWithdrawnNotice {
+    readonly kind: 'feature-withdrawn';
     readonly tenantId: string;
     readonly subscriptionId: string;
-    readonly retirementId: string;
-    readonly retired: RetirementSide;
-    readonly replacement: RetirementSide;
-    /** Every difference, retired to replacement, as the catalogue's diff states it. */
-    readonly changes: readonly VersionChange[];
+    readonly withdrawalId: string;
+    readonly featureKey: string;
+    readonly featureLabel: string;
+    readonly reason: string;
+    /** ISO 8601. */
+    readonly effectiveFrom: string;
+    readonly lines: readonly FeatureWithdrawalNoticeLine[];
     /**
-     * The rhythm the subscription is billed in when the retirement takes
-     * effect — a change of rhythm scheduled by then included — which says
-     * which of the two prices applies.
+     * Whether the subscription holds the feature through special terms its
+     * contract records and through no line: then it may end at once, and no
+     * reduction applies by itself.
      */
-    readonly billingCycle: string;
+    readonly specialTerms: boolean;
+}
+/** A withdrawn feature is granted again. Sent once to every subscription told of the withdrawal. */
+interface FeatureWithdrawalLiftedNotice {
+    readonly kind: 'feature-withdrawal-lifted';
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly withdrawalId: string;
+    readonly featureKey: string;
+    readonly featureLabel: string;
     /** ISO 8601. */
-    readonly effectiveAt: string;
-    /** ISO date (`YYYY-MM-DD`), UTC. */
-    readonly lastDayToCancel: string;
+    readonly liftedFrom: string;
 }
 /**
- * The one reminder of a retirement, where staying put costs the subscription
- * something (`SC-SUB-034`): sent 14 days before the retirement takes effect,
- * once per subscription and retired version. It says again what the
- * retirement notice said, and what a switch taken now would cost. Its
- * `billingCycle` is still the rhythm billed at the date, read again from the
- * subscription as it stands when the reminder is sent: a change of rhythm
- * scheduled since the announcement is in it.
+ * The subscription, or one booking of it, ended at once while a feature it
+ * holds was withdrawn: what the account credits the unused rest of the period
+ * already charged from. Recorded by each attempt before it ends anything, so
+ * the credit never lacks its record; an attempt whose end did not happen leaves
+ * one behind, and only the one whose `endedAt` the subscription or the booking
+ * records is sent, counted or credited (`endedAtOnceSubjectOf`).
  */
-interface VersionRetirementReminder extends Omit<VersionRetiredNotice, 'kind'> {
-    readonly kind: 'version-retirement-reminder';
-    /**
-     * What switching to the replacement now costs in the subscription's rhythm
-     * (`SC-SUB-032`), or null where it cannot switch now: in a trial, with a
-     * change scheduled, or where either plan is held for a special contract.
-     */
-    readonly switchTerms: RetirementSwitchTerms | null;
+interface EndedAtOnceNotice {
+    readonly kind: 'ended-at-once';
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    /** The booking that ended; null where the subscription did, and every booking with it. */
+    readonly subscriptionBundleId: string | null;
+    readonly withdrawalId: string;
+    readonly featureKey: string;
+    readonly featureLabel: string;
+    /** ISO 8601. */
+    readonly endedAt: string;
 }
-/**
- * Why a retirement does not reach a subscription on the version:
- *
- * - `ended` — the subscription is over.
- * - `cancelled-before` — its cancellation lands by the effective date.
- * - `changes-before` — a scheduled change moves it to another plan, or to
- *   another version of this one, by then.
- * - `no-term` — it carries no date a term can be counted from.
- * - `already-told` — an earlier announcement of this version reached it, and
- *   stands.
- */
-type RetirementSkipReason = 'ended' | 'cancelled-before' | 'changes-before' | 'no-term' | 'already-told';
-/** A refusal as the preview reports it and the announcement throws it. */
-interface RetirementBlocker {
+/** A blocker or a refusal a person reads: a stable code and the values its sentence names. */
+interface FeatureWithdrawalBlocker {
     readonly code: string;
     readonly message: string;
     readonly params: Record<string, string | number>;
 }
-/** A subscription a retirement reaches, with what it means there. */
-interface RetirementReachedRow {
+/** A subscription a withdrawal reaches, as the operator previews it. */
+interface FeatureWithdrawalReachedRow {
     readonly tenantId: string;
     readonly subscriptionId: string;
     readonly status: string;
-    /** The rhythm it is billed in when the retirement takes effect. */
-    readonly billingCycle: string;
-    /** ISO 8601. */
-    readonly effectiveAt: string;
-    /** ISO date, UTC. */
-    readonly lastDayToCancel: string;
-    /** Reached by another retirement within the last twelve months: the announcement waits. */
-    readonly reachedRecently: boolean;
-}
-/** A subscription on the version a retirement does not reach, and why. */
-interface RetirementSkippedRow {
+    /** Each line with its price per period in its rhythm, net, or null where none is known. */
+    readonly lines: readonly (FeatureWithdrawalLine & {
+        readonly priceNet: number | null;
+    })[];
+    /** Whether it holds the feature through special terms its contract records, and through no line. */
+    readonly specialTerms: boolean;
+}
+/** A subscription holding the feature that the withdrawal does not reach: it ends by the date. */
+interface FeatureWithdrawalSkippedRow {
     readonly tenantId: string;
     readonly subscriptionId: string;
-    readonly reason: RetirementSkipReason;
+    readonly reason: 'ends-before';
 }
-/** What announcing a retirement now would do. */
-interface RetirementPreview {
-    readonly retired: RetirementSide;
-    readonly replacement: RetirementSide;
-    /** Every difference, retired to replacement, as the subscribers will be told it. */
-    readonly changes: readonly VersionChange[];
+/**
+ * A plan or an add-on in a rhythm the withdrawal reaches, which the operator
+ * may name a reduction for: how many lines it reaches and the lowest price
+ * among them, which a reduction may not exceed.
+ */
+interface FeatureWithdrawalTarget {
+    readonly kind: FeatureWithdrawalLineKind;
+    readonly key: string;
+    readonly label: string;
+    readonly billingCycle: BillingCycle;
+    readonly lines: number;
+    readonly lowestPriceNet: number | null;
+}
+/** What announcing a withdrawal now would do. */
+interface FeatureWithdrawalPreview {
+    readonly feature: {
+        readonly key: string;
+        readonly label: string;
+    };
+    /** ISO 8601: the date it would take effect. */
+    readonly effectiveFrom: string;
     /** ISO 8601: the moment it is computed for. */
     readonly asOf: string;
-    readonly reached: readonly RetirementReachedRow[];
-    readonly skipped: readonly RetirementSkippedRow[];
+    readonly reached: readonly FeatureWithdrawalReachedRow[];
+    readonly skipped: readonly FeatureWithdrawalSkippedRow[];
+    readonly targets: readonly FeatureWithdrawalTarget[];
     /** Empty where it may be announced as it stands. */
-    readonly blockers: readonly RetirementBlocker[];
+    readonly blockers: readonly FeatureWithdrawalBlocker[];
+}
+/** A withdrawal as the administration reads it: the record, its dates as ISO 8601. */
+interface FeatureWithdrawalRow {
+    readonly id: string;
+    readonly featureKey: string;
+    readonly reason: string;
+    readonly effectiveFrom: string;
+    readonly liftedFrom: string | null;
+    readonly reductions: readonly FeatureWithdrawalReduction[];
+    readonly announcedAt: string;
+    readonly announcedBy: string;
+    readonly liftedAt: string | null;
+    readonly liftedBy: string | null;
+    /** When the subscriptions it reaches were told; null until then. */
+    readonly toldAt: string | null;
 }
+/** The row the administration reads for `record`. */
+declare function featureWithdrawalRowOf(record: FeatureWithdrawalRecord): FeatureWithdrawalRow;
 /** What an announcement did. */
-interface RetirementAnnounced {
-    readonly retirement: VersionRetirementRecord;
+interface FeatureWithdrawalAnnounced {
+    readonly withdrawal: FeatureWithdrawalRow;
     /** Notices sent now; the rest are sent by the next run. */
     readonly told: number;
     readonly failed: number;
 }
-/**
- * How far a retirement has come, counted over the subscriptions it reached
- * (`SC-SUB-033`).
- */
-interface RetirementProgress {
-    /** Off the retired version: moved at their date, switched early, or changed on their own. */
-    readonly moved: number;
-    /** Still on the retired version, before their date. */
-    readonly waiting: number;
-    /** Still on the retired version after their date: the run has not moved them yet, or cannot. */
-    readonly overdue: number;
-    /** Still on the retired version, and ended by their date: there is nothing to move. */
-    readonly ended: number;
+/** What lifting a withdrawal did. */
+interface FeatureWithdrawalLifted {
+    readonly withdrawal: FeatureWithdrawalRow;
+    readonly told: number;
+    readonly failed: number;
+}
+/** A withdrawal as the administration lists it, with how far it has come. */
+interface FeatureWithdrawalView extends FeatureWithdrawalRow {
+    readonly featureLabel: string;
+    readonly progress: {
+        /** The subscriptions it reached. */
+        readonly reached: number;
+        /** Of those, the ones whose notice reached somebody. */
+        readonly told: number;
+        /** The subscriptions and bookings that ended at once under it. */
+        readonly endedAtOnce: number;
+    };
+}
+/** A line of the tenant's subscription a withdrawal reached, as the tenant sees it now. */
+interface TenantFeatureWithdrawalLine extends FeatureWithdrawalNoticeLine {
     /**
-     * Still on the retired version, and not told yet: their notice has reached
-     * nobody, so their date is not set and nothing moves them (`SC-SUB-036`).
+     * Whether the reduction still applies: the line runs as it was reached.
+     * A change of plan or rhythm the subscriber made ends it.
      */
-    readonly notTold: number;
+    readonly reduced: boolean;
     /**
-     * Reminded 14 days before their date (`SC-SUB-034`) — counted beside the
-     * four above, not instead of one: a subscription reminded moves later.
+     * Where a change scheduled before the announcement brings the line and has
+     * not landed yet: when it lands, ISO 8601, from which the reduction
+     * applies. Null otherwise.
      */
-    readonly reminded: number;
-}
-/** An announcement as the administration lists it, with how far it has come. */
-interface VersionRetirementView extends VersionRetirementRecord {
-    readonly progress: RetirementProgress;
+    readonly fromChange: string | null;
 }
-/** What one run of the moves at the date did. */
-interface RetirementMoveRun {
-    /** Subscriptions moved onto their replacement, with the contract the move writes. */
-    readonly moved: number;
-    /** Moves that could not be made, and are tried again by the next run. */
-    readonly failed: number;
+/** A withdrawal reaching the tenant's subscription, beside its plan and its add-ons. */
+interface TenantFeatureWithdrawal {
+    readonly withdrawalId: string;
+    readonly featureKey: string;
+    readonly featureLabel: string;
+    readonly reason: string;
+    /** ISO 8601. */
+    readonly effectiveFrom: string;
+    /** ISO 8601, once the operator has lifted it. */
+    readonly liftedFrom: string | null;
+    /** Whether it takes the feature away now. */
+    readonly inEffect: boolean;
+    readonly lines: readonly TenantFeatureWithdrawalLine[];
+    readonly specialTerms: boolean;
+    /** What may be ended at once now: the subscription, and which bookings. */
+    readonly endable: {
+        readonly subscription: boolean;
+        readonly subscriptionBundleIds: readonly string[];
+    };
 }
-/** What switching to the replacement before the date did (`SC-SUB-032`). */
-interface RetirementSwitchResult {
-    readonly fromPlanVersionId: string;
-    readonly planVersionId: string;
-    /** ISO date of the last day the price is held, or null where none is. */
-    readonly heldUntilDay: string | null;
+/**
+ * The features `withdrawals` take away at `now` or from a date ahead, and not
+ * lifted by then, the earliest first: what a catalogue marks beside every plan
+ * and add-on that grants them. A withdrawal lifted before its own date takes
+ * nothing away. One feature can appear twice — withdrawn until a date, and
+ * again from it.
+ */
+declare function withdrawnFeaturesOf(withdrawals: readonly FeatureWithdrawalRecord[], now: Date): WithdrawnFeature[];
+/**
+ * A feature withdrawn now or from a date ahead, as a catalogue marks it beside
+ * every plan and add-on that grants it, so whoever concludes is shown it first.
+ */
+interface WithdrawnFeature extends FeatureWithdrawalMark {
+    readonly featureKey: string;
+}
+/** What ending at once now would credit, before the subscriber confirms it. */
+interface EndAtOncePreview {
+    /** ISO 8601: the moment it ends. */
+    readonly endsAt: string;
+    /** The unused rest of what was charged, net, as a positive amount; 0 where nothing was charged. */
+    readonly creditNet: number;
+    /** ISO 4217, where anything is credited. */
+    readonly currency: string | null;
 }
+/** What ending at once did. */
+interface EndedAtOnce extends EndAtOncePreview {
+    readonly withdrawalId: string;
+    /** The booking that ended; null where the subscription did. */
+    readonly subscriptionBundleId: string | null;
+}
+/**
+ * The subject an end at once is recorded under: the subscription or the
+ * booking, and the moment the attempt names, so a later attempt records its
+ * own moment rather than inheriting one whose end never happened.
+ */
+declare function endedAtOnceSubjectOf(subscriptionOrBookingId: string, at: Date): string;
 
 /** What a notice is about. */
-type SubscriptionNoticeKind = 'version-offered' | 'version-retired' | 'version-retirement-reminder';
+type SubscriptionNoticeKind = 'version-offered' | 'version-retired' | 'version-retirement-reminder' | 'bundle-version-retired' | 'bundle-version-retirement-reminder' | 'bundle-version-offered' | 'feature-withdrawn' | 'feature-withdrawal-lifted' | 'ended-at-once';
 /** Which notice: there is one per subscription, kind and subject. */
 interface SubscriptionNoticeKey {
     readonly tenantId: string;
@@ -2953,7 +3597,16 @@ interface SubscriptionNoticeKey {
      * is told of a version's retirement once, whichever announcement it came
      * with. The announcement is in the notice as `retirementId`. For
      * `version-retirement-reminder`, the id of the version retired as well: a
-     * subscription is reminded of a version's retirement once.
+     * subscription is reminded of a version's retirement once. For
+     * `bundle-version-retired`, the id of the add-on version retired: a
+     * subscription holds one booking of an add-on, so that booking is told of
+     * the retirement once. For `bundle-version-retirement-reminder`, the id of
+     * the add-on version retired as well: that booking is reminded of it once.
+     * For `bundle-version-offered`, the id of the add-on version offered: that
+     * booking is told of the version once. For `feature-withdrawn` and
+     * `feature-withdrawal-lifted`, the id of the withdrawal: a subscription is
+     * told of each once. For `ended-at-once`, the id of what ended — the
+     * subscription, or the booking — which ends once.
      */
     readonly subject: string;
 }
@@ -2992,8 +3645,21 @@ interface VersionOfferedNotice {
     /** The offer as `GET billing/version-offer` answers it at the moment the notice is due. */
     readonly offer: VersionOfferView;
 }
+/**
+ * A newer version of an add-on a booking is on is now offered to it. Sent once
+ * per booking and version, when the offer appears beside the add-on — the
+ * notice and the offer say the same thing.
+ */
+interface BundleVersionOfferedNotice {
+    readonly kind: 'bundle-version-offered';
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly subscriptionBundleId: string;
+    /** The offer as the list of the tenant's bookings shows it at the moment the notice is due. */
+    readonly offer: BundleVersionOfferView;
+}
 /** A notice handed to the application to send. */
-type SubscriptionNotice = VersionOfferedNotice | VersionRetiredNotice | VersionRetirementReminder;
+type SubscriptionNotice = VersionOfferedNotice | VersionRetiredNotice | VersionRetirementReminder | BundleVersionRetiredNotice | BundleVersionRetirementReminder | BundleVersionOfferedNotice | FeatureWithdrawnNotice | FeatureWithdrawalLiftedNotice | EndedAtOnceNotice;
 
 /**
  * A `subscription_notices` row as either adapter reads it back. The two JSON
@@ -3077,6 +3743,46 @@ interface CanonicalVersionRetirementRow {
 /** Reads a row back as a record, naming each column rather than spreading the row. */
 declare function toVersionRetirementRecord(row: CanonicalVersionRetirementRow): VersionRetirementRecord;
 
+/** A `bundle_version_retirements` row as either adapter reads it back. */
+interface CanonicalBundleVersionRetirementRow {
+    id: string;
+    retiredBundleVersionId: string;
+    retiredBundleKey: string;
+    retiredVersion: number;
+    replacementBundleVersionId: string;
+    replacementBundleKey: string;
+    replacementVersion: number;
+    announcedAt: Date;
+    announcedBy: string;
+}
+/** Reads a row back as a record, naming each column rather than spreading the row. */
+declare function toBundleVersionRetirementRecord(row: CanonicalBundleVersionRetirementRow): BundleVersionRetirementRecord;
+
+/**
+ * A `feature_withdrawals` row as either adapter reads it back. `reductions` is
+ * `unknown`: the database holds whatever was written to the column.
+ */
+interface CanonicalFeatureWithdrawalRow {
+    id: string;
+    featureKey: string;
+    reason: string;
+    effectiveFrom: Date;
+    liftedFrom: Date | null;
+    reductions: unknown;
+    announcedAt: Date;
+    announcedBy: string;
+    liftedAt: Date | null;
+    liftedBy: string | null;
+    toldAt: Date | null;
+}
+/**
+ * Reads a row back as a record, naming each column rather than spreading the
+ * row. The reductions are checked rather than cast: they are what every
+ * subscription the withdrawal reached is charged less by, and a value nobody
+ * can read must stop at the read and name its row.
+ */
+declare function toFeatureWithdrawalRecord(row: CanonicalFeatureWithdrawalRow): FeatureWithdrawalRecord;
+
 /** A scheduled change as a subscription row holds it. */
 interface ScheduledChangeColumns {
     readonly pendingPlan: string | null;
@@ -3119,9 +3825,15 @@ declare function retirementReminderIsDue(notice: Pick<VersionRetiredNotice, 'eff
  * Whether staying put costs the subscription something when the retirement
  * takes effect (D9): the replacement takes a feature or a quota away, or is
  * dearer in `billingCycle`, the rhythm it is billed in then — or not sold in
- * it. A price that rises only in another rhythm costs it nothing.
+ * it. A price that rises only in another rhythm costs it nothing. A plan
+ * version's retirement and an add-on version's are judged alike.
  */
-declare function retirementCostsTheSubscription(notice: Pick<VersionRetiredNotice, 'retired' | 'replacement' | 'changes' | 'lastDayToCancel'>, billingCycle: string): boolean;
+declare function retirementCostsTheSubscription(notice: {
+    readonly retired: RetirementPricedSide;
+    readonly replacement: RetirementPricedSide;
+    readonly changes: readonly VersionChange[];
+    readonly lastDayToCancel: string;
+}, billingCycle: string): boolean;
 
 /** A `maintenance_windows` row as either adapter reads it back. */
 type CanonicalMaintenanceWindowRow = MaintenanceWindowRecord;
@@ -3159,6 +3871,28 @@ declare function maintenanceRetryAfterSeconds(window: MaintenanceWindowRecord, n
  */
 declare function parseZonedInstant(text: string): Date | null;
 
+/** A calendar day, `YYYY-MM-DD`. */
+type CalendarDay = string;
+/**
+ * The day `at` falls on in `timeZone`. Throws a `RangeError` for a zone the
+ * runtime does not know, and for no zone at all — without one `Intl` would
+ * read the host's, and the day would depend on the machine.
+ */
+declare function dayInZone(at: Date, timeZone: string): CalendarDay;
+/**
+ * The last day a period covers in `timeZone`. A period ends before `until`, so
+ * its last moment is one millisecond earlier: a month from 1 October to
+ * 1 November covers 31 October as its last day.
+ */
+declare function lastDayInZone(period: {
+    from: Date;
+    until: Date;
+}, timeZone: string): CalendarDay;
+/** The day `days` calendar days after `day`; months and years roll over as the calendar does. */
+declare function addDaysToDay(day: CalendarDay, days: number): CalendarDay;
+/** The year a day belongs to. */
+declare function yearOfDay(day: CalendarDay): number;
+
 /**
  * The top-level blocks of `config/saas.yaml` that are the catalogue rather than
  * the configuration, and the format marker.
@@ -3932,27 +4666,559 @@ interface PromoCodeValidationLogRepository {
  * The consumer implementation decides what "first time" means. Important:
  * unfinished onboarding drafts must not count as an existing customer.
  */
-interface FirstTimeCustomerCheck {
-    /** Returns true if a completed/historical customer already exists for the email. */
-    hasExistingCustomerForEmail(email: string): Promise<boolean>;
+interface FirstTimeCustomerCheck {
+    /** Returns true if a completed/historical customer already exists for the email. */
+    hasExistingCustomerForEmail(email: string): Promise<boolean>;
+}
+/** Subscription lookup for `redeem()`. Sufficient for promo calculations. */
+interface PromoSubscriptionLookup {
+    findById(subscriptionId: string, tx?: TransactionContext): Promise<{
+        id: string;
+        tenantId: string;
+        plan: string;
+        billingCycle: BillingCycle;
+        startedAt: Date | null;
+    } | null>;
+}
+/**
+ * Aggregation adapter for the stats endpoint (`PromoCodesService.stats`).
+ * Consumers without an `InvoiceDiscount` table return '0.00'.
+ */
+interface PromoRevenueDeductionAggregator {
+    /** Sum of the amountGross values for all redemptions of a promo code (Decimal-as-string). */
+    sumGrossForPromoCode(promoCodeId: string): Promise<string>;
+}
+
+/**
+ * What made the charge arise. activation: the first period of a subscription. renewal: a later period. planChange: what an immediate plan change adds. bundleBooking: the first, short period of an add-on. bundleChange: what an add-on's switch to a dearer version adds for the rest of its period. credit: a decision that reduces what is owed. correction: a counter-entry reversing an earlier charge, which is how the append-only journal answers a mistake. reductionTakenBack: a reduction granted in advance, taken back for the days it no longer covers — the feature it was granted for came back, or what it reduced ended at once.
+ */
+type SubscriberChargeOrigin = 'activation' | 'renewal' | 'planChange' | 'bundleBooking' | 'bundleChange' | 'credit' | 'correction' | 'reductionTakenBack';
+/**
+ * Which kind of contract line the charge realises.
+ */
+type SubscriberChargeSource = 'plan' | 'bundle' | 'discount';
+/**
+ * One charge in a subscriber's account: an amount that became due for a period, derived from a line of the contract in force. The journal is append-only — a charge is never updated, and a mistake is answered with a counter-entry rather than an edit, so the account says what happened rather than what somebody thinks today. A charge is net: the tax is decided by the tax adapter when the charge is invoiced, from the subscriber's origin on that day, and computed once per rate on the invoice.
+ */
+interface SubscriberCharge {
+    /**
+     * The charge's own identifier. Never shown to a customer as an invoice number: invoice numbering is sequential, gapless and legally constrained per country, and an identifier somebody has already seen on a screen cannot become one later without confusion.
+     */
+    id: string;
+    /**
+     * The party the contract is concluded with, whose account this is. It outlives the tenant.
+     */
+    subscriberId: string;
+    /**
+     * The tenant the subscription belonged to when the charge arose.
+     */
+    tenantId: string;
+    /**
+     * The subscription the charge arose on. Part of the natural key.
+     */
+    subscriptionId: string;
+    /**
+     * The contract whose line the charge realises.
+     */
+    contractId: string;
+    /**
+     * The contract line the charge came from, so that every invoice line can be traced back to what was agreed.
+     */
+    contractLineItemId: string;
+    origin: SubscriberChargeOrigin;
+    source: SubscriberChargeSource;
+    /**
+     * Which thing of its source the charge is for, stable across contracts: the subscription id for the plan, the booking id for an add-on, the discount's key for a discount. Part of the natural key (subscriptionId, source, sourceRef, periodStart, origin), which is unique — a charge derived twice is written once.
+     */
+    sourceRef: string;
+    /**
+     * The start of the period the charge belongs to — the grouping key for an invoice.
+     */
+    periodStart: string;
+    periodEnd: string;
+    /**
+     * ISO 4217, as the contract line records it — recorded per charge so that a charge written in 2026 still means what it meant after the configured currency changes.
+     */
+    currency: string;
+    /**
+     * Net, rounded to the currency's decimal places once, when the charge is written; the written figure is the truth from then on. Negative for a discount.
+     */
+    amountNet: number;
+    /**
+     * When the amount became due. The account is ordered by this, not by when the row was written.
+     */
+    bookedAt: string;
+    createdAt: string;
+}
+
+/** A charge as a store reads it back: the wire format, with its dates as dates. */
+interface SubscriberChargeRecord {
+    id: string;
+    subscriberId: string;
+    tenantId: string;
+    subscriptionId: string;
+    contractId: string;
+    contractLineItemId: string;
+    origin: SubscriberChargeOrigin;
+    source: SubscriberChargeSource;
+    /** The subscription id for the plan, the booking id for an add-on, the discount's key. */
+    sourceRef: string;
+    periodStart: Date;
+    periodEnd: Date;
+    currency: string;
+    /** Net, rounded to the cent when written. Negative for a discount. */
+    amountNet: number;
+    /** When the amount became due. */
+    bookedAt: Date;
+    createdAt: Date;
+}
+/** A charge to write: everything but what the store assigns. */
+type NewSubscriberCharge = Omit<SubscriberChargeRecord, 'id' | 'createdAt'>;
+/**
+ * The manifest capability that announces the operator's view of an account.
+ * The platform sets it where it serves the view, and the admin UI shows the
+ * view only where it is set.
+ */
+declare const SUBSCRIBER_ACCOUNT_CAPABILITY = "charges.read";
+/** Whose account it is, as the operator is shown it. */
+interface AdminAccountHolder {
+    id: string;
+    /** What the customer quotes, and what an invoice will carry. */
+    customerNumber: string;
+    legalName: string;
+}
+/** One charge of an account, with the name its contract line gives it. */
+interface AdminAccountEntry {
+    /** The charge as the journal holds it. */
+    charge: SubscriberCharge;
+    /**
+     * The contract line's own title, as it was when the contract was
+     * concluded, or `null` where that line cannot be read.
+     */
+    title: string | null;
+}
+/**
+ * A tenant's account as the operator reads it: the charges of the subscription
+ * it holds, newest first — by when each became due, then by its period, then
+ * the plan before its add-ons before its discounts.
+ *
+ * No total: without invoices and payments, a sum would be what was charged so
+ * far, and it would be read as what is owed.
+ */
+interface AdminSubscriberAccount {
+    /** `null` for a tenant that has no subscriber. */
+    holder: AdminAccountHolder | null;
+    entries: AdminAccountEntry[];
+}
+
+/** The issuer an invoice names, as of its issue date. */
+interface SubscriptionInvoiceIssuer extends LegalIdentity, PartyAddress {
+}
+/** The subscriber an invoice names, copied from its record on the issue date. */
+interface SubscriptionInvoiceSubscriber extends LegalIdentity, PartyAddress {
+    customerNumber: string;
+}
+/** One line of an invoice: one charge, as the invoice states it. */
+interface SubscriptionInvoiceLineRecord {
+    id: string;
+    invoiceId: string;
+    /** From 1, in the order the invoice lists its lines. */
+    position: number;
+    /** The charge the line invoices; a charge stands on one invoice (`SC-PRIC-022`). */
+    chargeId: string;
+    /** The contract line the charge came from (`SC-AUD-013`). */
+    contractLineItemId: string;
+    /** What the line is for, as the contract line names it. */
+    title: string;
+    origin: SubscriberChargeOrigin;
+    source: SubscriberChargeSource;
+    /** The first day the charge covers, in the installation's time zone. */
+    periodFrom: CalendarDay;
+    /** The last day the charge covers, in the installation's time zone. */
+    periodUntil: CalendarDay;
+    /** Net, as the charge was written. Negative for a discount. */
+    amountNet: number;
+    /** In per cent: the rate of the invoice's treatment. */
+    taxRate: number;
+}
+/** A line to write: everything but what the store assigns. */
+type NewSubscriptionInvoiceLine = Omit<SubscriptionInvoiceLineRecord, 'id' | 'invoiceId'>;
+/** An invoice as a store reads it back. */
+interface SubscriptionInvoiceRecord {
+    id: string;
+    /** `<prefix>-<year>-<sequence>`, e.g. `AHP-2026-000123` (`formatInvoiceNumber`). */
+    number: string;
+    numberPrefix: string;
+    /** The year of the issue date, which the sequence restarts with. */
+    numberYear: number;
+    /** From 1 each year, without gaps. */
+    numberSequence: number;
+    tenantId: string;
+    subscriberId: string;
+    subscriptionId: string;
+    /** The contract the invoiced charges belong to. */
+    contractId: string;
+    issuedAt: Date;
+    /** The day it was issued, in the installation's time zone. */
+    issueDate: CalendarDay;
+    /** The day it is due: the issue date plus the payment term (`SC-PRIC-046`). */
+    dueDate: CalendarDay;
+    /** The first day its charges cover. */
+    servicePeriodFrom: CalendarDay;
+    /** The last day its charges cover. */
+    servicePeriodUntil: CalendarDay;
+    currency: string;
+    issuer: SubscriptionInvoiceIssuer;
+    subscriber: SubscriptionInvoiceSubscriber;
+    /**
+     * The lines `config/saas.yaml` named under `invoicing.footer` on the issue
+     * date — what a business letter of the issuer states beyond the invoice's
+     * own content (`SC-PRIC-077`); none where it named none.
+     */
+    footer: string[];
+    /** The treatment the tax adapter decided when it was issued, with its name and version. */
+    taxTreatment: TaxTreatment;
+    /** The tax, rate by rate, computed once per rate (`SC-PRIC-041`). */
+    taxes: TaxAtRate[];
+    totalNet: number;
+    totalTax: number;
+    totalGross: number;
+    lines: SubscriptionInvoiceLineRecord[];
+    createdAt: Date;
+}
+/**
+ * An invoice to issue: everything but what the store assigns — the id, and
+ * the number, which the store draws when it writes the invoice.
+ */
+interface NewSubscriptionInvoice extends Omit<SubscriptionInvoiceRecord, 'id' | 'number' | 'numberSequence' | 'lines' | 'createdAt'> {
+    lines: NewSubscriptionInvoiceLine[];
+}
+/** How many digits an invoice number's sequence is written with, at least. */
+declare const INVOICE_SEQUENCE_DIGITS = 6;
+/**
+ * The number an invoice carries: the prefix `config/saas.yaml` names, the year
+ * the sequence counts in, and the sequence written with at least six digits —
+ * `formatInvoiceNumber('AHP', 2026, 123)` is `AHP-2026-000123`.
+ */
+declare function formatInvoiceNumber(prefix: string, year: number, sequence: number): string;
+
+/**
+ * The manifest capability that announces the operator's download of an
+ * invoice's archived document. The platform sets it where it serves the route.
+ */
+declare const INVOICE_DOCUMENT_CAPABILITY = "invoices.read";
+/** A rendered invoice: its bytes, as a file. */
+interface InvoiceDocument {
+    content: Uint8Array;
+    /** `application/pdf` for a ZUGFeRD invoice. */
+    mediaType: string;
+    /** What a person saving it would call it, such as `AHP-2026-000123.pdf`. */
+    fileName: string;
+}
+/**
+ * Renders an invoice into the file the tax adapter's law requires — the
+ * application's own renderer, or the default one SaaSiCat ships.
+ *
+ * Given the invoice as it was issued, it renders the same bytes every time, so
+ * a repeated attempt archives the file whose checksum was recorded. Whatever
+ * it would take from the clock, such as a PDF's creation date, it takes from
+ * the invoice's `issuedAt`. A renderer updated between two attempts renders
+ * other bytes; while nothing is archived, those take the place of the ones
+ * recorded, and the audit log says so (`SC-AUD-019`).
+ */
+interface InvoiceRenderer {
+    render(invoice: SubscriptionInvoiceRecord): Promise<InvoiceDocument>;
+}
+/** A document to archive: the file, under its invoice, with the checksum recorded for it. */
+interface InvoiceDocumentToArchive extends InvoiceDocument {
+    invoiceId: string;
+    /** SHA-256 of `content`, lower-case hex. */
+    checksum: string;
+    archivedAt: Date;
+}
+/** A document as the archive hands it back. */
+type ArchivedInvoiceDocument = InvoiceDocumentToArchive;
+/**
+ * Keeps each invoice's document, unalterable, for as long as the law asks —
+ * in Germany 8 years from the end of the calendar year it was issued in, in
+ * the European Union. The shipped adapters keep it in the database
+ * (`SubscriptionInvoiceArchive`, which refuses every update and delete);
+ * object storage with a retention lock is another way to implement it.
+ */
+interface InvoiceArchivePort {
+    /**
+     * Stores the document under its invoice. Storing it again with the same
+     * checksum is the same write and changes nothing; another checksum for an
+     * invoice already archived is refused with
+     * `SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED`, and the first stays.
+     */
+    store(document: InvoiceDocumentToArchive): Promise<void>;
+    /** The document archived under the invoice, or `null` where none is. */
+    read(invoiceId: string): Promise<ArchivedInvoiceDocument | null>;
+    /**
+     * Why the archive would let a document it keeps be changed or removed, or
+     * `null` where it would not. Asked when invoices start, which are refused
+     * while it names a reason: an archive that is not unalterable keeps no
+     * document as the law asks, and would only be found out at an audit.
+     */
+    protectionProblem(): Promise<string | null>;
+}
+/** An invoice on its way to the subscriber. */
+interface InvoiceMail {
+    invoice: SubscriptionInvoiceRecord;
+    /** The invoice email on the subscriber's record. */
+    to: string;
+    /** The archived file, to attach. */
+    document: InvoiceDocument;
+}
+/**
+ * Sends an invoice to the subscriber with its file attached (`SC-PRIC-047`).
+ *
+ * The application words the message — in the subscriber's language, with a
+ * link to the tenant's sign-in rather than to the file itself — and sends it
+ * with its own mail infrastructure. It rejects where the message could not be
+ * handed on; the platform then shows the failure to the operator, with the
+ * rejection's message as the reason and the recipient's address taken out of
+ * it, and tries again on the next run. The invoice stays issued either way: delivery is not
+ * what makes it an invoice.
+ *
+ * A run claims the invoice before it calls this, so of several instances one
+ * sends it. One that does not answer within a minute holds the invoice for
+ * its answer: a late success is recorded, a late failure tried again.
+ */
+interface InvoiceMailPort {
+    deliver(mail: InvoiceMail): Promise<void>;
+}
+/** Where an invoice's document stands, as the invoice records it. */
+interface SubscriptionInvoiceDocumentRecord {
+    invoiceId: string;
+    /** SHA-256 of the rendered file, lower-case hex, recorded before it is archived. */
+    checksum: string;
+    mediaType: string;
+    fileName: string;
+    /** In bytes. */
+    size: number;
+    renderedAt: Date;
+    /** When the archive confirmed it; `null` while the invoice waits for its document. */
+    archivedAt: Date | null;
+    /**
+     * When the run that is mailing it took it on; `null` while no run holds it.
+     * A claim older than the lease is taken on by the next run.
+     */
+    deliveryClaimedAt: Date | null;
+    /** When it was handed to the mail; `null` until then. */
+    deliveredAt: Date | null;
+    /** The address it was sent to. */
+    deliveredTo: string | null;
+}
+/** What is recorded of a rendering before its file is archived. */
+type NewInvoiceRendering = Pick<SubscriptionInvoiceDocumentRecord, 'checksum' | 'mediaType' | 'fileName' | 'size' | 'renderedAt'>;
+
+/** The adapter that gave an answer, recorded beside the answer. */
+interface TaxAdapterIdentity {
+    /** The adapter's package name, such as `@saasicat/tax-de`. */
+    name: string;
+    /** The adapter's version as published, such as `1.0.0`. */
+    version: string;
+}
+/** The kinds of tax treatment every adapter shares, in the order they are named. */
+declare const TAX_TREATMENT_KINDS: readonly ["standard", "reduced", "exempt", "reverse-charge", "not-taxable", "small-business"];
+/**
+ * What a tax treatment is, in the words every adapter shares.
+ *
+ * - `standard` and `reduced`: the issuer's country taxes the charge at a rate.
+ * - `exempt`: the charge is exempt in the issuer's country.
+ * - `reverse-charge`: the subscriber, a business in another country, owes the
+ *   tax instead of the issuer.
+ * - `not-taxable`: the charge is not taxable in the issuer's country at all,
+ *   such as a service to a business outside the European Union.
+ * - `small-business`: the issuer charges no tax under a small business scheme.
+ */
+type TaxTreatmentKind = (typeof TAX_TREATMENT_KINDS)[number];
+/** The treatment an adapter decided, as a contract and an invoice record it. */
+interface TaxTreatment {
+    kind: TaxTreatmentKind;
+    /** The rate in percent, such as `19`; `0` for every kind that charges no tax. */
+    rate: number;
+    /**
+     * The sentence the document has to carry for this treatment, such as the
+     * reference to the reverse charge; `null` where the law asks for none.
+     */
+    note: string | null;
+    /** Who decided it. */
+    adapter: TaxAdapterIdentity;
+}
+/**
+ * Where a subscriber stands for tax purposes, as its record stands: what an
+ * adapter decides a treatment from.
+ */
+interface SubscriberTaxOrigin {
+    /** The country of the billing address, ISO 3166-1 alpha-2; `null` while unknown. */
+    country: string | null;
+    /**
+     * Whether the subscriber is a business, as sign-up or the operator recorded
+     * it; `null` while nobody has said. Never derived from a tax identifier: a
+     * business outside the European Union may have none.
+     */
+    business: boolean | null;
+    /** The VAT identification number as entered, validated or not. */
+    vatId: string | null;
+    /**
+     * The same number, only when its latest completed check found it valid;
+     * otherwise `null`. An adapter decides as though a subscriber whose number
+     * is not validated had none (`SC-PRIC-040`).
+     */
+    validatedVatId: string | null;
+}
+/** The issuer as an adapter needs it: the operator, as `config/saas.yaml` names it. */
+interface TaxIssuer {
+    /** ISO 3166-1 alpha-2; `null` where the configuration names none. */
+    country: string | null;
+    vatId: string | null;
+}
+/** What an adapter decides a treatment for. */
+interface TaxDecisionRequest {
+    issuer: TaxIssuer;
+    origin: SubscriberTaxOrigin;
+    /**
+     * The period the charge covers, as a charge records it: from `from` up to
+     * `until`, which is the first moment after it. A rate that changed in
+     * between is the adapter's to see.
+     */
+    period: {
+        from: Date;
+        until: Date;
+    };
+    /**
+     * The installation's time zone, an IANA name such as `Europe/Berlin`: the
+     * calendar in which the days of the period count (`SC-PRIC-045`).
+     */
+    timeZone: string;
+}
+/**
+ * An adapter's answer: a treatment, or a sentence saying the case is not
+ * supported. An unsupported case is refused before a contract exists rather
+ * than invoiced with a guessed tax (`SC-PRIC-039`).
+ */
+type TaxDecision = {
+    supported: true;
+    treatment: TaxTreatment;
+} | {
+    supported: false;
+    reason: string;
+};
+/**
+ * A completed check of a VAT identification number, with its date and what
+ * the service returned (`SC-PRIC-040`). Every check is recorded for the
+ * subscriber and never rewritten: a reverse charge rests on the confirmation
+ * that held when the invoice was issued, and neither a later check nor a
+ * corrected number may take it away.
+ */
+interface VatIdCheck {
+    /** The number checked, exactly as it was stored when the check ran. */
+    vatId: string;
+    /**
+     * When the service's answer was received, by the platform's clock, to the
+     * millisecond. `keepsVatIdCheck` makes the check with the latest one count,
+     * so a date of day precision — such as the request date VIES returns —
+     * would make two checks of one day tie, and a date in the future would hold
+     * back every check after it. Such a date belongs in `confirmation`.
+     */
+    checkedAt: Date;
+    /** Whether the service confirmed the number as valid. */
+    valid: boolean;
+    /** The service that answered, such as `VIES`. */
+    service: string;
+    /**
+     * What the service returned as its confirmation — a request identifier, the
+     * name and address it holds for the number — as text, as the service sent it.
+     */
+    confirmation: Record<string, string>;
+}
+/**
+ * How a check ended. A check that could not complete, such as while the
+ * service is unavailable, is not a result: it leaves the number unvalidated
+ * and is never read as valid.
+ */
+type VatIdCheckOutcome = {
+    completed: true;
+    check: VatIdCheck;
+} | {
+    completed: false;
+    reason: string;
+};
+/**
+ * How an application binds a tax adapter, the way it binds a payment gateway:
+ * the adapter's name, which `config/saas.yaml#tax.adapter` names, and how to
+ * build it from the options the file gives it. The options come from the file,
+ * so the factory checks them and throws for one the adapter cannot take.
+ */
+interface TaxAdapterFactory {
+    /** The adapter's package name, such as `@saasicat/tax-de`. */
+    readonly adapterName: string;
+    create(options: Readonly<Record<string, unknown>>): TaxAdapter;
+}
+/**
+ * The tax adapter of an installation: a package for the country of its issuer,
+ * named in `config/saas.yaml`. An adapter is a template, not tax advice; its
+ * documentation says what it decides and on which basis.
+ */
+interface TaxAdapter extends TaxAdapterIdentity {
+    /** The treatment of a charge, or why the case is not supported. Decides only; writes nothing. */
+    decide(request: TaxDecisionRequest): TaxDecision;
+    /**
+     * Checks a VAT identification number with the service the adapter names.
+     * Resolves to an outcome whatever the service does: an error, a timeout and
+     * an answer the adapter cannot read are each a check that did not complete.
+     */
+    checkVatId(vatId: string, issuer: TaxIssuer): Promise<VatIdCheckOutcome>;
+    /**
+     * An invoice's tax by the rule this adapter's law names (`SC-PRIC-041`):
+     * per rate, with the totals the invoice states. The amount it states is
+     * the amount collected and the amount a payment settles.
+     */
+    invoiceTax(lines: readonly InvoiceTaxLine[]): TaxPerRate;
+    /**
+     * What an invoice lacks of the content the law requires of it
+     * (`SC-PRIC-027`), as the fields it misses — `issuer.taxIdentifier`,
+     * `subscriber.postalCode` — or none where it is complete. Asked before the
+     * number is drawn; an invoice that lacks anything is not issued.
+     */
+    invoiceContentGaps(draft: InvoiceContentDraft): readonly string[];
+    /**
+     * What a rendered document lacks of the format the law requires
+     * (`SC-PRIC-042`), or disagrees with in the invoice it was rendered from —
+     * `format.embeddedXml`, `xml.totalGross` — or none where it is the file to
+     * issue. A document with anything here is not archived, sent or offered;
+     * the invoice keeps its number and waits for a document that passes.
+     */
+    invoiceDocumentGaps(document: InvoiceDocument, invoice: SubscriptionInvoiceRecord): Promise<readonly string[]>;
 }
-/** Subscription lookup for `redeem()`. Sufficient for promo calculations. */
-interface PromoSubscriptionLookup {
-    findById(subscriptionId: string, tx?: TransactionContext): Promise<{
-        id: string;
-        tenantId: string;
-        plan: string;
-        billingCycle: BillingCycle;
-        startedAt: Date | null;
-    } | null>;
+/** A line as an invoice's tax is computed from it. */
+interface InvoiceTaxLine {
+    net: number;
+    /** In per cent. */
+    rate: number;
 }
 /**
- * Aggregation adapter for the stats endpoint (`PromoCodesService.stats`).
- * Consumers without an `InvoiceDiscount` table return '0.00'.
+ * What an invoice says, without its number: what the adapter checks against
+ * the content the law requires before the number is drawn.
  */
-interface PromoRevenueDeductionAggregator {
-    /** Sum of the amountGross values for all redemptions of a promo code (Decimal-as-string). */
-    sumGrossForPromoCode(promoCodeId: string): Promise<string>;
+interface InvoiceContentDraft {
+    issuer: LegalIdentity & PartyAddress;
+    subscriber: LegalIdentity & PartyAddress;
+    treatment: TaxTreatment;
+    issueDate: string;
+    dueDate: string;
+    servicePeriod: {
+        from: string;
+        until: string;
+    };
+    lines: readonly {
+        title: string;
+        net: number;
+        rate: number;
+    }[];
 }
 
 type ContractLineItemKind = 'plan' | 'bundle' | 'discount';
@@ -4070,6 +5336,14 @@ interface SubscriptionContractRecord extends SubscriptionContractParties {
      * never presented as what was agreed.
      */
     partiesMigrated: boolean;
+    /**
+     * The tax treatment the installation's tax adapter decided when the
+     * contract was concluded, with the adapter's name and version
+     * (`SC-PRIC-038`). `null` for a contract concluded without an adapter,
+     * before one existed, or by a path that does not ask one yet; each invoice
+     * then takes the adapter's answer when it is issued.
+     */
+    taxTreatment: TaxTreatment | null;
     status: SubscriptionContractStatus;
     effectiveFrom: Date;
     effectiveUntil: Date | null;
@@ -4116,6 +5390,11 @@ interface NewSubscriptionContractData extends CreateSubscriptionContractData {
      * means `false`.
      */
     partiesMigrated?: boolean;
+    /**
+     * The treatment the platform had the tax adapter decide, recorded as it
+     * was answered and never rewritten. Absent means `null`.
+     */
+    taxTreatment?: TaxTreatment | null;
 }
 interface TerminateSubscriptionContractData {
     /**
@@ -4224,16 +5503,115 @@ interface SubscriberContact extends PartyAddress {
     /** Where invoices will be sent. */
     invoiceEmail: string | null;
 }
+/**
+ * Whether the subscriber is a business: part of its tax origin beside the
+ * country and the VAT identification number (ADR 0013).
+ */
+interface SubscriberTaxStatus {
+    /**
+     * As sign-up or the operator recorded it; `null` while nobody has said.
+     * Never derived from a tax identifier: a business outside the European
+     * Union may have none, and is still a business.
+     */
+    business: boolean | null;
+}
+/**
+ * The address an invoice names. Sign-up asks for every one of them, and once
+ * given they can be changed but not cleared: without them nothing can be
+ * invoiced (`SC-PRIC-032`).
+ */
+declare const SUBSCRIBER_INVOICE_ADDRESS_FIELDS: readonly ["addressLine1", "postalCode", "city", "country"];
+type SubscriberInvoiceAddressField = (typeof SUBSCRIBER_INVOICE_ADDRESS_FIELDS)[number];
+/**
+ * Whether a subscriber can be given its next contract where a tax adapter
+ * decides (`SC-PRIC-032`, `SC-PRIC-039`): which fields of the address an
+ * invoice names are empty, and the adapter's sentence where it supports no
+ * treatment for the subscriber as it stands. Computed when it is read, from the
+ * record and the adapter as they are then.
+ */
+interface SubscriberReadiness {
+    ready: boolean;
+    missing: SubscriberInvoiceAddressField[];
+    /** The adapter's sentence, or `null` where it treats the subscriber. */
+    taxRefusal: string | null;
+}
+/**
+ * A tenant's subscriber as the operator sees it beside the tenant: who the
+ * contracts are concluded with, what a tax adapter decides from, and — where
+ * one decides — what holds its next contract back (`SC-PRIC-070`).
+ */
+interface AdminTenantSubscriber {
+    subscriber: {
+        id: string;
+        customerNumber: string;
+        legalName: string;
+        addressLine1: string | null;
+        addressLine2: string | null;
+        postalCode: string | null;
+        city: string | null;
+        country: string | null;
+        business: boolean | null;
+        vatId: string | null;
+        /** Whether the check that counts for the VAT id found it valid. */
+        vatIdValidated: boolean;
+        taxNumber: string | null;
+        /** Created from the application's own tenant record, not from what a customer entered. */
+        migrated: boolean;
+    } | null;
+    /** `null` where no tax adapter decides, or the tenant has no subscriber. */
+    readiness: SubscriberReadiness | null;
+}
+/**
+ * The manifest capability that announces the operator's view of a tenant's
+ * subscriber. The platform sets it where it serves the view.
+ */
+declare const SUBSCRIBER_STANDING_CAPABILITY = "subscribers.read";
+/**
+ * The manifest capability that says a tax adapter decides, so a subscriber can
+ * be held back from its next contract: the operator's lists ask which only
+ * where it is set, and are spared the question everywhere else.
+ */
+declare const SUBSCRIBER_ATTENTION_CAPABILITY = "subscribers.attention";
+/**
+ * How many tenants one question about attention may name: a page of a list,
+ * not the whole of it. A list longer than this asks in pages.
+ */
+declare const SUBSCRIBER_ATTENTION_PAGE_SIZE = 200;
+/**
+ * The manifest capability that announces the operator's corrections of a
+ * subscriber — its legal identity, its business status, a check of its VAT
+ * identification number — beside the subscriber's view.
+ */
+declare const SUBSCRIBER_CORRECTION_CAPABILITY = "subscribers.correct";
+/** A tenant whose subscriber cannot be given its next contract, and why. */
+interface AdminSubscriberAttention {
+    tenantId: string;
+    readiness: SubscriberReadiness;
+}
+/** A live subscriber with the check of its VAT id that counts now. */
+interface SubscriberWithCurrentCheck {
+    subscriber: SubscriberRecord;
+    currentVatIdCheck: SubscriberVatIdCheckRecord | null;
+}
 /** A subscriber's master data, as it stands. */
-type SubscriberDetails = LegalIdentity & SubscriberContact;
+type SubscriberDetails = LegalIdentity & SubscriberContact & SubscriberTaxStatus;
 /**
  * What a subscriber is created with.
  *
- * Only the legal name is required. The address, the tax identifiers and the
- * invoice email stay optional until sign-up asks for them and invoicing
- * requires them; an absent or blank value is recorded as unknown.
+ * Only the legal name is required. The address, the tax identifiers, the
+ * business status and the invoice email stay optional until sign-up asks for
+ * them and invoicing requires them; an absent or blank value is recorded as
+ * unknown.
  */
-type NewSubscriberDetails = Pick<SubscriberDetails, 'legalName'> & Partial<Omit<SubscriberDetails, 'legalName'>>;
+type NewSubscriberDetails = Pick<SubscriberDetails, 'legalName'> & Partial<Omit<SubscriberDetails, 'legalName'>> & {
+    /**
+     * A check of `vatId` made before the subscriber existed — in a
+     * sign-up's step 4, or by `SubscriberService.assessNewSubscriber` —
+     * recorded with it when it is created, so its first contract is
+     * decided from it. A check of another number is refused.
+     */
+    vatIdCheck?: VatIdCheck | null;
+};
 interface SubscriberRecord extends SubscriberDetails {
     id: string;
     /**
@@ -4287,13 +5665,15 @@ interface SubscriberIdentityDelta {
     previous: SubscriberIdentityValues;
     corrected: SubscriberIdentityValues;
 }
-/** What a repository writes for a correction the service has accepted. */
+/**
+ * What a repository writes for a correction the service has accepted. The
+ * repository dates it, while it holds the subscriber's row lock.
+ */
 interface SubscriberCorrectionData {
     /** The new values; a field equal to what is stored is not recorded. */
     corrected: SubscriberIdentityValues;
     reason: string;
     correctedBy: string;
-    correctedAt: Date;
 }
 /** One correction of a subscriber's legal identity, as it was recorded. */
 interface SubscriberCorrectionRecord {
@@ -4305,6 +5685,12 @@ interface SubscriberCorrectionRecord {
     corrected: SubscriberIdentityValues;
     reason: string;
     correctedBy: string;
+    /**
+     * When the write that made it held the subscriber's row lock, by the
+     * platform's clock. The list is in the order the database numbered the
+     * writes; on one clock these dates follow that order, while two instances
+     * whose clocks differ may date neighbouring corrections out of it.
+     */
     correctedAt: Date;
 }
 /** The outcome of writing a correction: nothing is recorded when no value moved. */
@@ -4312,128 +5698,142 @@ interface SubscriberCorrectionResult {
     subscriber: SubscriberRecord;
     correction: SubscriberCorrectionRecord | null;
 }
-
 /**
- * What made the charge arise. activation: the first period of a subscription. renewal: a later period. planChange: what an immediate plan change adds. bundleBooking: the first, short period of an add-on. credit: a decision that reduces what is owed. correction: a counter-entry reversing an earlier charge, which is how the append-only journal answers a mistake.
+ * The details a subscriber's tax origin consists of, and whose change is
+ * recorded with its date — in the order they are named and shown.
  */
-type SubscriberChargeOrigin = 'activation' | 'renewal' | 'planChange' | 'bundleBooking' | 'credit' | 'correction';
-/**
- * Which kind of contract line the charge realises.
- */
-type SubscriberChargeSource = 'plan' | 'bundle' | 'discount';
+declare const SUBSCRIBER_TAX_ORIGIN_FIELDS: readonly ["country", "business", "vatId"];
+type SubscriberTaxOriginField = (typeof SUBSCRIBER_TAX_ORIGIN_FIELDS)[number];
+/** Tax origin values by field, holding only the fields a change moved. */
+type SubscriberTaxOriginValues = Partial<Pick<SubscriberDetails, SubscriberTaxOriginField>>;
 /**
- * One charge in a subscriber's account: an amount that became due for a period, derived from a line of the contract in force. The journal is append-only — a charge is never updated, and a mistake is answered with a counter-entry rather than an edit, so the account says what happened rather than what somebody thinks today. A charge is net: the tax is decided by the tax adapter when the charge is invoiced, from the subscriber's origin on that day, and computed once per rate on the invoice.
+ * One change of a subscriber's tax origin, as it was recorded: written in the
+ * same transaction as the change, whichever way it arrived — a contact change
+ * of the country, a correction of the VAT identification number, a change of
+ * the business status — and never rewritten. A change applies from the
+ * subscriber's next invoice (`SC-PRIC-043`).
  */
-interface SubscriberCharge {
-    /**
-     * The charge's own identifier. Never shown to a customer as an invoice number: invoice numbering is sequential, gapless and legally constrained per country, and an identifier somebody has already seen on a screen cannot become one later without confusion.
-     */
+interface SubscriberTaxOriginChangeRecord {
     id: string;
-    /**
-     * The party the contract is concluded with, whose account this is. It outlives the tenant.
-     */
     subscriberId: string;
+    /** The values the change replaced. */
+    previous: SubscriberTaxOriginValues;
+    /** The values it wrote. */
+    changed: SubscriberTaxOriginValues;
+    /** Who changed it, as an actor tag the audit log would write. */
+    changedBy: string;
     /**
-     * The tenant the subscription belonged to when the charge arose.
-     */
-    tenantId: string;
-    /**
-     * The subscription the charge arose on. Part of the natural key.
-     */
-    subscriptionId: string;
-    /**
-     * The contract whose line the charge realises.
-     */
-    contractId: string;
-    /**
-     * The contract line the charge came from, so that every invoice line can be traced back to what was agreed.
-     */
-    contractLineItemId: string;
-    origin: SubscriberChargeOrigin;
-    source: SubscriberChargeSource;
-    /**
-     * Which thing of its source the charge is for, stable across contracts: the subscription id for the plan, the booking id for an add-on, the discount's key for a discount. Part of the natural key (subscriptionId, source, sourceRef, periodStart, origin), which is unique — a charge derived twice is written once.
-     */
-    sourceRef: string;
-    /**
-     * The start of the period the charge belongs to — the grouping key for an invoice.
-     */
-    periodStart: string;
-    periodEnd: string;
-    /**
-     * ISO 4217, as the contract line records it — recorded per charge so that a charge written in 2026 still means what it meant after the configured currency changes.
-     */
-    currency: string;
-    /**
-     * Net, rounded to the currency's decimal places once, when the charge is written; the written figure is the truth from then on. Negative for a discount.
+     * When the write that made it held the subscriber's row lock, by the
+     * platform's clock. The list is in the order the database numbered the
+     * writes; on one clock these dates follow that order, while two instances
+     * whose clocks differ may date neighbouring changes out of it.
      */
-    amountNet: number;
+    changedAt: Date;
     /**
-     * When the amount became due. The account is ordered by this, not by when the row was written.
+     * Why it was changed: the reason of the correction or of the change of
+     * business status that made it; `null` for a change of the country, which
+     * comes with the contact details and states none.
      */
-    bookedAt: string;
-    createdAt: string;
+    reason: string | null;
 }
-
-/** A charge as a store reads it back: the wire format, with its dates as dates. */
-interface SubscriberChargeRecord {
-    id: string;
-    subscriberId: string;
-    tenantId: string;
-    subscriptionId: string;
-    contractId: string;
-    contractLineItemId: string;
-    origin: SubscriberChargeOrigin;
-    source: SubscriberChargeSource;
-    /** The subscription id for the plan, the booking id for an add-on, the discount's key. */
-    sourceRef: string;
-    periodStart: Date;
-    periodEnd: Date;
-    currency: string;
-    /** Net, rounded to the cent when written. Negative for a discount. */
-    amountNet: number;
-    /** When the amount became due. */
-    bookedAt: Date;
-    createdAt: Date;
+/** What a repository writes for a change of the business status the service has accepted. */
+interface SubscriberBusinessStatusData {
+    business: boolean | null;
+    /** Who changes it, as an actor tag the audit log would write. */
+    changedBy: string;
+    /** Why, in the operator's words: whether it is a business decides the tax treatment. */
+    reason: string;
+}
+/** The outcome of writing a business status: nothing is recorded when it does not move. */
+interface SubscriberBusinessStatusResult {
+    subscriber: SubscriberRecord;
+    change: SubscriberTaxOriginChangeRecord | null;
 }
-/** A charge to write: everything but what the store assigns. */
-type NewSubscriberCharge = Omit<SubscriberChargeRecord, 'id' | 'createdAt'>;
 /**
- * The manifest capability that announces the operator's view of an account.
- * The platform sets it where it serves the view, and the admin UI shows the
- * view only where it is set.
+ * One completed check of a subscriber's VAT identification number, as it was
+ * recorded: never rewritten, whether it counts now or not.
  */
-declare const SUBSCRIBER_ACCOUNT_CAPABILITY = "charges.read";
-/** Whose account it is, as the operator is shown it. */
-interface AdminAccountHolder {
+interface SubscriberVatIdCheckRecord extends VatIdCheck {
     id: string;
-    /** What the customer quotes, and what an invoice will carry. */
-    customerNumber: string;
-    legalName: string;
+    subscriberId: string;
+    /** When the check was recorded, by the platform's clock. */
+    recordedAt: Date;
 }
-/** One charge of an account, with the name its contract line gives it. */
-interface AdminAccountEntry {
-    /** The charge as the journal holds it. */
-    charge: SubscriberCharge;
+/** The outcome of recording a check: the check as recorded, and the one that counts now. */
+interface RecordedVatIdCheck {
+    recorded: SubscriberVatIdCheckRecord;
     /**
-     * The contract line's own title, as it was when the contract was
-     * concluded, or `null` where that line cannot be read.
+     * The check that counts for the subscriber's number from now on: the one
+     * just recorded, one recorded earlier that completed later, or none — a
+     * check of a number the subscriber no longer has counts for nothing.
      */
-    title: string | null;
+    current: SubscriberVatIdCheckRecord | null;
 }
 /**
- * A tenant's account as the operator reads it: the charges of the subscription
- * it holds, newest first — by when each became due, then by its period, then
- * the plan before its add-ons before its discounts.
- *
- * No total: without invoices and payments, a sum would be what was charged so
- * far, and it would be read as what is owed.
+ * What became of a check of a subscriber's VAT identification number: the
+ * check as it was recorded, and whether it counts for the number held — or why
+ * it did not complete, in which case nothing was recorded and the number stays
+ * as validated as it was (`SC-PRIC-040`).
  */
-interface AdminSubscriberAccount {
-    /** `null` for a tenant that has no subscriber. */
-    holder: AdminAccountHolder | null;
-    entries: AdminAccountEntry[];
+type SubscriberVatIdCheckResult = {
+    completed: true;
+    check: SubscriberVatIdCheckRecord;
+    counts: boolean;
+} | {
+    completed: false;
+    reason: string;
+};
+/** A check of a subscriber's VAT identification number, as the operator is shown it. */
+type AdminVatIdCheckOutcome = {
+    completed: true;
+    valid: boolean;
+    /** When the service answered, as an ISO string. */
+    checkedAt: string;
+    service: string;
+    /** Whether it is the check that counts for the number held now. */
+    counts: boolean;
+} | {
+    completed: false;
+    reason: string;
+};
+/**
+ * The answer to an operator's correction or check: the subscriber as it now
+ * stands, and the check a VAT identification number got, where one was made.
+ */
+interface AdminSubscriberCorrected {
+    subscriber: AdminTenantSubscriber;
+    vatIdCheck: AdminVatIdCheckOutcome | null;
 }
+/**
+ * One entry of a subscriber's history as the operator reads it, the latest
+ * first: a correction of its legal identity, a change of its country or
+ * business status, or a check of its VAT identification number. Dates are ISO
+ * strings.
+ */
+type AdminSubscriberHistoryEntry = {
+    kind: 'identity-corrected';
+    at: string;
+    by: string;
+    previous: SubscriberIdentityValues;
+    corrected: SubscriberIdentityValues;
+    reason: string;
+} | {
+    kind: 'tax-origin-changed';
+    at: string;
+    by: string;
+    previous: SubscriberTaxOriginValues;
+    changed: SubscriberTaxOriginValues;
+    /** `null` for a change of the country with the contact details. */
+    reason: string | null;
+} | {
+    kind: 'vat-id-checked';
+    at: string;
+    vatId: string;
+    valid: boolean;
+    service: string;
+    /** Whether it is the check that counts for the number held now. */
+    counts: boolean;
+};
 
 /**
  * Snapshot form of a `Subscription` row for the EntitlementService
@@ -4592,6 +5992,79 @@ interface SubscriptionBundleRepository {
      * implementations to avoid drift.
      */
     countActiveByBundleVersionId(bundleVersionId: string, asOf?: Date): Promise<number>;
+    /**
+     * Every booking of the add-on version `bundleVersionId`, in every tenant,
+     * whatever its state. The platform reads it to find the bookings an add-on
+     * retirement reaches, inside the RLS bypass, and decides itself which of
+     * them are still running.
+     *
+     * Optional, so a repository written before it keeps working; retiring an
+     * add-on version over one without it is refused at start-up.
+     */
+    listOfVersion?(bundleVersionId: string): Promise<SubscriptionBundleRecord[]>;
+    /**
+     * Moves the booking `subscriptionBundleId` from the add-on version `from`
+     * onto `to` and answers it as it now stands, or null where it is not on
+     * `from` any more, or gone. Nothing else changes: its period, its terms,
+     * its rhythm and its cancellation stay as they are. Conditional on `from`,
+     * so a move and the put-back of a move that could not write its contract
+     * never write over each other, nor two runs over one booking.
+     *
+     * An add-on retirement moves a booking at its date, and a subscriber by
+     * taking a newer version offered (`SC-BUN-058`). Optional, so a repository
+     * written before it keeps working; retiring an add-on version over one
+     * without it is refused at start-up, and no newer version is offered.
+     */
+    moveToVersion?(subscriptionBundleId: string, from: string, to: string): Promise<SubscriptionBundleRecord | null>;
+    /**
+     * Schedules the booking `subscriptionBundleId` to continue on the add-on
+     * version `to` from `effectiveAt` — `pendingBundleVersionId` and
+     * `pendingVersionEffectiveAt` — and answers it as it now stands, or null
+     * where it is not on `from` any more, already has a switch scheduled, or is
+     * gone. Nothing else changes, its version included: the switch is made at
+     * that moment by the run (`listScheduledVersionsDue`).
+     *
+     * Optional, and so are the two methods after it: without all three, a
+     * newer version that takes something away is not offered.
+     */
+    scheduleVersion?(subscriptionBundleId: string, switchTo: {
+        from: string;
+        to: string;
+        effectiveAt: Date;
+    }): Promise<SubscriptionBundleRecord | null>;
+    /**
+     * Clears the switch scheduled for the booking `subscriptionBundleId`, and
+     * answers it as it now stands; null where no switch to `to` is scheduled
+     * any more, or it is gone. Its version stays as it is.
+     */
+    unscheduleVersion?(subscriptionBundleId: string, to: string): Promise<SubscriptionBundleRecord | null>;
+    /**
+     * Every booking, in every tenant and whatever its state, with a switch
+     * scheduled to take effect at or before `asOf` — oldest first. The
+     * platform reads it inside the RLS bypass and decides itself which of
+     * them still move.
+     */
+    listScheduledVersionsDue?(asOf: Date): Promise<SubscriptionBundleRecord[]>;
+    /**
+     * Ends at `input.at` the booking `subscriptionBundleId` whose cancellation
+     * was declared for a later date, provided its effective date is still
+     * `input.expectedCanceledEffectiveAt`, and answers it as it now stands;
+     * null where its cancellation moved meanwhile, or it is gone. Both
+     * cancellation fields become `input.at`. What a feature withdrawn for an
+     * external reason lets a subscriber do, cancelled or not; a booking not
+     * cancelled is ended through `cancel`.
+     *
+     * Optional, so a repository written before it keeps working; without it, a
+     * booking already cancelled for a later date cannot be ended at once.
+     */
+    endNow?(subscriptionBundleId: string, input: EndNowInput): Promise<SubscriptionBundleRecord | null>;
+}
+/** What ending at once something cancelled for a later date is told to write. */
+interface EndNowInput {
+    /** The moment it ends, and the moment that is declared. */
+    readonly at: Date;
+    /** The effective date of the cancellation the caller read: the write is conditional on it. */
+    readonly expectedCanceledEffectiveAt: Date;
 }
 /**
  * Append-only repository for V3 SubscriptionContracts. Contracts are the
@@ -4694,19 +6167,66 @@ interface SubscriberRepository {
     findById(subscriberId: string, tx?: TransactionContext): Promise<SubscriberRecord | null>;
     /** The subscriber live for this tenant, or `null` when it has none. */
     findByTenantId(tenantId: string, tx?: TransactionContext): Promise<SubscriberRecord | null>;
-    /** Writes the members given and keeps the rest; `null` when no such subscriber exists. */
-    updateContact(subscriberId: string, change: SubscriberContactChange, tx?: TransactionContext): Promise<SubscriberRecord | null>;
+    /**
+     * Writes the members given and keeps the rest; `null` when no such
+     * subscriber exists. Read and written under the lock a correction takes. A
+     * change of the country is a change of the tax origin and is recorded as
+     * one in the same step, by `changedBy` and dated while the lock is held.
+     */
+    updateContact(subscriberId: string, change: SubscriberContactChange, changedBy: string, tx?: TransactionContext): Promise<SubscriberRecord | null>;
     /**
      * Writes a correction of the legal identity and records it, in one step:
      * the subscriber is read and changed under a lock, so the values recorded
      * as replaced are the ones this write replaced even when two corrections
-     * arrive at once. A field whose stored value already equals the corrected
-     * one is left out of the record, and when none differs nothing is written
-     * and `correction` is `null`. `null` when no such subscriber exists.
+     * arrive at once. The correction is dated while the lock is held and
+     * numbered by the database as it is written. A field whose stored value
+     * already equals the corrected one is left out of the record, and when none
+     * differs nothing is written and `correction` is `null`. `null` when no
+     * such subscriber exists.
+     *
+     * A corrected VAT identification number is a change of the tax origin and
+     * is recorded as one too, by the same actor and with the same date.
+     * The check that counted for the number it replaced counts no more — it
+     * would otherwise validate that number again should it come back — and
+     * stays recorded (`listVatIdChecks`); the number written is held from that
+     * date (`vatIdSince`), so no check completed before it counts for it.
      */
     correctIdentity(subscriberId: string, data: SubscriberCorrectionData, tx?: TransactionContext): Promise<SubscriberCorrectionResult | null>;
-    /** Every correction of this subscriber, the latest first. */
+    /** Every correction of this subscriber, the latest written first. */
     listCorrections(subscriberId: string): Promise<SubscriberCorrectionRecord[]>;
+    /**
+     * Writes whether the subscriber is a business and records the change of
+     * its tax origin, in one step and under the same lock as a correction,
+     * dated while the lock is held. When the stored status already equals the
+     * one given nothing is written and `change` is `null`. `null` when no such
+     * subscriber exists.
+     */
+    changeBusinessStatus(subscriberId: string, data: SubscriberBusinessStatusData, tx?: TransactionContext): Promise<SubscriberBusinessStatusResult | null>;
+    /**
+     * Records a completed check of the subscriber's VAT identification number.
+     * Every check is recorded and none is rewritten or removed: it is the
+     * evidence a reverse charge rests on. Under the lock a correction takes it
+     * then decides whether the check counts from now on — only for the number
+     * the subscriber holds, completed since it holds it, and never over a check
+     * that completed later (`keepsVatIdCheck` from `@saasicat/core` decides).
+     * `null` when no such subscriber exists.
+     */
+    recordVatIdCheck(subscriberId: string, check: VatIdCheck, tx?: TransactionContext): Promise<RecordedVatIdCheck | null>;
+    /**
+     * The check that counts for the subscriber's number now, or `null` while
+     * none does: never checked, or corrected since.
+     */
+    findCurrentVatIdCheck(subscriberId: string, tx?: TransactionContext): Promise<SubscriberVatIdCheckRecord | null>;
+    /** Every check recorded for this subscriber, counting or not, the latest checked first. */
+    listVatIdChecks(subscriberId: string): Promise<SubscriberVatIdCheckRecord[]>;
+    /**
+     * The live subscribers of these tenants, each with the check of its VAT id
+     * that counts now, in at most a few reads — what the operator's lists mark
+     * a subscriber from. A tenant without a live subscriber is left out.
+     */
+    listForTenants(tenantIds: readonly string[], tx?: TransactionContext): Promise<SubscriberWithCurrentCheck[]>;
+    /** Every recorded change of this subscriber's tax origin, the latest written first. */
+    listTaxOriginChanges(subscriberId: string): Promise<SubscriberTaxOriginChangeRecord[]>;
 }
 /**
  * The subscriber's account: the charges that became due, one per contract line
@@ -4729,6 +6249,113 @@ interface SubscriberLedgerRepository {
     /** Every charge of one subscription, oldest period first. */
     listBySubscription(subscriptionId: string, tx?: TransactionContext): Promise<SubscriberChargeRecord[]>;
 }
+/**
+ * The invoices issued from the charge journal, and the one number range they
+ * are numbered in (`SC-PRIC-072`).
+ *
+ * An invoice is written once and never changed. Its number is drawn when it is
+ * written, in the same transaction, so an invoice that fails to be written
+ * leaves no gap; the range restarts at 1 each year.
+ */
+interface SubscriptionInvoiceRepository {
+    /**
+     * The subscriptions with a charge to invoice: a charge on no invoice in a
+     * group — the charges booked at the same moment under the same contract —
+     * that carries an amount (`SC-PRIC-048`). By id, at most `limit`, after
+     * `after` where it is given, so a caller reads them page by page and a
+     * subscription held back on one run never keeps the others from the next.
+     */
+    listSubscriptionsWithUninvoicedCharges(page: {
+        limit: number;
+        after?: string;
+    }, tx?: TransactionContext): Promise<string[]>;
+    /** The charges of one subscription on no invoice, oldest period first. */
+    listUninvoicedCharges(subscriptionId: string, tx?: TransactionContext): Promise<SubscriberChargeRecord[]>;
+    /**
+     * Draws the next number of the invoice's year and writes the invoice with
+     * its lines, in one transaction — the caller's where it passes one. Two
+     * calls at once draw two numbers one after the other, never the same one
+     * and never with a gap between them.
+     *
+     * Refuses with `SUBSCRIPTION_INVOICE_CHARGE_INVOICED` (`moved`) where a
+     * charge already stands on an invoice: nothing is written, and the number
+     * is not drawn.
+     */
+    issue(invoice: NewSubscriptionInvoice, tx?: TransactionContext): Promise<SubscriptionInvoiceRecord>;
+    findById(id: string, tx?: TransactionContext): Promise<SubscriptionInvoiceRecord | null>;
+    /** Every invoice of one subscriber, the latest number first. */
+    listBySubscriber(subscriberId: string, tx?: TransactionContext): Promise<SubscriptionInvoiceRecord[]>;
+    /**
+     * The prefixes the issued invoices carry, at most two: one is the range,
+     * a second one says the prefix was changed under it (`SC-PRIC-024`).
+     */
+    listIssuedNumberPrefixes(tx?: TransactionContext): Promise<string[]>;
+    /**
+     * Records the rendering of an invoice's document before its file is
+     * archived (`SC-AUD-019`), once. A rendering recorded again with the same
+     * checksum is the same write and answers the record as it stands; another
+     * checksum is refused with `SUBSCRIPTION_INVOICE_DOCUMENT_CHANGED`
+     * (`moved`), and the first stays: `replaceRendering` is the one write that
+     * puts another in its place.
+     */
+    recordRendering(invoiceId: string, rendering: NewInvoiceRendering, tx?: TransactionContext): Promise<SubscriptionInvoiceDocumentRecord>;
+    /**
+     * Records a rendering in place of the one recorded with `replaced` as its
+     * checksum, while the invoice is not archived (`SC-AUD-019`): until the
+     * archive holds a file, nothing has been handed out. Answers the record as
+     * it stands now, or `null` where the recorded checksum is another by now or
+     * the invoice is archived — a run that read it before another one changed it.
+     */
+    replaceRendering(invoiceId: string, rendering: NewInvoiceRendering, replaced: string, tx?: TransactionContext): Promise<SubscriptionInvoiceDocumentRecord | null>;
+    /**
+     * Records that the archive confirmed the document whose checksum is
+     * `checksum`; `false` where it was already recorded, or the recorded
+     * checksum is another.
+     */
+    markArchived(invoiceId: string, at: Date, checksum: string, tx?: TransactionContext): Promise<boolean>;
+    /**
+     * Claims an archived invoice's mail for the run calling it at `at`: where
+     * it is not delivered and no run holds it, or the run that holds it took it
+     * on before `staleBefore`. `true` where this run holds it now — of two
+     * concurrent calls exactly one does — so that an invoice is mailed once
+     * however many instances run (`SC-PRIC-047`).
+     */
+    claimDelivery(invoiceId: string, at: Date, staleBefore: Date, tx?: TransactionContext): Promise<boolean>;
+    /**
+     * Records that the invoice was handed to the mail, provided it is still
+     * held by the claim taken at `claimedAt` and not delivered. `false` where it
+     * is not: the claim went stale and another run took the invoice on.
+     */
+    markDelivered(invoiceId: string, delivery: {
+        claimedAt: Date;
+        at: Date;
+        to: string;
+    }, tx?: TransactionContext): Promise<boolean>;
+    /**
+     * Lets go of the claim taken at `claimedAt`, so the next run tries again.
+     * Does nothing where the invoice is delivered or held by another claim.
+     */
+    releaseDelivery(invoiceId: string, claimedAt: Date, tx?: TransactionContext): Promise<void>;
+    /** Where the invoice's document stands, or `null` before it was rendered. */
+    findDocument(invoiceId: string, tx?: TransactionContext): Promise<SubscriptionInvoiceDocumentRecord | null>;
+    /**
+     * The invoices whose document the archive has not confirmed yet —
+     * not rendered, or rendered and not archived (`SC-PRIC-033`). By id, at
+     * most `limit`, after `after` where it is given.
+     */
+    listAwaitingDocument(page: {
+        limit: number;
+        after?: string;
+    }, tx?: TransactionContext): Promise<string[]>;
+    /**
+     * The invoices archived and not yet handed to the mail, page by page as
+     * above — whether or not a run holds them, which `claimDelivery` decides.
+     */
+    listAwaitingDelivery(page: {
+        limit: number;
+        after?: string;
+    }, tx?: TransactionContext): Promise<string[]>;
+}
 /**
  * Display form of a subscription for the tenant self-service UI.
  * Richer than `SubscriptionRecord` (which is only the aggregation form); contains
@@ -4863,6 +6490,16 @@ interface SubscriptionUsagePort {
      * port without it is refused at start-up.
      */
     listBoundToVersion?(planVersionId: string): Promise<TenantSubscriptionUsage[]>;
+    /**
+     * The subscriptions `subscriptionIds`, in whichever tenant, each with the
+     * tenant it belongs to; an id that names none is left out. The platform
+     * reads it inside the RLS bypass to find the subscription of each booking
+     * an add-on retirement reaches.
+     *
+     * Optional, so a port written before it keeps working; retiring an add-on
+     * version over a port without it is refused at start-up.
+     */
+    listByIds?(subscriptionIds: readonly string[]): Promise<TenantSubscriptionUsage[]>;
 }
 /**
  * Returns the current usage for all quotaKeys of a tenant declared via
@@ -5061,6 +6698,14 @@ interface CancelSubscriptionInput {
     terminateNow: boolean;
     minimumTermUntil?: Date;
 }
+/** What `endNow` answers with. */
+interface EndSubscriptionNowResult {
+    /** False where the cancellation moved since it was read, and nothing was written. */
+    ended: boolean;
+    canceledAt: Date | null;
+    canceledEffectiveAt: Date | null;
+    status: string;
+}
 /** What `cancelSubscription` answers with. */
 interface CancelSubscriptionResult {
     canceledAt: Date | null;
@@ -5130,6 +6775,22 @@ interface TenantSubscriptionWritePort {
      * unchanged, which is the ordinary case.
      */
     cancelSubscription(tenantId: string, input: CancelSubscriptionInput): Promise<CancelSubscriptionResult>;
+    /**
+     * Ends at `input.at` a subscription whose cancellation was declared for a
+     * later date, provided its effective date is still
+     * `input.expectedCanceledEffectiveAt`: both cancellation fields become
+     * `input.at` and the status `CANCELED`. Answers `ended: false`, with the
+     * stored fields, where the cancellation moved meanwhile. A conditional
+     * claim, like `cancelSubscription`, so an end written in between is not
+     * written over.
+     *
+     * What a feature withdrawn for an external reason lets a subscriber do,
+     * cancelled or not; a subscription not cancelled is ended through
+     * `cancelSubscription` with `terminateNow`. Optional, so a port written
+     * before it keeps working; without it, a subscription already cancelled
+     * for a later date cannot be ended at once.
+     */
+    endNow?(tenantId: string, input: EndNowInput): Promise<EndSubscriptionNowResult>;
     /**
      * Atomic onboarding creation: sets plan + cycle + period window
      * AND optionally calls a promo-redeem callback — all in a
@@ -5336,7 +6997,9 @@ interface AdminUserListRow {
 }
 interface AdminSubscriptionListRow {
     id: string;
+    /** The tenant by its id too: what the operator's lists ask a subscriber's standing by. */
     tenant: {
+        id: string;
         slug: string;
         name: string;
     };
@@ -6221,11 +7884,26 @@ interface SubscriptionNoticeRepository {
  * Throw where it could not be sent and should be tried again: the claim is
  * released and the next run sends it. Resolving with no recipients records that
  * nobody could be told, and the notice is not tried again — except a
- * retirement's notice (`version-retired`), which nobody was told of: it is tried
- * again by every run until somebody is, and its date counts from then.
+ * retirement's notice (`version-retired`, `bundle-version-retired`), which
+ * nobody was told of: it is tried again by every run until somebody is, and its
+ * date counts from then.
+ */
+interface SubscriptionNoticePort {
+    deliver(notice: SubscriptionNotice): Promise<SubscriptionNoticeDelivery>;
+}
+
+/**
+ * Keeps every add-on retirement announcement: which version, which
+ * replacement, when and by whom. What it means for each booking it reaches is
+ * kept beside it as a notice of kind `bundle-version-retired`, written in the
+ * same transaction.
  */
-interface SubscriptionNoticePort {
-    deliver(notice: SubscriptionNotice): Promise<SubscriptionNoticeDelivery>;
+interface BundleVersionRetirementRepository {
+    /** Records an announcement, in the caller's transaction where one is given. */
+    create(data: NewBundleVersionRetirement, tx?: TransactionContext): Promise<BundleVersionRetirementRecord>;
+    /** Every announcement, the most recent first. */
+    list(): Promise<BundleVersionRetirementRecord[]>;
+    findById(id: string): Promise<BundleVersionRetirementRecord | null>;
 }
 
 /**
@@ -6241,6 +7919,45 @@ interface VersionRetirementRepository {
     findById(id: string): Promise<VersionRetirementRecord | null>;
 }
 
+/**
+ * Keeps every feature withdrawal: which feature, why, from when, the
+ * reductions the operator named, when it was lifted, and when the
+ * subscriptions it reaches were told. What it means for each of them is kept
+ * beside it as a notice of kind `feature-withdrawn`, written in the
+ * transaction that marks it told.
+ *
+ * An adapter translates. It does not decide whether a feature may be
+ * withdrawn; it holds a feature to one withdrawal not yet lifted, so that two
+ * operators announcing at once cannot both succeed, and makes lifting and
+ * marking it told conditional on neither having happened yet.
+ */
+interface FeatureWithdrawalRepository {
+    /**
+     * Records a withdrawal, in the caller's transaction where one is given, and
+     * returns it as stored — the id is the adapter's to assign. Returns null
+     * where a withdrawal of the same feature is recorded and not lifted: the
+     * database holds a feature to one, so of two concurrent calls exactly one
+     * lands.
+     */
+    create(data: NewFeatureWithdrawal, tx?: TransactionContext): Promise<FeatureWithdrawalRecord | null>;
+    /** Every withdrawal, the most recently announced first. */
+    list(): Promise<FeatureWithdrawalRecord[]>;
+    findById(id: string): Promise<FeatureWithdrawalRecord | null>;
+    /**
+     * Records that the withdrawal `id` is lifted, provided it is not lifted
+     * yet, and returns it as stored; null where it was lifted meanwhile or no
+     * withdrawal has that id.
+     */
+    lift(id: string, lift: FeatureWithdrawalLift, tx?: TransactionContext): Promise<FeatureWithdrawalRecord | null>;
+    /**
+     * Records that the subscriptions the withdrawal `id` reaches were told at
+     * `at`, provided nobody recorded it yet, in the caller's transaction where
+     * one is given. Returns whether this call recorded it: of an announcement
+     * and a run telling the same withdrawal at once, exactly one does.
+     */
+    markTold(id: string, at: Date, tx?: TransactionContext): Promise<boolean>;
+}
+
 /** Class reference usable as a DI token (e.g. the consumer's `PrismaService`). */
 type PersistenceClassRef = abstract new (...args: never[]) => unknown;
 /** DI token forms a persistence bundle may reference in `inject`. */
@@ -6328,6 +8045,10 @@ interface SaaSiCatPersistenceEntitlement {
     subscriberRepository?: PersistenceProvider<SubscriberRepository>;
     /** The charges a subscriber's contracts give rise to (`tenantBilling.chargeJournal`). */
     subscriberLedgerRepository?: PersistenceProvider<SubscriberLedgerRepository>;
+    /** The invoices issued from those charges (`tenantBilling.chargeJournal.invoices`). */
+    subscriptionInvoiceRepository?: PersistenceProvider<SubscriptionInvoiceRepository>;
+    /** The invoices' documents, kept in the database (`chargeJournal.invoices.archive`). */
+    subscriptionInvoiceArchive?: PersistenceProvider<InvoiceArchivePort>;
     subscriptionBundleRepository?: PersistenceProvider<SubscriptionBundleRepository>;
     bundleRepository?: PersistenceProvider<BundleRepository>;
 }
@@ -6365,6 +8086,17 @@ interface SaaSiCatPersistenceTenantBilling {
      * retire versions without one is refused at start-up.
      */
     versionRetirements?: PersistenceProvider<VersionRetirementRepository>;
+    /**
+     * The record of every add-on retirement announcement. Optional so an
+     * adapter written before it keeps working; without it, retiring an add-on
+     * version is off, and retiring a plan version is not affected.
+     */
+    bundleVersionRetirements?: PersistenceProvider<BundleVersionRetirementRepository>;
+    /**
+     * The record of every feature withdrawal. Optional so an adapter written
+     * before it keeps working; without it, withdrawing a feature is off.
+     */
+    featureWithdrawals?: PersistenceProvider<FeatureWithdrawalRepository>;
 }
 /**
  * The record of payment gateway callbacks and the payment methods they confirm
@@ -6531,6 +8263,13 @@ declare const CATALOG_ERROR_CODES: {
     readonly PLAN_NOT_FOUND: "PLAN_NOT_FOUND";
     readonly PLAN_VERSION_NOT_FOUND: "PLAN_VERSION_NOT_FOUND";
     readonly 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.
+     */
+    readonly BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING: "BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING";
     readonly BUNDLE_VERSION_NOT_FOUND: "BUNDLE_VERSION_NOT_FOUND";
     readonly FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND";
     readonly QUOTA_NOT_FOUND: "QUOTA_NOT_FOUND";
@@ -6718,6 +8457,16 @@ declare const BILLING_ERROR_CODES: {
      * to pick, so the way past it is the add-on ending.
      */
     readonly 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.
+     */
+    readonly 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.
@@ -6728,6 +8477,142 @@ declare const BILLING_ERROR_CODES: {
      * the retirement as it now stands.
      */
     readonly RETIREMENT_SWITCH_CHANGED: "RETIREMENT_SWITCH_CHANGED";
+    /**
+     * 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.
+     */
+    readonly 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. */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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. */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly BUNDLE_VERSION_OFFER_CHANGED: "BUNDLE_VERSION_OFFER_CHANGED";
+    /**
+     * Withdrawing a feature is not offered: the installation's stores cannot
+     * list everybody a withdrawal would reach.
+     */
+    readonly FEATURE_WITHDRAWAL_UNAVAILABLE: "FEATURE_WITHDRAWAL_UNAVAILABLE";
+    /** The catalogue knows no feature of that key, so there is nothing to withdraw. Carries `featureKey`. */
+    readonly 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.
+     */
+    readonly 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`. */
+    readonly 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.
+     */
+    readonly 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`.
+     */
+    readonly FEATURE_WITHDRAWAL_REDUCTION_NOT_REACHED: "FEATURE_WITHDRAWAL_REDUCTION_NOT_REACHED";
+    /** A reduction is named twice. Carries `kind`, `key` and `billingCycle`. */
+    readonly 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`.
+     */
+    readonly 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`.
+     */
+    readonly FEATURE_WITHDRAWAL_PREVIEW_CHANGED: "FEATURE_WITHDRAWAL_PREVIEW_CHANGED";
+    /** No withdrawal has that id. Carries `withdrawalId`. */
+    readonly FEATURE_WITHDRAWAL_NOT_FOUND: "FEATURE_WITHDRAWAL_NOT_FOUND";
+    /** The withdrawal was lifted already. Carries the `date` it is lifted from. */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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`.
+     */
+    readonly 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.
+     */
+    readonly FEATURE_WITHDRAWAL_DOES_NOT_REACH: "FEATURE_WITHDRAWAL_DOES_NOT_REACH";
+    /** What was to be ended at once has ended already. */
+    readonly 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`.
+     */
+    readonly FEATURE_WITHDRAWAL_END_NOW_UNSUPPORTED: "FEATURE_WITHDRAWAL_END_NOW_UNSUPPORTED";
     /** The subscription has ended; its plan can no longer be changed. */
     readonly SUBSCRIPTION_ENDED: "SUBSCRIPTION_ENDED";
     /** An active special contract blocks self-service plan changes. */
@@ -6762,6 +8647,16 @@ declare const BILLING_ERROR_CODES: {
      * day the booking can end.
      */
     readonly 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.
+     */
+    readonly 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
@@ -6831,6 +8726,21 @@ declare const CONTRACT_ERROR_CODES: {
      * describes. Nothing was written; load the offer and conclude it again.
      */
     readonly 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.
+     */
+    readonly 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.
+     */
+    readonly CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION: "CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION";
     readonly SUBSCRIPTION_CONTRACT_NOT_FOUND: "SUBSCRIPTION_CONTRACT_NOT_FOUND";
     readonly NO_ACTIVE_SUBSCRIPTION_CONTRACT: "NO_ACTIVE_SUBSCRIPTION_CONTRACT";
     readonly SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SUBSCRIPTION_CONTRACT_ALREADY_CLOSED";
@@ -6842,8 +8752,64 @@ declare const CONTRACT_ERROR_CODES: {
      * would take effect. Nothing was written.
      */
     readonly 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.
+     */
+    readonly SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED";
 };
 type ContractErrorCode = (typeof CONTRACT_ERROR_CODES)[keyof typeof CONTRACT_ERROR_CODES];
+/** Invoices issued from the charge journal (`SubscriptionInvoiceService`). */
+declare const 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.
+     */
+    readonly 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`).
+     */
+    readonly 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`).
+     */
+    readonly 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.
+     */
+    readonly 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`).
+     */
+    readonly 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`).
+     */
+    readonly 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`). */
+    readonly SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED: "SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED";
+    /** No invoice with this id (`invoiceId`). */
+    readonly 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.
+     */
+    readonly SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL";
+};
+type InvoiceErrorCode = (typeof INVOICE_ERROR_CODES)[keyof typeof INVOICE_ERROR_CODES];
 /** The parties contracts are concluded with (`SubscriberService`), and their absence. */
 declare const SUBSCRIBER_ERROR_CODES: {
     /**
@@ -6868,6 +8834,29 @@ declare const SUBSCRIBER_ERROR_CODES: {
     readonly SUBSCRIBER_CORRECTION_CHANGES_NOTHING: "SUBSCRIBER_CORRECTION_CHANGES_NOTHING";
     /** The operator declared another legal entity: that is a transfer, not an edit. */
     readonly 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.
+     */
+    readonly 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. */
+    readonly 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.
+     */
+    readonly 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`).
+     */
+    readonly 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. */
+    readonly SUBSCRIBER_VAT_ID_MISSING: "SUBSCRIBER_VAT_ID_MISSING";
 };
 type SubscriberErrorCode = (typeof SUBSCRIBER_ERROR_CODES)[keyof typeof SUBSCRIBER_ERROR_CODES];
 /** Self-service registration funnel (`PendingRegistration`). */
@@ -6985,6 +8974,31 @@ declare const MAINTENANCE_ERROR_CODES: {
     readonly MAINTENANCE_MESSAGE_TOO_LONG: "MAINTENANCE_MESSAGE_TOO_LONG";
 };
 type MaintenanceErrorCode = (typeof MAINTENANCE_ERROR_CODES)[keyof typeof MAINTENANCE_ERROR_CODES];
+/** Codes of the installation's tax adapter (ADR 0013). */
+declare const 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`).
+     */
+    readonly 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.
+     */
+    readonly 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`).
+     */
+    readonly TAX_VAT_ID_CHECK_NOT_AVAILABLE: "TAX_VAT_ID_CHECK_NOT_AVAILABLE";
+};
+type TaxErrorCode = (typeof TAX_ERROR_CODES)[keyof typeof TAX_ERROR_CODES];
 /**
  * Every exception code the platform emits, in one object.
  *
@@ -6993,6 +9007,27 @@ type MaintenanceErrorCode = (typeof MAINTENANCE_ERROR_CODES)[keyof typeof MAINTE
  * removing one may not.
  */
 declare const PLATFORM_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`).
+     */
+    readonly 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.
+     */
+    readonly 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`).
+     */
+    readonly TAX_VAT_ID_CHECK_NOT_AVAILABLE: "TAX_VAT_ID_CHECK_NOT_AVAILABLE";
     /** The application is locked for maintenance; the body carries the window. */
     readonly MAINTENANCE: "MAINTENANCE";
     /** A window is already open: move or cancel it before announcing another. */
@@ -7069,6 +9104,76 @@ declare const PLATFORM_ERROR_CODES: {
     readonly SUBSCRIBER_CORRECTION_CHANGES_NOTHING: "SUBSCRIBER_CORRECTION_CHANGES_NOTHING";
     /** The operator declared another legal entity: that is a transfer, not an edit. */
     readonly 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.
+     */
+    readonly 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. */
+    readonly 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.
+     */
+    readonly 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`).
+     */
+    readonly 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. */
+    readonly SUBSCRIBER_VAT_ID_MISSING: "SUBSCRIBER_VAT_ID_MISSING";
+    /**
+     * 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.
+     */
+    readonly 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`).
+     */
+    readonly 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`).
+     */
+    readonly 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.
+     */
+    readonly 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`).
+     */
+    readonly 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`).
+     */
+    readonly 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`). */
+    readonly SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED: "SUBSCRIPTION_INVOICE_DOCUMENT_NOT_ARCHIVED";
+    /** No invoice with this id (`invoiceId`). */
+    readonly 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.
+     */
+    readonly SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL";
     readonly CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "CHECKOUT_OFFER_LINE_ITEMS_REQUIRED";
     readonly CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED";
     readonly CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED";
@@ -7103,6 +9208,21 @@ declare const PLATFORM_ERROR_CODES: {
      * describes. Nothing was written; load the offer and conclude it again.
      */
     readonly 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.
+     */
+    readonly 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.
+     */
+    readonly CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION: "CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION";
     readonly SUBSCRIPTION_CONTRACT_NOT_FOUND: "SUBSCRIPTION_CONTRACT_NOT_FOUND";
     readonly NO_ACTIVE_SUBSCRIPTION_CONTRACT: "NO_ACTIVE_SUBSCRIPTION_CONTRACT";
     readonly SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SUBSCRIPTION_CONTRACT_ALREADY_CLOSED";
@@ -7114,6 +9234,11 @@ declare const PLATFORM_ERROR_CODES: {
      * would take effect. Nothing was written.
      */
     readonly 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.
+     */
+    readonly SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED";
     /**
      * Feature not covered by the plan. Defined in `upsell.types.ts` because the
      * upsell body type is built around it; re-exported here so an exhaustive
@@ -7273,6 +9398,16 @@ declare const PLATFORM_ERROR_CODES: {
      * to pick, so the way past it is the add-on ending.
      */
     readonly 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.
+     */
+    readonly 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.
@@ -7283,6 +9418,142 @@ declare const PLATFORM_ERROR_CODES: {
      * the retirement as it now stands.
      */
     readonly RETIREMENT_SWITCH_CHANGED: "RETIREMENT_SWITCH_CHANGED";
+    /**
+     * 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.
+     */
+    readonly 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. */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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. */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly BUNDLE_VERSION_OFFER_CHANGED: "BUNDLE_VERSION_OFFER_CHANGED";
+    /**
+     * Withdrawing a feature is not offered: the installation's stores cannot
+     * list everybody a withdrawal would reach.
+     */
+    readonly FEATURE_WITHDRAWAL_UNAVAILABLE: "FEATURE_WITHDRAWAL_UNAVAILABLE";
+    /** The catalogue knows no feature of that key, so there is nothing to withdraw. Carries `featureKey`. */
+    readonly 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.
+     */
+    readonly 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`. */
+    readonly 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.
+     */
+    readonly 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`.
+     */
+    readonly FEATURE_WITHDRAWAL_REDUCTION_NOT_REACHED: "FEATURE_WITHDRAWAL_REDUCTION_NOT_REACHED";
+    /** A reduction is named twice. Carries `kind`, `key` and `billingCycle`. */
+    readonly 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`.
+     */
+    readonly 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`.
+     */
+    readonly FEATURE_WITHDRAWAL_PREVIEW_CHANGED: "FEATURE_WITHDRAWAL_PREVIEW_CHANGED";
+    /** No withdrawal has that id. Carries `withdrawalId`. */
+    readonly FEATURE_WITHDRAWAL_NOT_FOUND: "FEATURE_WITHDRAWAL_NOT_FOUND";
+    /** The withdrawal was lifted already. Carries the `date` it is lifted from. */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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`.
+     */
+    readonly 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.
+     */
+    readonly FEATURE_WITHDRAWAL_DOES_NOT_REACH: "FEATURE_WITHDRAWAL_DOES_NOT_REACH";
+    /** What was to be ended at once has ended already. */
+    readonly 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`.
+     */
+    readonly FEATURE_WITHDRAWAL_END_NOW_UNSUPPORTED: "FEATURE_WITHDRAWAL_END_NOW_UNSUPPORTED";
     /** The subscription has ended; its plan can no longer be changed. */
     readonly SUBSCRIPTION_ENDED: "SUBSCRIPTION_ENDED";
     /** An active special contract blocks self-service plan changes. */
@@ -7317,6 +9588,16 @@ declare const PLATFORM_ERROR_CODES: {
      * day the booking can end.
      */
     readonly 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.
+     */
+    readonly 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
@@ -7421,6 +9702,13 @@ declare const PLATFORM_ERROR_CODES: {
     readonly PLAN_NOT_FOUND: "PLAN_NOT_FOUND";
     readonly PLAN_VERSION_NOT_FOUND: "PLAN_VERSION_NOT_FOUND";
     readonly 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.
+     */
+    readonly BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING: "BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING";
     readonly BUNDLE_VERSION_NOT_FOUND: "BUNDLE_VERSION_NOT_FOUND";
     readonly FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND";
     readonly QUOTA_NOT_FOUND: "QUOTA_NOT_FOUND";
@@ -7493,7 +9781,7 @@ declare const PLATFORM_ERROR_CODES: {
     /** Email already taken (mapped from `PlatformUserExistsError`). */
     readonly EMAIL_EXISTS: "EMAIL_EXISTS";
 };
-type PlatformErrorCode = SetupErrorCode | AuthErrorCode | PromoErrorCode | CatalogErrorCode | BillingErrorCode | ContractErrorCode | SubscriberErrorCode | RegistrationErrorCode | PaymentErrorCode | SettingsErrorCode | MaintenanceErrorCode;
+type PlatformErrorCode = SetupErrorCode | AuthErrorCode | PromoErrorCode | CatalogErrorCode | BillingErrorCode | ContractErrorCode | InvoiceErrorCode | SubscriberErrorCode | RegistrationErrorCode | PaymentErrorCode | SettingsErrorCode | MaintenanceErrorCode | TaxErrorCode;
 /**
  * Shape of a coded error response.
  *
@@ -7577,7 +9865,14 @@ declare const OPTIONAL_CANONICAL_MODELS: {
     readonly MaintenanceWindow: readonly ["core.maintenanceWindows"];
     readonly SubscriptionNotice: readonly ["tenantBilling.subscriptionNotices"];
     readonly VersionRetirement: readonly ["tenantBilling.versionRetirements"];
+    readonly BundleVersionRetirement: readonly ["tenantBilling.bundleVersionRetirements"];
+    readonly FeatureWithdrawal: readonly ["tenantBilling.featureWithdrawals"];
     readonly SubscriberLedgerEntry: readonly ["entitlement.subscriberLedgerRepository"];
+    readonly SubscriptionInvoice: readonly ["entitlement.subscriptionInvoiceRepository"];
+    readonly SubscriptionInvoiceLine: readonly ["entitlement.subscriptionInvoiceRepository"];
+    readonly SubscriptionInvoiceNumber: readonly ["entitlement.subscriptionInvoiceRepository"];
+    readonly SubscriptionInvoiceDocument: readonly ["entitlement.subscriptionInvoiceRepository"];
+    readonly SubscriptionInvoiceArchive: readonly ["entitlement.subscriptionInvoiceArchive"];
     readonly PromoCodeHold: readonly ["promo.holdRepository"];
 };
 type OptionalCanonicalModel = keyof typeof OPTIONAL_CANONICAL_MODELS;
@@ -7881,6 +10176,14 @@ interface PendingRegistration {
     country: string | null;
     vatId: string | null;
     taxNumber: string | null;
+    /** Whether the sign-up is a business, as step 4 says; `null` where it did not say. */
+    business: boolean | null;
+    /**
+     * The check of `vatId` step 4 made, outside any transaction, where the tax
+     * adapter needed a validated number to treat the sign-up; `null` where it
+     * needed none. The subscriber takes it over when it is created.
+     */
+    vatIdCheck: VatIdCheck | null;
     /** The gateway's session for the payment method, unique within `checkoutGatewayAccount`. */
     checkoutSessionId: string | null;
     /** The account in `config/saas.yaml#payments.accounts` the session was opened at. */
@@ -7925,6 +10228,8 @@ interface PendingRegistrationUpdateInput {
     country?: string | null;
     vatId?: string | null;
     taxNumber?: string | null;
+    business?: boolean | null;
+    vatIdCheck?: VatIdCheck | null;
     checkoutSessionId?: string | null;
     checkoutGatewayAccount?: string | null;
     gatewayCustomerRef?: string | null;
@@ -8179,7 +10484,12 @@ interface ConfiguratorPlanMarketing {
  */
 interface ConfiguratorMarketingProvider {
     listPlanMarketing(): ConfiguratorPlanMarketing[];
-    getVatRate(): number;
+    /**
+     * The rate the configurator shows. Required where config/saas.yaml names no
+     * tax adapter; left out where it names one, whose rate for a subscriber in
+     * the issuer's country is shown instead.
+     */
+    getVatRate?(): number;
     getCurrency(): string;
 }
 /**
@@ -8360,6 +10670,13 @@ interface RegistrationBillingDetails {
     country: string;
     vatId?: string | null;
     taxNumber?: string | null;
+    /**
+     * Whether the sign-up is a business. A tax adapter decides from it — a
+     * business elsewhere in the European Union, for instance, is charged under
+     * the reverse charge — and refuses the step where it needs it and it is
+     * missing.
+     */
+    business?: boolean | null;
 }
 interface StartCheckoutInput {
     pendingRegistrationId: string;
@@ -8561,6 +10878,10 @@ type IssuerIdentityChange =
  */
 declare function classifyIssuerChange(recorded: LegalIdentity | null, issuer: PlanCatalogIssuer | undefined): IssuerIdentityChange;
 
+/** Every origin a charge may name, as a record or a line that copies one is checked against. */
+declare const SUBSCRIBER_CHARGE_ORIGINS: readonly SubscriberChargeOrigin[];
+/** Every source a charge may name. */
+declare const SUBSCRIBER_CHARGE_SOURCES: readonly SubscriberChargeSource[];
 /**
  * A `subscriber_ledger_entries` row as either adapter reads it back. The amount
  * is `unknown` because a Prisma row carries a `Decimal` where a Drizzle row
@@ -8602,6 +10923,252 @@ declare function subscriberChargeColumns(charge: NewSubscriberCharge): Omit<Cano
     amountNet: string;
 };
 
+/**
+ * A `subscription_invoices` row as either adapter reads it back. Amounts are
+ * `unknown` because a Prisma row carries a `Decimal` where a Drizzle row carries
+ * a numeric string, and days because one carries a `Date` at midnight UTC where
+ * the other carries the text.
+ */
+interface CanonicalSubscriptionInvoiceRow {
+    id: string;
+    number: string;
+    numberPrefix: string;
+    numberYear: number;
+    numberSequence: number;
+    tenantId: string;
+    subscriberId: string;
+    subscriptionId: string;
+    contractId: string;
+    issuedAt: Date;
+    issueDate: unknown;
+    dueDate: unknown;
+    servicePeriodFrom: unknown;
+    servicePeriodUntil: unknown;
+    currency: string;
+    issuerParty: unknown;
+    subscriberParty: unknown;
+    footer: unknown;
+    taxTreatment: unknown;
+    taxes: unknown;
+    totalNet: unknown;
+    totalTax: unknown;
+    totalGross: unknown;
+    createdAt: Date;
+}
+/** A `subscription_invoice_lines` row as either adapter reads it back. */
+interface CanonicalSubscriptionInvoiceLineRow {
+    id: string;
+    invoiceId: string;
+    position: number;
+    chargeId: string;
+    contractLineItemId: string;
+    title: string;
+    origin: string;
+    source: string;
+    periodFrom: unknown;
+    periodUntil: unknown;
+    amountNet: unknown;
+    taxRate: unknown;
+}
+/** Reads an invoice row and its lines back as a record, the lines in their order. */
+declare function toSubscriptionInvoiceRecord(row: CanonicalSubscriptionInvoiceRow, lines: readonly CanonicalSubscriptionInvoiceLineRow[]): SubscriptionInvoiceRecord;
+/**
+ * The columns an invoice is written with: amounts as decimal strings of two
+ * places, as a charge's are, and days as their text, which each adapter turns
+ * into what its date column takes.
+ */
+interface SubscriptionInvoiceColumns {
+    number: string;
+    numberPrefix: string;
+    numberYear: number;
+    numberSequence: number;
+    tenantId: string;
+    subscriberId: string;
+    subscriptionId: string;
+    contractId: string;
+    issuedAt: Date;
+    issueDate: CalendarDay;
+    dueDate: CalendarDay;
+    servicePeriodFrom: CalendarDay;
+    servicePeriodUntil: CalendarDay;
+    currency: string;
+    issuerParty: SubscriptionInvoiceIssuer;
+    subscriberParty: SubscriptionInvoiceSubscriber;
+    footer: string[];
+    taxTreatment: Record<string, unknown>;
+    taxes: TaxAtRate[];
+    totalNet: string;
+    totalTax: string;
+    totalGross: string;
+}
+/** The columns a line is written with, in the form `SubscriptionInvoiceColumns` describes. */
+interface SubscriptionInvoiceLineColumns {
+    invoiceId: string;
+    position: number;
+    chargeId: string;
+    contractLineItemId: string;
+    title: string;
+    origin: string;
+    source: string;
+    periodFrom: CalendarDay;
+    periodUntil: CalendarDay;
+    amountNet: string;
+    taxRate: string;
+}
+/** The columns an invoice is written with, given the number the store drew. */
+declare function subscriptionInvoiceColumns(invoice: NewSubscriptionInvoice, drawn: {
+    number: string;
+    numberSequence: number;
+}): SubscriptionInvoiceColumns;
+/** The columns a line is written with. */
+declare function subscriptionInvoiceLineColumns(line: NewSubscriptionInvoiceLine, invoiceId: string): SubscriptionInvoiceLineColumns;
+/** A day as the `Date` at midnight UTC a Prisma `@db.Date` column takes. */
+declare function utcMidnightOf(day: CalendarDay): Date;
+
+/**
+ * A charge that already stands on an invoice: what the unique `chargeId` of
+ * the invoice lines answers when two runs issue the same charges at once. The
+ * invoice is not written and its number not drawn.
+ */
+declare function subscriptionInvoiceChargeInvoiced(chargeId: string): PersistenceRefusal;
+/**
+ * A rendering of an invoice's document whose checksum is not the one recorded
+ * or archived for it, refused: the first stays. Only the run replaces a
+ * recorded rendering, and only while nothing is archived (`SC-AUD-019`).
+ */
+declare function subscriptionInvoiceDocumentChanged(invoiceId: string, recorded: string, rendered: string): PersistenceRefusal;
+
+/** The charges one invoice issues: booked at the same moment under the same contract. */
+interface InvoiceGroup {
+    contractId: string;
+    bookedAt: Date;
+    charges: SubscriberChargeRecord[];
+}
+/**
+ * A subscription's charges left to invoice, as the invoices that issue them.
+ *
+ * The charges a billing period opens with are booked together and issued
+ * together; a charge that arises later in the period is booked when it arises
+ * and issued on an invoice of its own (`SC-PRIC-022`). A contract is the
+ * agreement an invoice asks payment under, so charges of two contracts are
+ * never on one invoice. The oldest come first, so numbers follow the charges.
+ * A group whose charges are all zero issues no invoice (`SC-PRIC-048`) and is
+ * left out; a charge of zero beside one that is not stays on its invoice.
+ */
+declare function invoiceGroupsOf(charges: readonly SubscriberChargeRecord[]): InvoiceGroup[];
+/** What an invoice is drawn up from. */
+interface InvoiceDraftInput {
+    group: InvoiceGroup;
+    /** The contract the group's charges belong to: where each line takes its title and place. */
+    contractLines: readonly Pick<ContractLineItemRecord, 'id' | 'titleSnapshot'>[];
+    tenantId: string;
+    subscriberId: string;
+    subscriber: SubscriptionInvoiceSubscriber;
+    issuer: SubscriptionInvoiceIssuer;
+    /** The footer lines `config/saas.yaml` names now (`SC-PRIC-077`). */
+    footer: readonly string[];
+    /** The treatment the tax adapter decides for the subscriber now (`SC-PRIC-043`). */
+    treatment: TaxTreatment;
+    /** The adapter's rule for the tax of an invoice (`SC-PRIC-041`). */
+    tax: (lines: readonly InvoiceTaxLine[]) => TaxPerRate;
+    issuedAt: Date;
+    /** The installation's time zone, which every day the invoice states is read in (`SC-PRIC-045`). */
+    timeZone: string;
+    numberPrefix: string;
+    /** Days from the issue date to the due date (`SC-PRIC-046`). */
+    paymentTermDays: number;
+}
+/**
+ * The invoice `input.group` makes. Its lines follow the contract's lines, so
+ * the invoice reads in the order the contract does, each naming its charge and
+ * its contract line (`SC-AUD-013`) and taking the contract line's title. Every
+ * line carries the treatment's rate, and the tax is the adapter's, computed
+ * once per rate over the lines' net amounts.
+ *
+ * Throws where the charges contradict each other — a currency or a contract
+ * line the group cannot have — which no invoice can be drawn up from.
+ */
+declare function draftSubscriptionInvoice(input: InvoiceDraftInput): NewSubscriptionInvoice;
+/** What the tax adapter checks of an invoice before its number is drawn (`SC-PRIC-027`). */
+declare function invoiceContentDraftOf(invoice: NewSubscriptionInvoice): InvoiceContentDraft;
+
+/** A recorded settings change, as far as the issuer's history needs it. */
+type IssuerHistoryStep = Pick<SettingsChangeRecord, 'previous' | 'current'>;
+/**
+ * The issuer an invoice of a contract names.
+ *
+ * `copy` is the issuer the contract copied when it was concluded; `configured`
+ * the issuer `config/saas.yaml` names on the issue date, as a contract would
+ * copy it now (`contractPartiesOf`), or `null` where it names none; `history`
+ * the recorded settings changes, the oldest first.
+ */
+declare function invoiceIssuerOf(copy: ContractIssuerParty, configured: ContractIssuerParty | null, history: readonly IssuerHistoryStep[]): SubscriptionInvoiceIssuer;
+/**
+ * The footer lines an invoice carries (`SC-PRIC-077`): those `config/saas.yaml`
+ * names, where the invoice names the issuer the file names; none where it names
+ * the contract's copy of another entity, whose register and account the lines
+ * are not.
+ */
+declare function invoiceFooterOf(issuer: SubscriptionInvoiceIssuer, configured: ContractIssuerParty | null, footer: readonly string[]): string[];
+
+/** A `subscription_invoice_documents` row as either adapter reads it back. */
+interface CanonicalSubscriptionInvoiceDocumentRow {
+    invoiceId: string;
+    checksum: string;
+    mediaType: string;
+    fileName: string;
+    size: unknown;
+    renderedAt: Date;
+    archivedAt: Date | null;
+    deliveryClaimedAt: Date | null;
+    deliveredAt: Date | null;
+    deliveredTo: string | null;
+}
+/** A `subscription_invoice_archive` row as either adapter reads it back. */
+interface CanonicalSubscriptionInvoiceArchiveRow {
+    invoiceId: string;
+    checksum: string;
+    mediaType: string;
+    fileName: string;
+    content: Uint8Array;
+    archivedAt: Date;
+}
+/** Whether `value` is a checksum as the platform records one. */
+declare function isInvoiceDocumentChecksum(value: unknown): value is string;
+declare function toSubscriptionInvoiceDocumentRecord(row: CanonicalSubscriptionInvoiceDocumentRow): SubscriptionInvoiceDocumentRecord;
+declare function toArchivedInvoiceDocument(row: CanonicalSubscriptionInvoiceArchiveRow): ArchivedInvoiceDocument;
+/**
+ * The triggers of `subscription_invoice_archive` that keep a document as it
+ * was issued (`1.0-an-invoice-document-is-archived.postgres.sql`): one refuses
+ * every update and delete of a row, the other every truncate of the table.
+ */
+declare const INVOICE_ARCHIVE_TRIGGERS: readonly ["subscription_invoice_archive_is_kept", "subscription_invoice_archive_is_not_emptied"];
+/**
+ * Why the database archive would let a document be changed, given the
+ * triggers that fire on its table, or `null` where both of its own do. Shared
+ * by both adapters, which read the enabled triggers from the catalogue.
+ *
+ * A database created from the fragments by `db push` alone, or a migration run
+ * before the table existed, has none: the triggers are SQL the Prisma DSL
+ * cannot express.
+ */
+declare function invoiceArchiveProtectionProblem(enabledTriggers: readonly string[]): string | null;
+
+/** The VAT category of EN 16931 (UNTDID 5305) a line and a breakdown name. */
+type VatCategory = 'S' | 'E' | 'AE' | 'O';
+/** The category EN 16931 names for a treatment an adapter decides. */
+declare function vatCategoryOf(kind: TaxTreatmentKind): VatCategory;
+/** Whether `text` can stand in an XML document as it is. */
+declare function holdsOnlyXmlCharacters(text: string): boolean;
+/**
+ * `text` as an e-invoice's XML states it, which is what every XML parser reads
+ * back from it: a character XML cannot hold becomes `?`, as the page shows a
+ * character its font has no glyph for (`SC-PRIC-078`), and a carriage return
+ * is the line feed XML 1.0 hands over in its place (§ 2.11). The renderer
+ * writes this, and the adapter's check compares the record through it.
+ */
+declare function asXmlReadsIt(text: string): string;
+
 /** A `subscribers` row as either adapter reads it back. */
 interface CanonicalSubscriberRow {
     id: string;
@@ -8616,10 +11183,21 @@ interface CanonicalSubscriberRow {
     vatId: string | null;
     taxNumber: string | null;
     invoiceEmail: string | null;
+    business: boolean | null;
     migrated: boolean;
     createdAt: Date;
     updatedAt: Date;
 }
+/** A `subscriber_tax_origin_changes` row as either adapter reads it back. */
+interface CanonicalSubscriberTaxOriginChangeRow {
+    id: string;
+    subscriberId: string;
+    previous: unknown;
+    changed: unknown;
+    changedBy: string;
+    changedAt: Date;
+    reason: string | null;
+}
 /** A `subscriber_corrections` row as either adapter reads it back. */
 interface CanonicalSubscriberCorrectionRow {
     id: string;
@@ -8639,6 +11217,7 @@ declare function formatCustomerNumber(prefix: string, sequence: number): string;
 /** `tenantId` is the tenant the subscriber's live link names, read beside the row. */
 declare function toSubscriberRecord(row: CanonicalSubscriberRow, tenantId: string | null): SubscriberRecord;
 declare function toSubscriberCorrectionRecord(row: CanonicalSubscriberCorrectionRow): SubscriberCorrectionRecord;
+declare function toSubscriberTaxOriginChangeRecord(row: CanonicalSubscriberTaxOriginChangeRow): SubscriberTaxOriginChangeRecord;
 /**
  * The part of a correction that changes something: every corrected field whose
  * stored value differs, with the value it replaces. Both adapters decide this
@@ -8656,7 +11235,7 @@ declare function contractPartiesOf(subscriber: SubscriberRecord, issuer: PlanCat
  * verified with as its invoice email, and the billing address and tax
  * identifiers step 4 took.
  */
-declare function subscriberFromRegistration(pending: Pick<PendingRegistration, 'tenantName' | 'email' | 'addressLine1' | 'addressLine2' | 'postalCode' | 'city' | 'country' | 'vatId' | 'taxNumber'>): NewSubscriberDetails;
+declare function subscriberFromRegistration(pending: Pick<PendingRegistration, 'tenantName' | 'email' | 'addressLine1' | 'addressLine2' | 'postalCode' | 'city' | 'country' | 'vatId' | 'taxNumber' | 'business' | 'vatIdCheck'>): NewSubscriberDetails;
 
 /** The payment method types, in the order a form offers them. */
 declare const PAYMENT_METHOD_TYPES: readonly PaymentMethodType[];
@@ -8733,9 +11312,10 @@ declare function refuseForeignPaymentMethodReference(recorded: Pick<CanonicalSub
 /**
  * A `subscription_bundles` row as either adapter reads it back.
  *
- * The three billing columns are optional because a Prisma client generated from
- * a schema that predates them returns a row without them; an absent column
- * reads as null, the same as a booking made before they existed.
+ * The three billing columns and the two of a scheduled switch are optional
+ * because a Prisma client generated from a schema that predates them returns a
+ * row without them; an absent column reads as null, the same as a booking made
+ * before they existed.
  */
 interface CanonicalSubscriptionBundleRow {
     id: string;
@@ -8746,6 +11326,8 @@ interface CanonicalSubscriptionBundleRow {
     billingCycle?: string | null;
     currentPeriodStart?: Date | null;
     currentPeriodEnd?: Date | null;
+    pendingBundleVersionId?: string | null;
+    pendingVersionEffectiveAt?: Date | null;
     canceledAt: Date | null;
     canceledEffectiveAt: Date | null;
     createdAt: Date;
@@ -8769,6 +11351,8 @@ interface CanonicalContractRow {
     subscriberSnapshot: unknown;
     issuerSnapshot: unknown;
     partiesMigrated: boolean;
+    /** JSON; see `toTaxTreatment`. */
+    taxTreatment: unknown;
     status: string;
     effectiveFrom: Date;
     effectiveUntil: Date | null;
@@ -8823,6 +11407,100 @@ interface CanonicalRunningContractRow {
 /** One running contract, and the legal name on its issuer copy where it has one. */
 declare function toRunningContractIssuer(row: CanonicalRunningContractRow): RunningContractIssuer;
 
+/**
+ * A VAT identification number in the one form it is stored, compared and
+ * checked in: upper case, without the spaces, dots and hyphens it is often
+ * written with. `atu 123.456-78` is `ATU12345678` — the same number, so
+ * entering it in another spelling moves nothing. `null` where nothing is left.
+ * The platform settles every number it is given with this, and a form that
+ * asks whether a number changed compares with it too.
+ */
+declare function canonicalVatId(written: string): string | null;
+/** A `subscriber_vat_id_checks` row as either adapter reads it back. */
+interface CanonicalSubscriberVatIdCheckRow {
+    id: string;
+    subscriberId: string;
+    vatId: string;
+    checkedAt: Date;
+    valid: boolean;
+    service: string;
+    confirmation: unknown;
+    recordedAt: Date;
+}
+/**
+ * What an adapter decides a subscriber's treatment from: the record as it
+ * stands, and the check that counts for its number now. The number counts as
+ * validated only when that check is of the number the subscriber has and found
+ * it valid.
+ */
+declare function taxOriginOf(subscriber: Pick<SubscriberRecord, SubscriberTaxOriginField>, currentCheck: VatIdCheck | null): SubscriberTaxOrigin;
+/** The subscriber's number, and since when it holds it. */
+interface HeldVatId {
+    vatId: string | null;
+    /**
+     * When the number was last set by a correction; `null` while it is the one
+     * the subscriber was created with.
+     */
+    vatIdSince: Date | null;
+}
+/**
+ * Whether a check just recorded is the one that counts from now on, given the
+ * subscriber's number and the check that counts now. Only a check of the
+ * number the subscriber holds, completed while it held it, and never over a
+ * check that completed later:
+ *
+ * - A check completed before the number was last set says nothing about it:
+ *   the number was away in between, and may have been revoked meanwhile.
+ * - Two checks of one number can run side by side, and the one written last
+ *   is not the latest — an older "valid" written after a newer "invalid" would
+ *   validate a number the latest check refused. Of two checks with the same
+ *   date, the one written last counts.
+ *
+ * `vatIdSince` and `checkedAt` are both the platform's clock; between two
+ * instances, the window this leaves is the difference between their clocks.
+ */
+declare function keepsVatIdCheck(held: HeldVatId, counting: VatIdCheck | null, check: VatIdCheck): boolean;
+/** A recorded check read back; a confirmation of another shape reads as empty. */
+declare function toSubscriberVatIdCheckRecord(row: CanonicalSubscriberVatIdCheckRow): SubscriberVatIdCheckRecord;
+/** A treatment as it is stored on a contract. */
+declare function taxTreatmentToJson(treatment: TaxTreatment): Record<string, unknown>;
+/** A stored treatment read back, or `null` where none is stored or it has another shape. */
+declare function toTaxTreatment(value: unknown): TaxTreatment | null;
+/** What a write moves of a subscriber's tax origin, and what follows from it. */
+interface TaxOriginWrite {
+    /** The values the write replaces, holding only the fields it moves. */
+    previous: SubscriberTaxOriginValues;
+    /** The values it writes, holding only the fields it moves. */
+    changed: SubscriberTaxOriginValues;
+    /** Whether it moves anything, and so has a change to record. */
+    moved: boolean;
+    /**
+     * Whether it moves the VAT identification number. The check that counted
+     * for the old number then counts no more — it says nothing about the new
+     * one, nor about the old one should it come back later — while the check
+     * itself stays recorded; and the number held is held since this write
+     * (`HeldVatId.vatIdSince`).
+     */
+    endsCountingVatIdCheck: boolean;
+}
+/**
+ * What a write moves of the tax origin: every field named whose stored value
+ * differs, with the value it replaces. Every adapter asks this under the lock
+ * it read `current` with, and applies the answer: a change is recorded only
+ * when it moved something.
+ */
+declare function taxOriginWrite(current: Pick<SubscriberRecord, SubscriberTaxOriginField>, next: SubscriberTaxOriginValues): TaxOriginWrite;
+/** Stored tax origin values read back, holding only the fields that are there. */
+declare function toTaxOriginValues(value: unknown): SubscriberTaxOriginValues;
+/**
+ * A check of a VAT identification number as a store gives it back. A sign-up
+ * keeps its check where the application's repository puts it — often a JSON
+ * column, which hands `checkedAt` back as text — so it is read again here,
+ * once. Anything that is not a whole check reads as none: a number never
+ * counts as validated on a record that cannot say so.
+ */
+declare function vatIdCheckFromStore(value: unknown): VatIdCheck | null;
+
 /** Why a version is editable (for UI badges + audit logs). */
 type VersionEditableReason = 'draft' | 'pre-active';
 interface VersionEditability {
@@ -8904,4 +11582,4 @@ declare function resolveErrorMessage(body: ResolvableErrorBody, overrides?: Part
 
 declare const ERROR_MESSAGES_DE: Record<PlatformErrorCode, string>;
 
-export { ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES, AUTH_ERROR_CODES, type ActionKey, type ActivationOrchestrator, type ActivePlanVersionWhere, type ActivePlanVersionWhereWithEndsAt, type ActiveVersionWhere, type ActiveVersionWhereWithEndsAt, type ActorTag, type AdminAccountEntry, type AdminAccountHolder, type AdminActor, type AdminAuditListFilter, type AdminManifest, type AdminResourcesPort, type AdminSubscriberAccount, type AdminSubscriptionListRow, type AdminTenantDetail, type AdminTenantListFilter, type AdminTenantListRow, type AdminTenantStateResult, type AdminUserListFilter, type AdminUserListRow, type AppliedSettingsPort, type AppliedSettingsRecord, type AppliedSettingsValues, type ApplyOnboardingSelectionInput, type ApplyOnboardingSelectionResult, type ApprovedCatalogKeys, type AuditActionDef, type AuditActor, type AuditEntry, type AuditPort, type AuditQuery, type AuditQueryPort, type AuditStatsPort, type AuditStatsSnapshot, type AuthErrorCode, BILLING_ERROR_CODES, BUNDLE_PRICE_LOOKUP_LIMIT, type BillingCycle, type BillingErrorCode, type BundleAvailabilityState, type BundleCompatibility, type BundleFeatureShape, type BundleListFilter, type BundlePricingOverride, type BundleRepository, type BundleRow, type BundleVersionFields, type BundleVersionMutationResult, type BundleVersionRow, CATALOGUE_KEYS, CATALOG_ERROR_CODES, CONTRACT_ERROR_CODES, CUSTOM_LIMITS_KEYS, type CancelSubscriptionBundleData, type CancelSubscriptionInput, type CancelSubscriptionResult, type CancellationNoticePeriods, type CanonicalContractLineItemRow, type CanonicalContractRow, type CanonicalMaintenanceWindowRow, type CanonicalPlanRow, type CanonicalPlanVersionRow, type CanonicalRunningContractRow, type CanonicalSubscriberChargeRow, type CanonicalSubscriberCorrectionRow, type CanonicalSubscriberPaymentMethodRow, type CanonicalSubscriberRow, type CanonicalSubscriptionBundleRow, type CanonicalSubscriptionNoticeRow, type CanonicalVersionRetirementRow, type CapabilityCatalogEntryRow, type CapabilityCodeStatus, type CapabilityKey, type CapabilityKind, type CatalogEntryFilter, type CatalogEntryI18n, type CatalogEntryI18nFields, type CatalogEntryRepository, type CatalogErrorCode, type CatalogVersionKind, type ChangeDirection, type CheckoutOfferFilter, type CheckoutOfferLineItem, type CheckoutOfferLineItemKind, type CheckoutOfferPriceBreakdown, type CheckoutOfferPromoCodeSnapshot, type CheckoutOfferPromotionSnapshot, type CheckoutOfferRepository, type CheckoutOfferRow, type CheckoutOfferSelection, type CheckoutOfferSelectionUpdate, type CheckoutOfferStatus, type CleanupResult, type CliUserRow, type ComponentKey, type ConcurrencyGate, type ConfiguratorCatalog, type ConfiguratorMarketingProvider, type ConfiguratorModel, type ConfiguratorPlanMarketing, type ConfiguratorPlanVersionRow, type ConfiguratorPriceBreakdown, type ConfiguratorSourcesLookup, type ConfirmedPaymentMethod, type ContractErrorCode, type ContractIssuerParty, type ContractLineItemKind, type ContractLineItemRecord, type ContractSubscriberParty, type CreateBundleData, type CreateBundleVersionDraftData, type CreateCheckoutOfferData, type CreateMarketingProjectionData, type CreatePlanData, type CreatePlanVersionDraftData, type CreatePromoCodeData, type CreatePromoCodeRequest, type CreatePromotionData, type CreateSubscriberData, type CreateSubscriptionBundleData, type CreateSubscriptionContractData, type CreateSuperAdminCliInput, type CreateTenantInput, type CustomLimits, type DiffResult, type DiscoveredCapability, type DiscoveredFeature, type DiscoveredQuota, type DiscoveredQuotaPolicy, type DiscoveryCodeStatus, type DiscoverySnapshot, type DiscoveryStatus, ERROR_MESSAGES_DE, ERROR_MESSAGES_EN, type EffectiveLimitsSnapshot, type EmailPort, type ErrorMessageParams, FEATURE_NOT_LICENSED, type FeatureCatalogEntryRow, type FeatureDef, type FeatureKey, type FeatureNotLicensedBody, type FeatureRequiresIndex, type FeatureTier, type FeatureUiMeta, type FeatureUiRegistry, type FinalActivationResult, type FirstTimeCustomerCheck, ForeignPaymentMethodReferenceError, type ImmediatePlanChangeInput, type InvoiceLineItemSnapshot, type IssuerCorrectionFault, type IssuerIdentityChange, type KpiCardDef, type KpiDisplayHint, LEGAL_IDENTITY_FIELDS, type LegalIdentity, type LegalIdentityField, MAINTENANCE_CAPABILITY, MAINTENANCE_ERROR_CODES, MAINTENANCE_MESSAGE_MAX_LENGTH, MAINTENANCE_STATE_MAX_AGE_SECONDS, MARKETING_PRIORITY_MAX, MARKETING_PRIORITY_MIN, type MaintenanceErrorCode, type MaintenanceLockView, type MaintenanceNotificationPort, type MaintenanceOverview, type MaintenanceStatusView, type MaintenanceUnlockView, type MaintenanceWindowChanges, type MaintenanceWindowEvent, type MaintenanceWindowPort, type MaintenanceWindowRecord, type MaintenanceWindowStage, type MaintenanceWindowStatus, type MaintenanceWindowView, type ManifestAccessPort, type ManifestContribution, type MarketingProjectionFilter, type MarketingProjectionRepository, type MarketingProjectionRow, type MarketingSettingsRepository, type MarketingSettingsRow, type MarketingTargetType, type MarketingTopFeature, type MaskedPaymentMethod, type MfaPort, NO_SCHEDULED_CHANGE, type NewContractLineItemData, type NewMaintenanceWindow, type NewSettingsChange, type NewSubscriberCharge, type NewSubscriberDetails, type NewSubscriptionContractData, type NewVersionRetirement, type NoticeToRecord, OPTIONAL_CANONICAL_MODELS, OTP_RATE_LIMIT_MAX_SENDS, OTP_RATE_LIMIT_WINDOW_MINUTES, OTP_TTL_MINUTES, OTP_VERIFY_MAX_ATTEMPTS, type OnboardingPromoRedemption, type OnboardingSelectionRequest, type OnboardingSelectionResponse, type OptionalBundleMember, type OptionalCanonicalModel, type OrderlyRetirementSettings, PASSWORD_RESET_TTL_MINUTES, PAYMENT_ERROR_CODES, PAYMENT_METHOD_TYPES, PENDING_CHECKOUT_TTL_DAYS, PENDING_EMAIL_TTL_HOURS, PENDING_ONBOARDING_TTL_DAYS, PLATFORM_ERROR_CODES, PROMO_ERROR_CODES, type Paginated, type PartyAddress, type PasswordHasher, type PasswordResetCliResult, PaymentCallbackRejectedError, type PaymentErrorCode, type PaymentEventClaim, type PaymentEventLog, type PaymentGateway, type PaymentGatewayCallback, type PaymentGatewayEvent, type PaymentMethodHolder, type PaymentMethodSetupSession, type PaymentMethodSetupSubject, type PaymentMethodType, type PendingRegistration, type PendingRegistrationCreateInput, type PendingRegistrationRepository, type PendingRegistrationSnapshot, type PendingRegistrationUpdateInput, type PersistenceCapabilities, PersistenceCapabilityError, type PersistenceClassRef, type PersistenceInjectionToken, type PersistenceProvider, PersistenceRefusal, type PersistenceRefusalReason, type PlanCatalog, type PlanCatalogApp, type PlanCatalogImportReport, type PlanCatalogImportSink, type PlanCatalogIssuer, type PlanCatalogIssuerCorrection, type PlanCatalogLookup, type PlanCatalogMarketing, type PlanCatalogNotifications, type PlanCatalogPaymentAccount, type PlanCatalogPayments, type PlanCatalogReadSink, type PlanCatalogReadSnapshot, type PlanCatalogSettings, type PlanCatalogSubscribers, type PlanCatalogTenantBilling, type PlanDef, type PlanId, type PlanListFilter, type PlanRepository, type PlanRow, type PlanVersion, type PlanVersionFields, type PlanVersionMutationResult, type PlanVersionRecord, type PlanVersionRepository, type PlanVersionRow, type PlatformErrorBody, type PlatformErrorCode, type PlatformJobActor, type PlatformRole, type PlatformUserDto, PlatformUserExistsError, type ProjectPageDef, type PromoCode, type PromoCodeDurationType, type PromoCodeFilter, type PromoCodeHoldRecord, type PromoCodeHoldRepository, type PromoCodeHoldTaken, type PromoCodeRecord, type PromoCodeRedemption, type PromoCodeRedemptionListItem, type PromoCodeRedemptionRecord, type PromoCodeRedemptionRepository, type PromoCodeRedemptionStatus, type PromoCodeRepository, type PromoCodeStatsPort, type PromoCodeStatsSnapshot, type PromoCodeStatus, type PromoCodeValidationLog, type PromoCodeValidationLogRepository, type PromoCodeValidationResult, type PromoCodeValueType, type PromoErrorCode, type PromoPreviewInvalidReason, type PromoPreviewRequest, type PromoPreviewResponse, type PromoPreviewValidResponse, type PromoRevenueDeductionAggregator, type PromoSubscriptionLookup, type PromotionBillingCycle, type PromotionI18n, type PromotionI18nFields, type PromotionOnPrice, type PromotionRepository, type PromotionResult, type PromotionRow, type PromotionStatus, type PromotionTargetType, type PromotionType, type PromotionValue, type PublicBootResponse, type PublicComparisonRow, type PublicMarketingBundle, type PublicMarketingCatalogResponse, type PublicMarketingPlan, type PublicMarketingPromo, type PublicNewPaymentMethods, type PublicSignupPlan, type PublishBundleVersionData, type PublishBundleVersionMeta, type PublishPlanVersionData, type QuotaCatalogEntryRow, type QuotaEnforcementMode, type QuotaKey, type QuotaProvider, REGISTRATION_ERROR_CODES, REGISTRATION_RESUME_TTL_MINUTES, REGISTRATION_STEP_BY_STATUS, RETIREMENT_REMINDER_LEAD_DAYS, type ReadCustomLimits, type ReassignTenantAdminCliResult, type RecommendablePlan, type RecordSubscriberPaymentMethodData, type RecordSubscriberPaymentMethodOutcome, type RecordSubscriberPaymentMethodResult, type RedeemPromoInTransactionCallback, type RegistrationActivation, type RegistrationAuditContext, type RegistrationAuditEvent, type RegistrationAuditEventType, type RegistrationAuditLogger, type RegistrationBillingDetails, type RegistrationConfigSelection, type RegistrationConfiguratorLookup, type RegistrationErrorCode, type RegistrationOtpDelivery, type RegistrationPromoPreview, type RegistrationResumeDelivery, type RegistrationResumeTokenSigner, type RegistrationStatus, type RegistrationStep, type RequiredCapabilities, type ResolvableErrorBody, type ResumeRegistrationInput, type ResumeRegistrationResult, type RetiredVersionRef, type RetirementAnnounced, type RetirementBlocker, type RetirementMoveRun, type RetirementPreview, type RetirementProgress, type RetirementReachedRow, type RetirementSide, type RetirementSkipReason, type RetirementSkippedRow, type RetirementSwitchResult, type RetirementSwitchTerms, type ReviewCatalogEntryData, type RlsBypassPort, type RunningContractIssuer, type RunningContractIssuers, SETTINGS_ERROR_CODES, SETUP_ERROR_CODES, SUBSCRIBER_ACCOUNT_CAPABILITY, SUBSCRIBER_ERROR_CODES, type SaaSiCatPersistenceAdapter, type SaaSiCatPersistenceAdminResources, type SaaSiCatPersistenceCatalog, type SaaSiCatPersistenceCore, type SaaSiCatPersistenceEntitlement, type SaaSiCatPersistencePayments, type SaaSiCatPersistencePromo, type SaaSiCatPersistenceTenantBilling, type SaveRegistrationConfigInput, type SaveRegistrationConfigResult, type ScheduledChangeColumns, type ScheduledPlanChangeInput, type SecretSealer, type SelectPlanInput, type SelectPlanResult, type SelectableBundleShape, type SelfServiceBlockedPlans, type SetCatalogEntryReviewData, type SettingsChangeFilter, type SettingsChangeRecord, type SettingsDifference, type SettingsErrorCode, type SetupConfirmMfaRequest, type SetupConfirmMfaResponse, type SetupErrorCode, type SetupRequest, type SetupResult, type SetupStatusResponse, type SlugAvailabilityCheck, type StandardPageDef, type StandardPageKey, type StartCheckoutInput, type StartCheckoutResult, type StartPaymentMethodSetupInput, type StartRegistrationInput, type StartRegistrationResult, type StoredBundleStem, type StrictModeWarning, type StrictModeWarningCode, type SubscriberCharge, type SubscriberChargeOrigin, type SubscriberChargeRecord, type SubscriberChargeSource, type SubscriberContact, type SubscriberContactChange, type SubscriberCorrectionData, type SubscriberCorrectionRecord, type SubscriberCorrectionResult, type SubscriberDetails, type SubscriberErrorCode, type SubscriberIdentityCorrection, type SubscriberIdentityDelta, type SubscriberIdentityValues, type SubscriberLedgerRepository, type SubscriberPaymentMethodRecord, type SubscriberPaymentMethodReference, type SubscriberPaymentMethodRepository, type SubscriberPaymentMethodSetupData, type SubscriberPaymentMethodSetupMatch, type SubscriberPaymentMethodStatus, type SubscriberRecord, type SubscriberRepository, type Subscription, type SubscriptionBundleRecord, type SubscriptionBundleRepository, type SubscriptionBundleView, type SubscriptionContractFilter, type SubscriptionContractInvoiceSnapshot, type SubscriptionContractParties, type SubscriptionContractPriceSnapshot, type SubscriptionContractRecord, type SubscriptionContractRepository, type SubscriptionContractStatus, type SubscriptionNotice, type SubscriptionNoticeDelivery, type SubscriptionNoticeKey, type SubscriptionNoticeKind, type SubscriptionNoticePort, type SubscriptionNoticeRecord, type SubscriptionNoticeRepository, type SubscriptionRecord, type SubscriptionRepository, type SubscriptionStatsPort, type SubscriptionStatsSnapshot, type SubscriptionStatus, type SubscriptionUsagePort, type SubscriptionUsageRecord, type SuperAdminProvisioningPort, type SupersedeSubscriptionContractData, type SyncDiscoveryResult, type TenantActionDef, type TenantColumnDef, type TenantDto, type TenantListFilter, type TenantPort, type TenantSubscriptionUsage, type TenantSubscriptionWritePort, type TerminateSubscriptionContractData, type TopPromoCode, type TransactionContext, type TransactionRunner, type UpdateBundleData, type UpdateBundleVersionDraftData, type UpdateCatalogEntryBaseData, type UpdateCatalogEntryI18nData, type UpdateCheckoutOfferData, type UpdateMarketingProjectionData, type UpdateMarketingSettingsData, type UpdatePlanData, type UpdatePlanVersionDraftData, type UpdatePromoCodeData, type UpdatePromoCodeRequest, type UpdatePromotionData, type UpsellOffer, type UpsellOfferResolver, type UpsertCapabilityEntryData, type UpsertFeatureCatalogEntryInput, type UpsertFeatureEntryData, type UpsertPlanInput, type UpsertPlanVersionInput, type UpsertQuotaEntryData, type UpsertResult, type UsageSnapshotPort, type UserAccountLookup, type UserListFilter, type UserManagementPort, type UserPort, VERSION_RETIREMENT_CAPABILITY, type VerifyRegistrationOtpResult, type VersionChange, type VersionChangeDirection, type VersionEditability, type VersionEditableReason, type VersionOffer, type VersionOfferClass, type VersionOfferFields, type VersionOfferSide, type VersionOfferView, type VersionOfferedNotice, type VersionRetiredNotice, type VersionRetirementRecord, type VersionRetirementReminder, type VersionRetirementRepository, type VersionRetirementView, type VersionSale, type VersionSaleDates, type VersionSaleKind, type VersionSwitchResult, type VersionWindow, type VersionedEntityBase, applyPromo, assertPersistenceCapabilities, buildActivePlanVersionWhere, buildActiveVersionWhere, buildFeatureRequiresIndex, bundleDraftDefaults, bundleKeyTaken, bundleStemDefaults, canonicalJson, catalogDraftExists, catalogVersionAlreadyPublished, catalogVersionGone, classifyBundleVersionDiff, classifyIssuerChange, classifyPlanDiff, classifyVersionOffer, collectUnsatisfiedRequires, computeIncludedVat, concurrencyGate, concurrencyGateOf, contractPartiesOf, coverageExcludingSelf, customLimitsReader, definedFields, diffSettings, formatCustomerNumber, formatErrorMessage, grossFromNet, identityCorrectionDelta, isBundleRedundant, isForeignPaymentMethodReferenceError, isMaintenanceAnnouncementLapsed, isMaintenanceOverrun, isPaymentCallbackRejectedError, isPersistenceRefusal, isPlatformUserExistsError, isVersionActiveAt, isVersionEditable, issuerIdentityOf, keepOneRecommended, maintenanceRetryAfterSeconds, maintenanceStatusOf, maintenanceWindowStatusOf, maintenanceWindowViewOf, marketingProjectionTaken, membersLeftOut, missingRequiresFor, movedIdentityFields, netFromGross, noActivePlanVersion, parseZonedInstant, percentOf, pickActivePromo, planCatalogSettingsOf, planKeyTaken, planNotInCatalog, previousUtcDay, promoCodeTaken, promoStatus, promotionOnPrice, prorate, readCustomLimits, readQuotaRecord, readQuotaValue, recordedIssuerIdentity, refuseForeignPaymentMethodReference, resolveBundleAvailability, resolveErrorMessage, retirementCostsTheSubscription, retirementReminderDueAt, retirementReminderIsDue, retirementSwitchTerms, roundToCents, sameLegalIdentity, scheduledChangeAfterWrite, selectChargeableBundles, settingsSubtreeOf, startOfUtcDay, subscriberChargeColumns, subscriberFromRegistration, subscriberPaymentMethodColumns, subscriptionBundleAlreadyCancelled, subscriptionBundleGone, subscriptionContractGone, subscriptionGone, sumToCents, toBundleStemRow, toCents, toContractLineItemRecord, toDecimalString, toMaintenanceWindowRecord, toPlanRow, toPlanVersionRow, toRunningContractIssuer, toSubscriberChargeRecord, toSubscriberCorrectionRecord, toSubscriberPaymentMethodRecord, toSubscriberRecord, toSubscriptionBundleRecord, toSubscriptionContractRecord, toSubscriptionNoticeRecord, toVersionRetirementRecord, versionOnSale, versionOnSaleOrNext, versionSale };
+export { ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES, AUTH_ERROR_CODES, type ActionKey, type ActivationOrchestrator, type ActivePlanVersionWhere, type ActivePlanVersionWhereWithEndsAt, type ActiveVersionWhere, type ActiveVersionWhereWithEndsAt, type ActorTag, type AdminAccountEntry, type AdminAccountHolder, type AdminActor, type AdminAuditListFilter, type AdminManifest, type AdminResourcesPort, type AdminSubscriberAccount, type AdminSubscriberAttention, type AdminSubscriberCorrected, type AdminSubscriberHistoryEntry, type AdminSubscriptionListRow, type AdminTenantDetail, type AdminTenantListFilter, type AdminTenantListRow, type AdminTenantStateResult, type AdminTenantSubscriber, type AdminUserListFilter, type AdminUserListRow, type AdminVatIdCheckOutcome, type AppliedSettingsPort, type AppliedSettingsRecord, type AppliedSettingsValues, type ApplyOnboardingSelectionInput, type ApplyOnboardingSelectionResult, type ApprovedCatalogKeys, type ArchivedInvoiceDocument, type AuditActionDef, type AuditActor, type AuditEntry, type AuditPort, type AuditQuery, type AuditQueryPort, type AuditStatsPort, type AuditStatsSnapshot, type AuthErrorCode, BILLING_ERROR_CODES, BUNDLE_PRICE_LOOKUP_LIMIT, BUNDLE_VERSION_RETIREMENT_CAPABILITY, type BillingCycle, type BillingErrorCode, type BundleAvailabilityState, type BundleCompatibility, type BundleFeatureShape, type BundleListFilter, type BundlePricingOverride, type BundleRepository, type BundleRetirementAnnounced, type BundleRetirementPreview, type BundleRetirementReachedRow, type BundleRetirementSkipReason, type BundleRetirementSkippedRow, type BundleRetirementSwitchResult, type BundleRetirementSwitchTerms, type BundleRow, type BundleVersionFields, type BundleVersionMutationResult, type BundleVersionOfferView, type BundleVersionOfferedNotice, type BundleVersionRetiredNotice, type BundleVersionRetirementRecord, type BundleVersionRetirementReminder, type BundleVersionRetirementRepository, type BundleVersionRetirementView, type BundleVersionRow, type BundleVersionSide, type BundleVersionSwitchResult, CATALOGUE_KEYS, CATALOG_ERROR_CODES, CONTRACT_ERROR_CODES, CUSTOM_LIMITS_KEYS, type CalendarDay, type CancelSubscriptionBundleData, type CancelSubscriptionInput, type CancelSubscriptionResult, type CancellationNoticePeriods, type CanonicalBundleVersionRetirementRow, type CanonicalContractLineItemRow, type CanonicalContractRow, type CanonicalFeatureWithdrawalRow, type CanonicalMaintenanceWindowRow, type CanonicalPlanRow, type CanonicalPlanVersionRow, type CanonicalRunningContractRow, type CanonicalSubscriberChargeRow, type CanonicalSubscriberCorrectionRow, type CanonicalSubscriberPaymentMethodRow, type CanonicalSubscriberRow, type CanonicalSubscriberTaxOriginChangeRow, type CanonicalSubscriberVatIdCheckRow, type CanonicalSubscriptionBundleRow, type CanonicalSubscriptionInvoiceArchiveRow, type CanonicalSubscriptionInvoiceDocumentRow, type CanonicalSubscriptionInvoiceLineRow, type CanonicalSubscriptionInvoiceRow, type CanonicalSubscriptionNoticeRow, type CanonicalVersionRetirementRow, type CapabilityCatalogEntryRow, type CapabilityCodeStatus, type CapabilityKey, type CapabilityKind, type CatalogEntryFilter, type CatalogEntryI18n, type CatalogEntryI18nFields, type CatalogEntryRepository, type CatalogErrorCode, type CatalogVersionKind, type ChangeDirection, type CheckoutOfferFilter, type CheckoutOfferLineItem, type CheckoutOfferLineItemKind, type CheckoutOfferPriceBreakdown, type CheckoutOfferPromoCodeSnapshot, type CheckoutOfferPromotionSnapshot, type CheckoutOfferRepository, type CheckoutOfferRow, type CheckoutOfferSelection, type CheckoutOfferSelectionUpdate, type CheckoutOfferStatus, type CleanupResult, type CliUserRow, type ComponentKey, type ConcurrencyGate, type ConfiguratorCatalog, type ConfiguratorMarketingProvider, type ConfiguratorModel, type ConfiguratorPlanMarketing, type ConfiguratorPlanVersionRow, type ConfiguratorPriceBreakdown, type ConfiguratorSourcesLookup, type ConfirmedPaymentMethod, type ContractErrorCode, type ContractIssuerParty, type ContractLineItemKind, type ContractLineItemRecord, type ContractSubscriberParty, type CreateBundleData, type CreateBundleVersionDraftData, type CreateCheckoutOfferData, type CreateMarketingProjectionData, type CreatePlanData, type CreatePlanVersionDraftData, type CreatePromoCodeData, type CreatePromoCodeRequest, type CreatePromotionData, type CreateSubscriberData, type CreateSubscriptionBundleData, type CreateSubscriptionContractData, type CreateSuperAdminCliInput, type CreateTenantInput, type CustomLimits, type DiffResult, type DiscoveredCapability, type DiscoveredFeature, type DiscoveredQuota, type DiscoveredQuotaPolicy, type DiscoveryCodeStatus, type DiscoverySnapshot, type DiscoveryStatus, ERROR_MESSAGES_DE, ERROR_MESSAGES_EN, type EffectiveLimitsSnapshot, type EmailPort, type EndAtOncePreview, type EndNowInput, type EndSubscriptionNowResult, type EndedAtOnce, type EndedAtOnceNotice, type ErrorMessageParams, FEATURE_NOT_LICENSED, FEATURE_WITHDRAWAL_CAPABILITY, FEATURE_WITHDRAWAL_REASON_MAX_LENGTH, type FeatureCatalogEntryRow, type FeatureDef, type FeatureKey, type FeatureNotLicensedBody, type FeatureRequiresIndex, type FeatureTier, type FeatureUiMeta, type FeatureUiRegistry, type FeatureWithdrawalAnnounced, type FeatureWithdrawalBlocker, type FeatureWithdrawalLift, type FeatureWithdrawalLifted, type FeatureWithdrawalLiftedNotice, type FeatureWithdrawalLine, type FeatureWithdrawalLineKind, type FeatureWithdrawalMark, type FeatureWithdrawalNoticeLine, type FeatureWithdrawalPreview, type FeatureWithdrawalReachedRow, type FeatureWithdrawalRecord, type FeatureWithdrawalReduction, type FeatureWithdrawalRepository, type FeatureWithdrawalRow, type FeatureWithdrawalSkippedRow, type FeatureWithdrawalTarget, type FeatureWithdrawalView, type FeatureWithdrawnNotice, type FinalActivationResult, type FirstTimeCustomerCheck, ForeignPaymentMethodReferenceError, type HeldVatId, INVOICE_ARCHIVE_TRIGGERS, INVOICE_DOCUMENT_CAPABILITY, INVOICE_ERROR_CODES, INVOICE_SEQUENCE_DIGITS, type ImmediatePlanChangeInput, type InvoiceArchivePort, type InvoiceContentDraft, type InvoiceDocument, type InvoiceDocumentToArchive, type InvoiceDraftInput, type InvoiceErrorCode, type InvoiceGroup, type InvoiceLineItemSnapshot, type InvoiceMail, type InvoiceMailPort, type InvoiceRenderer, type InvoiceTaxLine, type IssuerCorrectionFault, type IssuerHistoryStep, type IssuerIdentityChange, type KpiCardDef, type KpiDisplayHint, LEGAL_IDENTITY_FIELDS, type LegalIdentity, type LegalIdentityField, MAINTENANCE_CAPABILITY, MAINTENANCE_ERROR_CODES, MAINTENANCE_MESSAGE_MAX_LENGTH, MAINTENANCE_STATE_MAX_AGE_SECONDS, MARKETING_PRIORITY_MAX, MARKETING_PRIORITY_MIN, type MaintenanceErrorCode, type MaintenanceLockView, type MaintenanceNotificationPort, type MaintenanceOverview, type MaintenanceStatusView, type MaintenanceUnlockView, type MaintenanceWindowChanges, type MaintenanceWindowEvent, type MaintenanceWindowPort, type MaintenanceWindowRecord, type MaintenanceWindowStage, type MaintenanceWindowStatus, type MaintenanceWindowView, type ManifestAccessPort, type ManifestContribution, type MarketingProjectionFilter, type MarketingProjectionRepository, type MarketingProjectionRow, type MarketingSettingsRepository, type MarketingSettingsRow, type MarketingTargetType, type MarketingTopFeature, type MaskedPaymentMethod, type MfaPort, NO_SCHEDULED_CHANGE, type NewBundleVersionRetirement, type NewContractLineItemData, type NewFeatureWithdrawal, type NewInvoiceRendering, type NewMaintenanceWindow, type NewSettingsChange, type NewSubscriberCharge, type NewSubscriberDetails, type NewSubscriptionContractData, type NewSubscriptionInvoice, type NewSubscriptionInvoiceLine, type NewVersionRetirement, type NotToldReasons, type NoticeToRecord, OPTIONAL_CANONICAL_MODELS, OTP_RATE_LIMIT_MAX_SENDS, OTP_RATE_LIMIT_WINDOW_MINUTES, OTP_TTL_MINUTES, OTP_VERIFY_MAX_ATTEMPTS, type OnboardingPromoRedemption, type OnboardingSelectionRequest, type OnboardingSelectionResponse, type OptionalBundleMember, type OptionalCanonicalModel, type OrderlyRetirementSettings, PASSWORD_RESET_TTL_MINUTES, PAYMENT_ERROR_CODES, PAYMENT_METHOD_TYPES, PENDING_CHECKOUT_TTL_DAYS, PENDING_EMAIL_TTL_HOURS, PENDING_ONBOARDING_TTL_DAYS, PLATFORM_ERROR_CODES, PROMO_ERROR_CODES, type Paginated, type PartyAddress, type PasswordHasher, type PasswordResetCliResult, PaymentCallbackRejectedError, type PaymentErrorCode, type PaymentEventClaim, type PaymentEventLog, type PaymentGateway, type PaymentGatewayCallback, type PaymentGatewayEvent, type PaymentMethodHolder, type PaymentMethodSetupSession, type PaymentMethodSetupSubject, type PaymentMethodType, type PendingRegistration, type PendingRegistrationCreateInput, type PendingRegistrationRepository, type PendingRegistrationSnapshot, type PendingRegistrationUpdateInput, type PersistenceCapabilities, PersistenceCapabilityError, type PersistenceClassRef, type PersistenceInjectionToken, type PersistenceProvider, PersistenceRefusal, type PersistenceRefusalReason, type PlanCatalog, type PlanCatalogApp, type PlanCatalogImportReport, type PlanCatalogImportSink, type PlanCatalogInvoicing, type PlanCatalogIssuer, type PlanCatalogIssuerCorrection, type PlanCatalogLookup, type PlanCatalogMarketing, type PlanCatalogNotifications, type PlanCatalogPaymentAccount, type PlanCatalogPayments, type PlanCatalogReadSink, type PlanCatalogReadSnapshot, type PlanCatalogSettings, type PlanCatalogSubscribers, type PlanCatalogTax, type PlanCatalogTenantBilling, type PlanDef, type PlanId, type PlanListFilter, type PlanRepository, type PlanRow, type PlanVersion, type PlanVersionFields, type PlanVersionMutationResult, type PlanVersionRecord, type PlanVersionRepository, type PlanVersionRow, type PlatformErrorBody, type PlatformErrorCode, type PlatformJobActor, type PlatformRole, type PlatformUserDto, PlatformUserExistsError, type ProjectPageDef, type PromoCode, type PromoCodeDurationType, type PromoCodeFilter, type PromoCodeHoldRecord, type PromoCodeHoldRepository, type PromoCodeHoldTaken, type PromoCodeRecord, type PromoCodeRedemption, type PromoCodeRedemptionListItem, type PromoCodeRedemptionRecord, type PromoCodeRedemptionRepository, type PromoCodeRedemptionStatus, type PromoCodeRepository, type PromoCodeStatsPort, type PromoCodeStatsSnapshot, type PromoCodeStatus, type PromoCodeValidationLog, type PromoCodeValidationLogRepository, type PromoCodeValidationResult, type PromoCodeValueType, type PromoErrorCode, type PromoPreviewInvalidReason, type PromoPreviewRequest, type PromoPreviewResponse, type PromoPreviewValidResponse, type PromoRevenueDeductionAggregator, type PromoSubscriptionLookup, type PromotionBillingCycle, type PromotionI18n, type PromotionI18nFields, type PromotionOnPrice, type PromotionRepository, type PromotionResult, type PromotionRow, type PromotionStatus, type PromotionTargetType, type PromotionType, type PromotionValue, type PublicBootResponse, type PublicComparisonRow, type PublicMarketingBundle, type PublicMarketingCatalogResponse, type PublicMarketingPlan, type PublicMarketingPromo, type PublicNewPaymentMethods, type PublicSignupPlan, type PublishBundleVersionData, type PublishBundleVersionMeta, type PublishPlanVersionData, type QuotaCatalogEntryRow, type QuotaEnforcementMode, type QuotaKey, type QuotaProvider, REGISTRATION_ERROR_CODES, REGISTRATION_RESUME_TTL_MINUTES, REGISTRATION_STEP_BY_STATUS, RETIREMENT_REMINDER_LEAD_DAYS, type ReadCustomLimits, type ReassignTenantAdminCliResult, type RecommendablePlan, type RecordSubscriberPaymentMethodData, type RecordSubscriberPaymentMethodOutcome, type RecordSubscriberPaymentMethodResult, type RecordedVatIdCheck, type RedeemPromoInTransactionCallback, type RegistrationActivation, type RegistrationAuditContext, type RegistrationAuditEvent, type RegistrationAuditEventType, type RegistrationAuditLogger, type RegistrationBillingDetails, type RegistrationConfigSelection, type RegistrationConfiguratorLookup, type RegistrationErrorCode, type RegistrationOtpDelivery, type RegistrationPromoPreview, type RegistrationResumeDelivery, type RegistrationResumeTokenSigner, type RegistrationStatus, type RegistrationStep, type RequiredCapabilities, type ResolvableErrorBody, type ResumeRegistrationInput, type ResumeRegistrationResult, type RetiredBundleVersionRef, type RetiredVersionRef, type RetirementAnnounced, type RetirementBlocker, type RetirementMoveRun, type RetirementPreview, type RetirementPricedSide, type RetirementProgress, type RetirementReachedRow, type RetirementSide, type RetirementSkipReason, type RetirementSkippedRow, type RetirementSwitchResult, type RetirementSwitchTerms, type ReviewCatalogEntryData, type RlsBypassPort, type RunningContractIssuer, type RunningContractIssuers, 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, type SaaSiCatPersistenceAdapter, type SaaSiCatPersistenceAdminResources, type SaaSiCatPersistenceCatalog, type SaaSiCatPersistenceCore, type SaaSiCatPersistenceEntitlement, type SaaSiCatPersistencePayments, type SaaSiCatPersistencePromo, type SaaSiCatPersistenceTenantBilling, type SaveRegistrationConfigInput, type SaveRegistrationConfigResult, type ScheduledChangeColumns, type ScheduledPlanChangeInput, type SecretSealer, type SelectPlanInput, type SelectPlanResult, type SelectableBundleShape, type SelfServiceBlockedPlans, type SetCatalogEntryReviewData, type SettingsChangeFilter, type SettingsChangeRecord, type SettingsDifference, type SettingsErrorCode, type SetupConfirmMfaRequest, type SetupConfirmMfaResponse, type SetupErrorCode, type SetupRequest, type SetupResult, type SetupStatusResponse, type SlugAvailabilityCheck, type StandardPageDef, type StandardPageKey, type StartCheckoutInput, type StartCheckoutResult, type StartPaymentMethodSetupInput, type StartRegistrationInput, type StartRegistrationResult, type StoredBundleStem, type StrictModeWarning, type StrictModeWarningCode, type SubscriberBusinessStatusData, type SubscriberBusinessStatusResult, type SubscriberCharge, type SubscriberChargeOrigin, type SubscriberChargeRecord, type SubscriberChargeSource, type SubscriberContact, type SubscriberContactChange, type SubscriberCorrectionData, type SubscriberCorrectionRecord, type SubscriberCorrectionResult, type SubscriberDetails, type SubscriberErrorCode, type SubscriberIdentityCorrection, type SubscriberIdentityDelta, type SubscriberIdentityValues, type SubscriberInvoiceAddressField, type SubscriberLedgerRepository, type SubscriberPaymentMethodRecord, type SubscriberPaymentMethodReference, type SubscriberPaymentMethodRepository, type SubscriberPaymentMethodSetupData, type SubscriberPaymentMethodSetupMatch, type SubscriberPaymentMethodStatus, type SubscriberReadiness, type SubscriberRecord, type SubscriberRepository, type SubscriberTaxOrigin, type SubscriberTaxOriginChangeRecord, type SubscriberTaxOriginField, type SubscriberTaxOriginValues, type SubscriberTaxStatus, type SubscriberVatIdCheckRecord, type SubscriberVatIdCheckResult, type SubscriberWithCurrentCheck, type Subscription, type SubscriptionBundleRecord, type SubscriptionBundleRepository, type SubscriptionBundleView, type SubscriptionContractFilter, type SubscriptionContractInvoiceSnapshot, type SubscriptionContractParties, type SubscriptionContractPriceSnapshot, type SubscriptionContractRecord, type SubscriptionContractRepository, type SubscriptionContractStatus, type SubscriptionInvoiceColumns, type SubscriptionInvoiceDocumentRecord, type SubscriptionInvoiceIssuer, type SubscriptionInvoiceLineColumns, type SubscriptionInvoiceLineRecord, type SubscriptionInvoiceRecord, type SubscriptionInvoiceRepository, type SubscriptionInvoiceSubscriber, type SubscriptionNotice, type SubscriptionNoticeDelivery, type SubscriptionNoticeKey, type SubscriptionNoticeKind, type SubscriptionNoticePort, type SubscriptionNoticeRecord, type SubscriptionNoticeRepository, type SubscriptionRecord, type SubscriptionRepository, type SubscriptionStatsPort, type SubscriptionStatsSnapshot, type SubscriptionStatus, type SubscriptionUsagePort, type SubscriptionUsageRecord, type SuperAdminProvisioningPort, type SupersedeSubscriptionContractData, type SyncDiscoveryResult, TAX_ERROR_CODES, TAX_TREATMENT_KINDS, type TaxAdapter, type TaxAdapterFactory, type TaxAdapterIdentity, type TaxAtRate, type TaxDecision, type TaxDecisionRequest, type TaxErrorCode, type TaxIssuer, type TaxOriginWrite, type TaxPerRate, type TaxTreatment, type TaxTreatmentKind, type TenantActionDef, type TenantColumnDef, type TenantDto, type TenantFeatureWithdrawal, type TenantFeatureWithdrawalLine, type TenantListFilter, type TenantPort, type TenantSubscriptionUsage, type TenantSubscriptionWritePort, type TerminateSubscriptionContractData, type TopPromoCode, type TransactionContext, type TransactionRunner, type UpdateBundleData, type UpdateBundleVersionDraftData, type UpdateCatalogEntryBaseData, type UpdateCatalogEntryI18nData, type UpdateCheckoutOfferData, type UpdateMarketingProjectionData, type UpdateMarketingSettingsData, type UpdatePlanData, type UpdatePlanVersionDraftData, type UpdatePromoCodeData, type UpdatePromoCodeRequest, type UpdatePromotionData, type UpsellOffer, type UpsellOfferResolver, type UpsertCapabilityEntryData, type UpsertFeatureCatalogEntryInput, type UpsertFeatureEntryData, type UpsertPlanInput, type UpsertPlanVersionInput, type UpsertQuotaEntryData, type UpsertResult, type UsageSnapshotPort, type UserAccountLookup, type UserListFilter, type UserManagementPort, type UserPort, VERSION_RETIREMENT_CAPABILITY, type VatCategory, type VatIdCheck, type VatIdCheckOutcome, type VerifyRegistrationOtpResult, type VersionChange, type VersionChangeDirection, type VersionEditability, type VersionEditableReason, type VersionOffer, type VersionOfferClass, type VersionOfferFields, type VersionOfferSide, type VersionOfferView, type VersionOfferedNotice, type VersionRetiredNotice, type VersionRetirementRecord, type VersionRetirementReminder, type VersionRetirementRepository, type VersionRetirementView, type VersionSale, type VersionSaleDates, type VersionSaleKind, type VersionSwitchResult, type VersionWindow, type VersionedEntityBase, type WithdrawnFeature, addDaysToDay, applyPromo, asXmlReadsIt, assertPersistenceCapabilities, buildActivePlanVersionWhere, buildActiveVersionWhere, buildFeatureRequiresIndex, bundleDraftDefaults, bundleKeyTaken, bundleStemDefaults, canonicalJson, canonicalVatId, catalogDraftExists, catalogVersionAlreadyPublished, catalogVersionGone, classifyBundleVersionDiff, classifyIssuerChange, classifyPlanDiff, classifyVersionOffer, collectUnsatisfiedRequires, computeIncludedVat, concurrencyGate, concurrencyGateOf, 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, isPersistenceRefusal, isPlatformUserExistsError, isVersionActiveAt, isVersionEditable, issuerIdentityOf, keepOneRecommended, keepsVatIdCheck, lastDayInZone, maintenanceRetryAfterSeconds, maintenanceStatusOf, maintenanceWindowStatusOf, maintenanceWindowViewOf, marketingProjectionTaken, membersLeftOut, missingRequiresFor, movedIdentityFields, netFromGross, nextWithdrawalChange, noActivePlanVersion, parseZonedInstant, percentOf, pickActivePromo, planCatalogSettingsOf, planKeyTaken, planNotInCatalog, previousUtcDay, promoCodeTaken, promoStatus, promotionOnPrice, prorate, readCustomLimits, readQuotaRecord, readQuotaValue, recordedIssuerIdentity, refuseForeignPaymentMethodReference, resolveBundleAvailability, resolveErrorMessage, retirementCostsTheSubscription, retirementReminderDueAt, retirementReminderIsDue, retirementSwitchTerms, roundToCents, sameLegalIdentity, scheduledChangeAfterWrite, selectChargeableBundles, settingsSubtreeOf, startOfUtcDay, subscriberChargeColumns, subscriberFromRegistration, subscriberPaymentMethodColumns, subscriptionBundleAlreadyCancelled, subscriptionBundleGone, subscriptionContractGone, subscriptionGone, subscriptionInvoiceChargeInvoiced, subscriptionInvoiceColumns, subscriptionInvoiceDocumentChanged, subscriptionInvoiceLineColumns, sumToCents, taxOriginOf, taxOriginWrite, taxPerRate, taxTreatmentToJson, toArchivedInvoiceDocument, toBundleStemRow, toBundleVersionRetirementRecord, toCents, toContractLineItemRecord, toDecimalString, toFeatureWithdrawalRecord, toMaintenanceWindowRecord, toPlanRow, toPlanVersionRow, toRunningContractIssuer, toSubscriberChargeRecord, toSubscriberCorrectionRecord, toSubscriberPaymentMethodRecord, toSubscriberRecord, toSubscriberTaxOriginChangeRecord, toSubscriberVatIdCheckRecord, toSubscriptionBundleRecord, toSubscriptionContractRecord, toSubscriptionInvoiceDocumentRecord, toSubscriptionInvoiceRecord, toSubscriptionNoticeRecord, toTaxOriginValues, toTaxTreatment, toVersionRetirementRecord, utcMidnightOf, vatCategoryOf, vatIdCheckFromStore, versionOnSale, versionOnSaleOrNext, versionSale, withdrawnFeaturesOf, yearOfDay };