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

package/dist/index.d.cts

@@ -198,7 +198,7 @@ interface CapabilityCatalogEntryRow {
  * `CORE` < `ADVANCED` < `PRO` < `ENTERPRISE`. Apps may add further
  * tiers; sorting then happens via `FeatureCatalogEntry.sortOrder`.
  */
-type FeatureTier = 'CORE' | 'ADVANCED' | 'PRO' | 'ENTERPRISE' | string;
+type FeatureTier = 'CORE' | 'ADVANCED' | 'PRO' | 'ENTERPRISE' | (string & {});
 /**
  * SuperAdmin projection of a feature (aggregation of capabilities that declare
  * `feature: 'XYZ'` in the decorator). The short marketing form lives here;
@@ -646,6 +646,44 @@ type PaymentGatewayEvent = {
     occurredAt: Date;
     sessionRef: string;
     subject: PaymentMethodSetupSubject;
+} | {
+    /**
+     * What became of a collection, reported by the gateway on its own:
+     * the same outcome `findCollection` answers, for the attempt its key
+     * names. Each report reads the payment as it stands when the adapter
+     * translates it, so reports arriving out of order never take an
+     * attempt back to an earlier state.
+     */
+    kind: 'collection-reported';
+    eventId: string;
+    occurredAt: Date;
+    attemptKey: string;
+    outcome: CollectionOutcome;
+} | {
+    /**
+     * A refund the operator made in the gateway, of a payment an attempt
+     * of SaaSiCat's collected, as it stands when the adapter translates
+     * the report: created, settled, failed or canceled.
+     */
+    kind: 'refund-reported';
+    eventId: string;
+    occurredAt: Date;
+    /** The attempt that collected the payment it pays back. */
+    attemptKey: string;
+    refund: GatewayRefund;
+} | {
+    /**
+     * Money the gateway took back from the operator for a payment an
+     * attempt of SaaSiCat's collected — a direct debit the bank returned,
+     * a chargeback — and what it gave back of it, both as they stand
+     * when the adapter translates the report.
+     */
+    kind: 'reversal-reported';
+    eventId: string;
+    occurredAt: Date;
+    /** The attempt that collected the payment it takes back. */
+    attemptKey: string;
+    reversal: GatewayReversal;
 } | {
     /** Genuine, and nothing SaaSiCat acts on. */
     kind: 'unhandled';
@@ -654,6 +692,107 @@ type PaymentGatewayEvent = {
     /** The gateway's own name for the event, for the log. */
     type: string;
 };
+/**
+ * Why a collection failed, in SaaSiCat's words; the gateway's own code is kept
+ * beside it. Whether a second try can pass follows from the reason alone
+ * (`isRetryableCollectionFailure`):
+ *
+ * - `insufficient-funds` — the account or the card does not cover the amount;
+ * - `declined` — refused without a reason that rules out a second try, or the
+ *   bank or issuer could not be reached;
+ * - `authentication-required` — the card's bank asks the subscriber to confirm
+ *   the payment, which nobody can do while they are not present;
+ * - `payment-method-unusable` — the card is lost, stolen, blocked or expired,
+ *   or the account is closed or restricted;
+ * - `mandate-invalid` — the direct debit's mandate was revoked, does not match
+ *   or was disputed;
+ * - `other` — anything the gateway names that is none of these.
+ */
+type CollectionFailureReason = 'insufficient-funds' | 'declined' | 'authentication-required' | 'payment-method-unusable' | 'mandate-invalid' | 'other';
+/** The collection of one invoice, as the platform asks a gateway to make it. */
+interface CollectInvoiceInput {
+    /**
+     * The same for this invoice and attempt across every repeat of the
+     * request, and kept by the gateway with what it creates, so
+     * `findCollection` finds it again. Never a second charge for one key.
+     */
+    attemptKey: string;
+    invoiceId: string;
+    /** The invoice's number, which the subscriber's statement names. */
+    invoiceNumber: string;
+    /** The invoice's gross amount in cents, of `currency`. */
+    amountCents: number;
+    /** As `config/saas.yaml#currency` writes it, e.g. `EUR`. */
+    currency: string;
+    /** The customer the payment method is kept for at the gateway. */
+    customerRef: string;
+    paymentMethodRef: string;
+    type: PaymentMethodType;
+}
+/**
+ * What became of a collection: collected, still on its way — a direct debit
+ * is submitted to the bank and settles days later —, or failed.
+ * `paymentRef` is the gateway's reference to what it created for the attempt.
+ */
+type CollectionOutcome = {
+    status: 'succeeded';
+    paymentRef: string;
+    /** What the gateway received, in cents of `currency`. */
+    amountCents: number;
+    /** As `config/saas.yaml#currency` writes it, e.g. `EUR`. */
+    currency: string;
+} | {
+    status: 'pending';
+    paymentRef: string;
+} | {
+    status: 'failed';
+    /** `null` where the gateway refused before it created anything. */
+    paymentRef: string | null;
+    reason: CollectionFailureReason;
+    /** The gateway's own code for the reason, for the operator. */
+    gatewayCode: string | null;
+};
+/**
+ * A refund as the gateway reports it. `pending` and `succeeded` pay the money
+ * out; `failed` and `canceled` gave it back to the operator.
+ */
+interface GatewayRefund {
+    /** The gateway's reference to the refund, unique within its account. */
+    refundRef: string;
+    /** The gateway's reference to the payment it pays back. */
+    paymentRef: string;
+    amountCents: number;
+    /** As `config/saas.yaml#currency` writes it, e.g. `EUR`. */
+    currency: string;
+    status: 'pending' | 'succeeded' | 'failed' | 'canceled';
+}
+/**
+ * A reversal as the gateway reports it: what it withdrew from the operator and
+ * what it gave back, each in total so far, so a report delivered late or twice
+ * says what stands rather than what changed. A dispute that withdraws nothing
+ * yet, such as an inquiry, is no reversal.
+ */
+interface GatewayReversal {
+    /** The gateway's reference to it, such as a dispute's, unique within its account. */
+    reversalRef: string;
+    /** The gateway's reference to the payment it takes back. */
+    paymentRef: string;
+    /** What it withdrew so far, in cents of `currency`. */
+    withdrawnCents: number;
+    /** What the gateway gave back of it so far, in cents of `currency`: a dispute won. */
+    reinstatedCents: number;
+    /** As `config/saas.yaml#currency` writes it, e.g. `EUR`. */
+    currency: string;
+}
+/** Which attempt the gateway is asked about. */
+interface FindCollectionInput {
+    attemptKey: string;
+    customerRef: string;
+    /** The gateway's reference, where an earlier answer named one. */
+    paymentRef: string | null;
+    /** When the attempt was first submitted: nothing created before it is its. */
+    submittedAt: Date;
+}
 /**
  * One account at a payment gateway: its keys, its form and its callbacks.
  *
@@ -681,7 +820,34 @@ interface PaymentGateway {
      * an `immediateCallback` is read for.
      */
     readCallback(callback: PaymentGatewayCallback): Promise<PaymentGatewayEvent>;
+    /**
+     * Collects an invoice with the payment method it announced, without the
+     * subscriber present, under `attemptKey`: a repeat of the request with the
+     * same key creates nothing new.
+     *
+     * Answers a refusal — a declined card, a debit the bank turned down — as a
+     * `failed` outcome. Throws only where the answer is unknown: the request
+     * may or may not have reached the gateway, and the platform asks
+     * `findCollection` before it sends anything again.
+     */
+    collect(input: CollectInvoiceInput): Promise<CollectionOutcome>;
+    /**
+     * What became of the attempt `attemptKey` names, read from the gateway
+     * itself; `null` where the gateway holds nothing under it, so the request
+     * never arrived and may be sent again. Throws where the gateway cannot be
+     * asked. The platform relies on `null`: where the invoice was paid
+     * meanwhile the attempt is settled rather than sent again, and only the
+     * gateway's own report could still record a payment it took after all.
+     */
+    findCollection(input: FindCollectionInput): Promise<CollectionOutcome | null>;
 }
+/**
+ * Whether a collection that failed for `reason` can pass on a second try: an
+ * account short of funds and a refusal without a cause can; a closed account,
+ * a revoked mandate, a lost card or a payment the subscriber has to confirm
+ * cannot, and asks the subscriber to act instead.
+ */
+declare function isRetryableCollectionFailure(reason: CollectionFailureReason): boolean;
 /**
  * A callback that is not the gateway's: a missing or wrong signature, a stale
  * timestamp, a body that was altered. Nothing is read from it.
@@ -859,6 +1025,27 @@ 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`),
+     * unless it is collected by direct debit.
+     */
+    paymentTermDays: number;
+    /**
+     * Calendar days between an invoice collected by direct debit and the day
+     * it is collected, which the invoice announces and falls due on
+     * (`SC-PRIC-028`). `DIRECT_DEBIT_LEAD_DAYS` where it is not set.
+     */
+    directDebitLeadDays?: 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`. */
@@ -916,6 +1103,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;
 }
@@ -2143,7 +2332,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' | 'reconciliation';
 interface StandardPageDef {
     enabled: boolean;
     requiredCapability?: CapabilityKey;
@@ -2431,6 +2620,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. */
@@ -2894,6 +3112,23 @@ interface FeatureUiMeta {
     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[];
+}
+/** 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>;
@@ -3220,8 +3455,312 @@ interface BundleVersionSwitchResult {
     readonly takesEffectAt: string;
 }
 
+/** 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;
+}
+/** 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;
+    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;
+}
+/**
+ * Whether `withdrawal` takes its feature away at `at`. A withdrawal lifted
+ * before its date never does.
+ */
+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>;
+/**
+ * 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.
+ */
+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 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 FeatureWithdrawnNotice {
+    readonly kind: 'feature-withdrawn';
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly withdrawalId: string;
+    readonly featureKey: string;
+    readonly featureLabel: string;
+    readonly reason: string;
+    /** ISO 8601. */
+    readonly effectiveFrom: string;
+    readonly lines: readonly FeatureWithdrawalNoticeLine[];
+    /**
+     * 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 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 liftedFrom: string;
+}
+/**
+ * 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 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;
+}
+/** 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 withdrawal reaches, as the operator previews it. */
+interface FeatureWithdrawalReachedRow {
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly status: string;
+    /** 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: 'ends-before';
+}
+/**
+ * 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 FeatureWithdrawalReachedRow[];
+    readonly skipped: readonly FeatureWithdrawalSkippedRow[];
+    readonly targets: readonly FeatureWithdrawalTarget[];
+    /** Empty where it may be announced as it stands. */
+    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 FeatureWithdrawalAnnounced {
+    readonly withdrawal: FeatureWithdrawalRow;
+    /** Notices sent now; the rest are sent by the next run. */
+    readonly told: number;
+    readonly failed: 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 {
+    /**
+     * Whether the reduction still applies: the line runs as it was reached.
+     * A change of plan or rhythm the subscriber made ends it.
+     */
+    readonly reduced: boolean;
+    /**
+     * 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 fromChange: string | null;
+}
+/** 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[];
+    };
+}
+/**
+ * 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' | 'bundle-version-retired' | 'bundle-version-retirement-reminder' | 'bundle-version-offered';
+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' | 'collection-failed' | 'collection-announced' | 'collection-reversed';
 /** Which notice: there is one per subscription, kind and subject. */
 interface SubscriptionNoticeKey {
     readonly tenantId: string;
@@ -3239,7 +3778,13 @@ interface SubscriptionNoticeKey {
      * 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.
+     * 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. For `collection-failed`,
+     * the key of the attempt that failed; for `collection-announced`, the key
+     * of the attempt announced; for `collection-reversed`, the key of the
+     * attempt whose payment was reversed: each is told once.
      */
     readonly subject: string;
 }
@@ -3292,7 +3837,7 @@ interface BundleVersionOfferedNotice {
     readonly offer: BundleVersionOfferView;
 }
 /** A notice handed to the application to send. */
-type SubscriptionNotice = VersionOfferedNotice | VersionRetiredNotice | VersionRetirementReminder | BundleVersionRetiredNotice | BundleVersionRetirementReminder | BundleVersionOfferedNotice;
+type SubscriptionNotice = VersionOfferedNotice | VersionRetiredNotice | VersionRetirementReminder | BundleVersionRetiredNotice | BundleVersionRetirementReminder | BundleVersionOfferedNotice | FeatureWithdrawnNotice | FeatureWithdrawalLiftedNotice | EndedAtOnceNotice;
 
 /**
  * A `subscription_notices` row as either adapter reads it back. The two JSON
@@ -3391,6 +3936,31 @@ interface CanonicalBundleVersionRetirementRow {
 /** 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;
@@ -3479,6 +4049,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.
@@ -4102,8 +4694,20 @@ interface PromoCodeRepository {
      * together, and the second one's answer is the refusal, not a driver error.
      */
     create(data: CreatePromoCodeData): Promise<PromoCodeRecord>;
-    update(id: string, data: UpdatePromoCodeData): Promise<PromoCodeRecord>;
-    softDelete(id: string): Promise<void>;
+    /**
+     * Changes the code under `id` only while it is not deleted, in the one
+     * write that changes it, and answers `null` where no such code is there —
+     * none under `id`, or one deleted, even since the platform read it
+     * (`SC-PROMO-032`).
+     */
+    update(id: string, data: UpdatePromoCodeData): Promise<PromoCodeRecord | null>;
+    /**
+     * Marks the code under `id` deleted only while it is not, in the one
+     * write that marks it, and answers whether it did: a second delete,
+     * however close behind the first, leaves the day it was deleted
+     * (`SC-PROMO-032`).
+     */
+    softDelete(id: string): Promise<boolean>;
     /**
      * Atomic slot reservation: increments `redemptionsCount` and checks
      * `status === 'ACTIVE' && (maxRedemptions IS NULL || redemptionsCount + heldCount < maxRedemptions)`.
@@ -4275,76 +4879,527 @@ interface PromoRevenueDeductionAggregator {
     sumGrossForPromoCode(promoCodeId: string): Promise<string>;
 }
 
-/** 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;
+/** What follows a failed collection. */
+type CollectionFailureNext = 
+/** The same card, or the card now in use, is charged on `on`. */
+{
+    readonly action: 'charged-again';
+    readonly on: CalendarDay;
 }
-/** 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"];
+/** A direct debit is announced again, with its own day, in a notice of its own. */
+ | {
+    readonly action: 'announced-again';
+}
+/** Nothing is tried again until the subscriber replaces the payment method. */
+ | {
+    readonly action: 'replace-payment-method';
+};
+/** The invoice a collection notice is about, as it was issued. */
+interface CollectionNoticeInvoice {
+    readonly tenantId: string;
+    readonly subscriptionId: string;
+    readonly subscriberId: string;
+    readonly invoiceId: string;
+    readonly invoiceNumber: string;
+    /** What the invoice asks for, of `currency`. */
+    readonly amount: number;
+    readonly currency: string;
+}
+/** A collection failed. Told once per failed attempt. */
+interface CollectionFailedNotice extends CollectionNoticeInvoice {
+    readonly kind: 'collection-failed';
+    readonly paymentMethodType: PaymentMethodType;
+    readonly reason: CollectionFailureReason;
+    readonly next: CollectionFailureNext;
+}
+/**
+ * A direct debit announced again, for a day of its own and under the mandate
+ * of the payment method it is collected with. Told once per planned attempt;
+ * it stands on its own and leaves the invoice as it was issued.
+ */
+interface CollectionAnnouncedNotice extends CollectionNoticeInvoice {
+    readonly kind: 'collection-announced';
+    /** The day the account is debited. */
+    readonly collectOn: CalendarDay;
+    readonly mandateReference: string;
+    /** The last four digits of the account's IBAN. */
+    readonly last4: string;
+}
+/** What follows a reversal that opened an invoice again. */
+type CollectionReversedNext = 
+/** It is collected with the payment method now in use, which replaced the reversed one. */
+{
+    readonly action: 'collected-with-payment-method-in-use';
+}
+/** Nothing is collected until the subscriber replaces the payment method. */
+ | {
+    readonly action: 'replace-payment-method';
+};
 /**
- * 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.
+ * A payment was reversed — a direct debit the bank returned, a chargeback —
+ * and its invoice is open again. Told once per reversed attempt; nothing is
+ * collected again with the payment method the payment was made with.
  */
-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;
+interface CollectionReversedNotice extends CollectionNoticeInvoice {
+    readonly kind: 'collection-reversed';
+    /** How the reversed payment was made. */
+    readonly paymentMethodType: PaymentMethodType;
+    /** What the invoice owes again, of `currency`. */
+    readonly owed: number;
+    readonly next: CollectionReversedNext;
 }
+/** A notice about collecting an invoice. */
+type InvoiceCollectionNotice = CollectionFailedNotice | CollectionAnnouncedNotice | CollectionReversedNotice;
+
 /**
- * Where a subscriber stands for tax purposes, as its record stands: what an
- * adapter decides a treatment from.
+ * 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.
  */
-interface SubscriberTaxOrigin {
-    /** The country of the billing address, ISO 3166-1 alpha-2; `null` while unknown. */
-    country: string | null;
+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 {
     /**
-     * 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.
+     * 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.
      */
-    business: boolean | null;
-    /** The VAT identification number as entered, validated or not. */
-    vatId: string | null;
+    id: string;
     /**
-     * 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`).
+     * The party the contract is concluded with, whose account this is. It outlives the tenant.
      */
-    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;
+    subscriberId: string;
     /**
-     * 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.
+     * 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'>;
+/**
+ * The payment method an invoice is collected with, copied from the
+ * subscriber's on the day it was issued — what the invoice tells the
+ * subscriber, so a later change leaves it as it was (`SC-PRIC-028`).
+ */
+interface SubscriptionInvoicePayment {
+    /** The subscriber's payment method, which the collection charges. */
+    paymentMethodId: string;
+    /** The account in `config/saas.yaml#payments.accounts` that holds it. */
+    gatewayAccount: string;
+    type: PaymentMethodType;
+    /** The card network, such as `visa`; `null` for a direct debit. */
+    brand: string | null;
+    /** The last four digits of the card number or the IBAN. */
+    last4: string;
+    /** The mandate a direct debit is collected under; `null` for a card. */
+    mandateReference: string | null;
+}
+/** 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 (`SC-PRIC-046`): the collection date where it is
+     * collected by direct debit, the issue date plus the payment term otherwise.
+     */
+    dueDate: CalendarDay;
+    /**
+     * The payment method it is collected with, as it stood when the invoice
+     * was issued; `null` where it is not collected — the subscriber had no
+     * payment method that can be, or the invoice asks for nothing.
+     */
+    payment: SubscriptionInvoicePayment | null;
+    /**
+     * The day a direct debit is collected from, which the invoice announces
+     * with its amount and mandate reference (`SC-PRIC-028`): the issue date
+     * plus the lead time. `null` unless `payment` is a direct debit.
+     */
+    collectionDate: CalendarDay | null;
+    /** 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`).
+ *
+ * An invoice collected by direct debit is the notice SEPA asks for before the
+ * debit: its document states the amount, the `collectionDate` and the
+ * `payment.mandateReference` (`SC-PRIC-028`).
+ */
+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;
+}
+/** A notice about collecting an invoice on its way to the subscriber. */
+interface InvoiceNoticeMail {
+    notice: InvoiceCollectionNotice;
+    /** The invoice email on the subscriber's record. */
+    to: string;
+}
+/**
+ * Sends an invoice to the subscriber with its file attached (`SC-PRIC-047`),
+ * and what the subscriber is told about collecting it (`SC-PRIC-028`,
+ * `SC-PRIC-080`).
+ *
+ * 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>;
+    /**
+     * Tells the subscriber that a collection failed and what follows, or the
+     * day a direct debit announced again is collected under which mandate.
+     * The application words it as it words the invoice; a direct debit's
+     * announcement names the amount, the day and the mandate reference. It
+     * rejects where the message could not be handed on, and the next run tries
+     * again; each notice is sent once however many instances run.
+     */
+    tell(mail: InvoiceNoticeMail): 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;
@@ -4433,6 +5488,53 @@ interface TaxAdapter extends TaxAdapterIdentity {
      * 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[]>;
+}
+/** A line as an invoice's tax is computed from it. */
+interface InvoiceTaxLine {
+    net: number;
+    /** In per cent. */
+    rate: number;
+}
+/**
+ * What an invoice says, without its number: what the adapter checks against
+ * the content the law requires before the number is drawn.
+ */
+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';
@@ -5050,125 +6152,673 @@ type AdminSubscriberHistoryEntry = {
 };
 
 /**
- * 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.
+ * Where an attempt stands: `SCHEDULED` while it is planned for a day and has
+ * not left; `SUBMITTED` once it is written as sent, before its request leaves,
+ * and until an answer is recorded; `PENDING` while a direct debit is on its
+ * way; `SUCCEEDED` and `FAILED` once it is settled; `WITHDRAWN` where a planned
+ * one will not be made, because the payment method it was planned with is no
+ * longer in use; `REVERSED` where it succeeded and a reversal of its payment —
+ * a returned direct debit, a chargeback — opened its invoice again, which is
+ * then collected only with another payment method (`SC-PRIC-085`).
+ */
+type InvoiceCollectionStatus = 'SCHEDULED' | 'SUBMITTED' | 'PENDING' | 'SUCCEEDED' | 'FAILED' | 'WITHDRAWN' | 'REVERSED';
+/** An attempt as a store reads it back. */
+interface InvoiceCollectionRecord {
+    id: string;
+    invoiceId: string;
+    /** From 1, per invoice. */
+    attempt: number;
+    /** `collectionAttemptKey(invoiceId, attempt)`: the key every request of this attempt carries. */
+    attemptKey: string;
+    /** The account in `config/saas.yaml#payments.accounts` the request went to. */
+    gatewayAccount: string;
+    /** The subscriber's payment method it charges. */
+    paymentMethodId: string;
+    paymentMethodType: PaymentMethodType;
+    customerRef: string;
+    paymentMethodRef: string;
+    /** The invoice's number, as the request names it. */
+    invoiceNumber: string;
+    /** The invoice's gross amount, of `currency`; the request carries it in cents. */
+    amount: number;
+    currency: string;
+    status: InvoiceCollectionStatus;
+    /** The gateway's reference to what it created; `null` until an answer names one. */
+    paymentRef: string | null;
+    /** Why it failed; `null` unless it did. */
+    failureReason: CollectionFailureReason | null;
+    /** The gateway's own code for the failure. */
+    failureCode: string | null;
+    /**
+     * When it was written as sent and its request first left; `null` while it
+     * is planned, and for a planned one withdrawn before it left.
+     */
+    submittedAt: Date | null;
+    /**
+     * When a run last took it on — to send it, to send it again, or to ask
+     * the gateway about it. Another run leaves it alone until this is old
+     * enough (`INVOICE_COLLECTION_LEASE_MS`, `INVOICE_COLLECTION_ASK_EVERY_MS`).
+     * `null` where `submittedAt` is.
+     */
+    heldAt: Date | null;
+    /** When it was settled, or withdrawn; `null` while it is not. */
+    resolvedAt: Date | null;
+    /**
+     * The day a planned attempt is collected from; `null` for one written as
+     * sent from the start, which the invoice's own date governs. A direct
+     * debit's is the earliest day until it is announced, and the day its
+     * announcement names after.
+     */
+    collectOn: CalendarDay | null;
+    /** When a planned direct debit's announcement reached the subscriber; `null` until it did. */
+    announcedAt: Date | null;
+    /**
+     * When what follows a failure or a reversal was decided — the subscriber's
+     * notice recorded, and the next attempt planned where one is made; `null`
+     * until it was, and for an attempt that neither failed nor was reversed.
+     */
+    followedUpAt: Date | null;
+}
+/** An attempt that has been sent: its request carries a moment, and a run holds it. */
+type SubmittedInvoiceCollection = InvoiceCollectionRecord & {
+    submittedAt: Date;
+    heldAt: Date;
+};
+/**
+ * `attempt` as one that has been sent. Throws for one that has not left, which
+ * a run never meets where it reads an attempt it sent or holds.
  */
-type SubscriberChargeOrigin = 'activation' | 'renewal' | 'planChange' | 'bundleBooking' | 'bundleChange' | 'credit' | 'correction';
+declare function sentCollectionOf(attempt: InvoiceCollectionRecord): SubmittedInvoiceCollection;
+/** An attempt to start: what its request carries, and the moment it is taken on. */
+interface NewInvoiceCollection {
+    invoiceId: string;
+    gatewayAccount: string;
+    paymentMethodId: string;
+    paymentMethodType: PaymentMethodType;
+    customerRef: string;
+    paymentMethodRef: string;
+    invoiceNumber: string;
+    amount: number;
+    currency: string;
+    /** Written as both `submittedAt` and `heldAt`. */
+    at: Date;
+}
+/** An attempt to plan for `collectOn`: what its request will carry. */
+interface PlannedInvoiceCollection {
+    invoiceId: string;
+    /**
+     * The number of the invoice's last attempt the plan follows — `0` where it
+     * has none. A run decides what follows from the attempts it read; one that
+     * read them before another run added an attempt plans nothing.
+     */
+    after: number;
+    gatewayAccount: string;
+    paymentMethodId: string;
+    paymentMethodType: PaymentMethodType;
+    customerRef: string;
+    paymentMethodRef: string;
+    invoiceNumber: string;
+    amount: number;
+    currency: string;
+    /** The day it is collected from; for a direct debit, the earliest such day. */
+    collectOn: CalendarDay;
+}
 /**
- * Which kind of contract line the charge realises.
+ * How long a run's hold on an attempt lasts. Longer than a request may take,
+ * so a run does not ask the gateway about, or send again, a request another
+ * run is still waiting for.
  */
-type SubscriberChargeSource = 'plan' | 'bundle' | 'discount';
+declare const INVOICE_COLLECTION_LEASE_MS: number;
 /**
- * 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.
+ * How often a direct debit on its way is asked about. Most are settled within
+ * six business days, and the gateway's own report of it is an event of its
+ * own; asking is what finds the outcome where no report arrives.
  */
-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.
-     */
+declare const INVOICE_COLLECTION_ASK_EVERY_MS: number;
+/**
+ * The key every request of an attempt carries, and that the gateway keeps
+ * with what it creates: `saasicat:collect:<invoice>:<attempt>`. The same for
+ * one attempt however often its request is repeated, and another for the next
+ * attempt of the same invoice.
+ */
+declare function collectionAttemptKey(invoiceId: string, attempt: number): string;
+/** The status an outcome settles an attempt in. */
+declare function collectionStatusOf(outcome: CollectionOutcome): InvoiceCollectionStatus;
+/**
+ * What an attempt whose request never reached the gateway is settled with
+ * where its invoice was paid meanwhile — a late payment for an earlier
+ * attempt — instead of being sent again: failed, for no reason the
+ * subscriber has to act on, under SaaSiCat's own code.
+ */
+declare const COLLECTION_NOT_SENT_PAID: CollectionOutcome;
+/**
+ * The same for an attempt whose payment method a payment of its invoice was
+ * reversed on meanwhile: sent now, it would collect with that payment method
+ * again (`SC-PRIC-085`). The reversal's notice tells the subscriber what
+ * follows.
+ */
+declare const COLLECTION_NOT_SENT_REVERSED: CollectionOutcome;
+/**
+ * What `abandonPaid` found for an attempt whose request never reached the
+ * gateway: `abandoned` — its invoice owes nothing, and it is settled as
+ * `COLLECTION_NOT_SENT_PAID`; `resend` — it is still `SUBMITTED` and its
+ * invoice still owes, so the same request is sent again; `settled` — it is no
+ * longer `SUBMITTED`, a report having settled it or put it on its way
+ * meanwhile, and nothing is sent.
+ */
+type AbandonPaidOutcome = 'abandoned' | 'resend' | 'settled';
+
+/** What a case is about: a refund no credit takes, or a reversal no credit takes. */
+type ReconciliationCaseKind = 'REFUND_UNMATCHED' | 'REVERSAL_UNMATCHED';
+/** A case to reconcile, as a store reads it back. */
+interface SubscriberReconciliationCaseRecord {
     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.
-     */
+    /** The tenant the payment's invoice was for, as a trace. */
     tenantId: string;
+    kind: ReconciliationCaseKind;
+    /** What matched nothing, positive, of `currency`. */
+    amount: number;
+    currency: string;
+    /** The payment the refund pays back, or the reversal takes back. */
+    paymentId: string;
+    /** The refund, for a `REFUND_UNMATCHED`; `null` otherwise. */
+    refundId: string | null;
+    /** The reversal, for a `REVERSAL_UNMATCHED`; `null` otherwise. */
+    reversalId: string | null;
+    gatewayAccount: string;
+    /** The refund's or the reversal's reference at the gateway, which the operator finds it under. */
+    gatewayRef: string;
+    recordedAt: Date;
+    /** When it was closed; `null` while it is open. */
+    closedAt: Date | null;
+    /** Who closed it; `null` while it is open, and where SaaSiCat closed it. */
+    closedBy: string | null;
+    /** Why it was closed, in the operator's words or SaaSiCat's; `null` while it is open. */
+    note: string | null;
+}
+/** An operator closing a case. */
+interface CloseReconciliationCase {
+    caseId: string;
+    note: string;
+    /** Who closes it. */
+    closedBy: string;
+    at: Date;
+}
+/** What closing a case did. */
+type ClosedReconciliationCase = {
+    outcome: 'closed';
+    case: SubscriberReconciliationCaseRecord;
+} | {
+    outcome: 'unknown-case';
+}
+/** Closed before, by the operator or by SaaSiCat; nothing is written. */
+ | {
+    outcome: 'already-closed';
+    case: SubscriberReconciliationCaseRecord;
+};
+/** Whether a list reads the cases still open or the ones closed. */
+type ReconciliationCaseState = 'open' | 'closed';
+/**
+ * The manifest capability that announces the operator's list of cases to
+ * reconcile. The platform sets it where it serves the list.
+ */
+declare const RECONCILIATION_READ_CAPABILITY = "reconciliation.read";
+/**
+ * The manifest capability that announces closing a case with a note, beside
+ * the list.
+ */
+declare const RECONCILIATION_CLOSE_CAPABILITY = "reconciliation.close";
+/**
+ * The manifest capability that announces a tenant's invoices with what each
+ * still owes, and its open cases, on its page.
+ */
+declare const SUBSCRIBER_PAYMENTS_CAPABILITY = "payments.read";
+/** A case as the operator reads it. */
+interface AdminReconciliationCase {
+    id: string;
+    kind: ReconciliationCaseKind;
+    amount: number;
+    currency: string;
+    /** The tenant the payment's invoice was for, which the administration's tenant list names. */
+    tenantId: string;
+    subscriber: {
+        id: string;
+        customerNumber: string;
+        legalName: string;
+    };
+    /** The payment it is about, and the invoice that payment was collected for. */
+    payment: {
+        ref: string;
+        invoiceNumber: string | null;
+    };
+    gatewayAccount: string;
+    /** The refund's or the reversal's reference at the gateway. */
+    reference: string;
+    /** ISO 8601. */
+    recordedAt: string;
+    /** ISO 8601; `null` while it is open. */
+    closedAt: string | null;
+    /** Who closed it; `null` while it is open, and where SaaSiCat closed it. */
+    closedBy: string | null;
+    note: string | null;
+}
+/** One page of cases, the oldest first; `next` continues it, `null` at the end. */
+interface AdminReconciliationCases {
+    cases: AdminReconciliationCase[];
+    next: string | null;
+}
+/** The longest note a case is closed with, which the route and the form both hold to. */
+declare const RECONCILIATION_NOTE_MAX_LENGTH = 500;
+/** An operator's note closing a case. */
+interface AdminReconciliationClose {
+    note: string;
+}
+/** An invoice on its tenant's page: what it asked for, and what it still owes. */
+interface AdminTenantInvoice {
+    id: string;
+    number: string;
+    /** ISO 8601. */
+    issuedAt: string;
+    dueDate: CalendarDay;
+    totalGross: number;
+    currency: 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.
+     * What it still owes after every payment, reversal and reinstatement
+     * against it; negative where the subscriber is owed, as by an invoice whose
+     * total is negative.
      */
+    owed: number;
+}
+/** A tenant's invoices, the newest first, and its cases still open, the oldest first. */
+interface AdminTenantPayments {
+    invoices: AdminTenantInvoice[];
+    openCases: AdminReconciliationCase[];
+}
+
+/** A payment the gateway confirmed for an invoice, as a store reads it back. */
+interface SubscriberPaymentRecord {
+    id: string;
+    subscriberId: string;
+    /** The tenant the invoice was for, as a trace. */
+    tenantId: string;
+    /** The invoice it was collected for. */
+    invoiceId: string;
+    /** The attempt that collected it. */
+    collectionId: string;
+    /** The account in `config/saas.yaml#payments.accounts` it was collected at. */
+    gatewayAccount: string;
+    provider: string;
+    /** The gateway's own reference to the payment, unique within its account. */
+    gatewayRef: string;
+    /** What the gateway received, of `currency`. */
+    amount: number;
+    currency: string;
+    recordedAt: Date;
+}
+/** A payment to record: what the gateway reported for an attempt. */
+interface NewSubscriberPayment {
+    invoiceId: string;
+    collectionId: string;
+    gatewayAccount: string;
+    provider: string;
+    gatewayRef: string;
+    amount: number;
+    currency: string;
+    at: Date;
+}
+/** What recording a payment did: what it settles of its invoice, and the credit it left. */
+interface RecordedSubscriberPayment {
+    payment: SubscriberPaymentRecord;
+    /** The part of the payment that settles its invoice; `0` where the invoice owed nothing. */
+    settled: number;
+    /** What the payment brought beyond what its invoice owed; `null` where it brought nothing more. */
+    credit: SubscriberCreditRecord | null;
+}
+/** Where a credit comes from. */
+type SubscriberCreditOrigin = 
+/** What a payment brought beyond what its invoice still owed. */
+{
+    kind: 'payment';
+    paymentId: string;
+}
+/** An invoice whose total is negative: the subscriber is owed its amount. */
+ | {
+    kind: 'invoice';
+    invoiceId: string;
+}
+/**
+ * What a reversal the gateway gave back brought beyond what the invoices
+ * it had opened again still owed: the subscriber paid them meanwhile.
+ */
+ | {
+    kind: 'reversal';
+    reversalId: string;
+};
+/** Money the operator owes a subscriber, as a store reads it back. */
+interface SubscriberCreditRecord {
+    id: string;
+    subscriberId: string;
+    /** The tenant it arose in, as a trace. */
+    tenantId: string;
+    /** What the subscriber is owed, positive, of `currency`. */
+    amount: number;
+    currency: string;
+    origin: SubscriberCreditOrigin;
+    createdAt: Date;
+}
+/**
+ * What changed how much of a credit is paid out: a refund the gateway reported
+ * against it, the same refund given back because it failed, a payout the
+ * operator recorded, a reversal that took the credit's open part back to the
+ * subscriber's bank, and the same reversal given back by the gateway.
+ */
+type SubscriberCreditEntryKind = 'REFUND' | 'REFUND_FAILED' | 'PAYOUT' | 'REVERSAL' | 'REVERSAL_TAKEN_BACK';
+/** One change to what a credit has paid out, as a store reads it back. */
+interface SubscriberCreditEntryRecord {
+    id: string;
+    creditId: string;
+    kind: SubscriberCreditEntryKind;
+    /**
+     * Positive. A `REFUND`, a `PAYOUT` and a `REVERSAL` pay this much of the
+     * credit out; a `REFUND_FAILED` and a `REVERSAL_TAKEN_BACK` give it back.
+     */
+    amount: number;
+    /** The refund, for a `REFUND` and its `REFUND_FAILED`; `null` otherwise. */
+    refundId: string | null;
+    /** The reversal, for a `REVERSAL` and its `REVERSAL_TAKEN_BACK`; `null` otherwise. */
+    reversalId: string | null;
+    /**
+     * Where the operator finds it: the refund's or the reversal's reference
+     * at the gateway, or the payout's, such as the transfer's.
+     */
+    reference: string | null;
+    /** The day the payout left; `null` for a refund's entries. */
+    paidOn: CalendarDay | null;
+    /** Who recorded the payout; `null` for a refund's entries. */
+    recordedBy: string | null;
+    /** What the operator noted with the payout. */
+    note: string | null;
+    recordedAt: Date;
+}
+/** A credit with what has been paid out of it, and what is still open. */
+interface SubscriberCreditStanding {
+    credit: SubscriberCreditRecord;
+    entries: SubscriberCreditEntryRecord[];
+    /** What the subscriber is still owed of it; never below `0`. */
+    open: number;
+}
+/**
+ * Where a refund stands, as the gateway reports it: `PENDING` and `SUCCEEDED`
+ * pay out, `FAILED` and `CANCELED` gave the money back to the operator.
+ */
+type SubscriberRefundStatus = 'PENDING' | 'SUCCEEDED' | 'FAILED' | 'CANCELED';
+/** A refund the operator made in the gateway, as a store reads it back. */
+interface SubscriberRefundRecord {
+    id: string;
+    subscriberId: string;
+    /** The payment it pays back. */
+    paymentId: string;
+    gatewayAccount: string;
+    /** The gateway's reference to the refund, unique within its account. */
+    gatewayRef: string;
+    amount: number;
+    currency: string;
+    status: SubscriberRefundStatus;
+    recordedAt: Date;
+    /** When it was recorded as failed or canceled; `null` while it pays out. */
+    endedAt: Date | null;
+}
+/** A refund as the gateway reported it, to record against the payment it pays back. */
+interface ReportedSubscriberRefund {
+    gatewayAccount: string;
+    gatewayRef: string;
+    /** The gateway's reference to the payment it pays back. */
+    paymentRef: string;
+    amount: number;
     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;
+    status: SubscriberRefundStatus;
+    at: Date;
 }
-
-/** A charge as a store reads it back: the wire format, with its dates as dates. */
-interface SubscriberChargeRecord {
+/** What recording a refund did. */
+type RecordedSubscriberRefund = 
+/** No payment of this installation's is under its reference. */
+{
+    outcome: 'unknown-payment';
+}
+/**
+ * Recorded for the first time: the credits it pays out, and the part that
+ * matches none, which is a case to reconcile.
+ */
+ | {
+    outcome: 'recorded';
+    refund: SubscriberRefundRecord;
+    parts: CreditPart[];
+    unmatched: number;
+    case: SubscriberReconciliationCaseRecord | null;
+}
+/**
+ * Recorded before; it failed or was canceled now, gave back what it paid
+ * out, and closed the case its unmatched part had opened.
+ */
+ | {
+    outcome: 'given-back';
+    refund: SubscriberRefundRecord;
+    parts: CreditPart[];
+    closedCases: SubscriberReconciliationCaseRecord[];
+}
+/** Recorded before, and nothing it reports changes what is paid out. */
+ | {
+    outcome: 'unchanged';
+    refund: SubscriberRefundRecord;
+};
+/** The part of an amount that one credit takes. */
+interface CreditPart {
+    creditId: string;
+    amount: number;
+}
+/** The part of an amount that one invoice takes. */
+interface InvoicePart {
+    invoiceId: string;
+    amount: number;
+}
+/**
+ * Money the gateway took back from the operator for a payment — a returned
+ * direct debit or a chargeback — as a store reads it back. What it withdrew and
+ * what the gateway gave back of it only grow; each change is recorded as the
+ * entries it adds.
+ */
+interface SubscriberReversalRecord {
     id: string;
     subscriberId: string;
+    /** The tenant the payment's invoice was for, as a trace. */
     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;
+    /** The payment it takes back. */
+    paymentId: string;
+    gatewayAccount: string;
+    /** The gateway's reference to it, such as a dispute's, unique within its account. */
+    gatewayRef: string;
+    /** What the gateway withdrew, positive, of `currency`. */
+    amount: number;
     currency: string;
-    /** Net, rounded to the cent when written. Negative for a discount. */
-    amountNet: number;
-    /** When the amount became due. */
-    bookedAt: Date;
-    createdAt: Date;
+    /**
+     * The part of `amount` taken from the credit the payment left — its open
+     * part and the part already paid out alike —, so a later reversal of the
+     * same payment takes from what of that credit is left.
+     */
+    fromCredit: number;
+    /** What the gateway gave back of `amount`, a dispute won; `0` until it gives anything back. */
+    reinstated: number;
+    recordedAt: Date;
+    /** When the gateway last gave something back; `null` until it does. */
+    reinstatedAt: Date | 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.
+ * A reversal as the gateway reports it, as it stands when it is reported: what
+ * it withdrew and what it gave back so far, each in total.
  */
-declare const SUBSCRIBER_ACCOUNT_CAPABILITY = "charges.read";
-/** Whose account it is, as the operator is shown it. */
-interface AdminAccountHolder {
+interface ReportedSubscriberReversal {
+    gatewayAccount: string;
+    gatewayRef: string;
+    /** The gateway's reference to the payment it takes back. */
+    paymentRef: string;
+    currency: string;
+    withdrawn: number;
+    reinstated: number;
+    at: Date;
+}
+/** What withdrawing part of a reversal's amount took back. */
+interface ReversalWithdrawal {
+    /** What it took of the credit the payment left that was still open. */
+    credit: CreditPart | null;
+    /**
+     * What it took instead of opening an invoice again, of the credits other
+     * payments collected for that invoice left, the oldest first.
+     */
+    covering: CreditPart[];
+    /** The invoices it opened again, each by how much, the oldest first. */
+    invoices: InvoicePart[];
+    /**
+     * The covers the payment's own credit gave other reversals of its invoice,
+     * lifted before anything else: each of those reversals now opens the
+     * invoice by what it took (`SC-PRIC-088`).
+     */
+    uncovered: LiftedCover[];
+    /**
+     * What met the part of that credit already paid out, or went beyond what
+     * the payment brought: a case to reconcile.
+     */
+    unmatched: number;
+    case: SubscriberReconciliationCaseRecord | null;
+}
+/** A cover lifted: the reversal it was given to, that reversal's payment, and what it opens now. */
+interface LiftedCover {
+    reversalId: string;
+    paymentId: string;
+    invoiceId: string;
+    amount: number;
+}
+/** What giving back part of a reversal's amount took back in turn. */
+interface ReversalReinstatement {
+    /** The cases of the reversal it covered, closed. */
+    closedCases: SubscriberReconciliationCaseRecord[];
+    /** What it gave back to the credits the reversal had taken from. */
+    credits: CreditPart[];
+    /** The invoices it settled again, each by how much. */
+    invoices: InvoicePart[];
+    /** What the invoices no longer owed, as a credit; `null` where they owed all of it. */
+    credit: SubscriberCreditRecord | null;
+}
+/** What recording a reversal did. */
+type RecordedSubscriberReversal = 
+/** No payment of this installation's is under its reference. */
+{
+    outcome: 'unknown-payment';
+}
+/**
+ * Recorded, or recorded before and changed now: what the newly withdrawn
+ * part took back, and what the newly given back part gave back, each
+ * `null` where nothing of it changed.
+ */
+ | {
+    outcome: 'recorded';
+    reversal: SubscriberReversalRecord;
+    withdrawal: ReversalWithdrawal | null;
+    reinstatement: ReversalReinstatement | null;
+}
+/** Recorded before, and nothing it reports changes it. */
+ | {
+    outcome: 'unchanged';
+    reversal: SubscriberReversalRecord;
+};
+/** A payout the operator made outside the gateway, to record against a credit. */
+interface NewSubscriberPayout {
+    creditId: string;
+    amount: number;
+    /** The transfer's reference, which the operator's bank statement names. */
+    reference: string;
+    paidOn: CalendarDay;
+    note: string | null;
+    /** Who records it. */
+    recordedBy: string;
+    at: Date;
+}
+/** What recording a payout did. */
+type RecordedSubscriberPayout = {
+    outcome: 'recorded';
+    entry: SubscriberCreditEntryRecord;
+    open: number;
+} | {
+    outcome: 'unknown-credit';
+}
+/** More than the credit still owes; nothing is written. */
+ | {
+    outcome: 'exceeds-open';
+    open: number;
+};
+/**
+ * The manifest capability that announces the operator's view of a
+ * subscriber's credits. The platform sets it where it serves the view.
+ */
+declare const SUBSCRIBER_CREDIT_CAPABILITY = "credits.read";
+/**
+ * The manifest capability that announces recording a payout the operator
+ * made outside the gateway, beside the view of the credits.
+ */
+declare const SUBSCRIBER_PAYOUT_CAPABILITY = "credits.payout";
+/** What paid a credit out, or gave it back, as the operator reads it. */
+interface AdminSubscriberCreditEntry {
+    kind: SubscriberCreditEntryKind;
+    amount: number;
+    /** The refund's or the reversal's reference at the gateway, or the payout's. */
+    reference: string | null;
+    /** The day a payout left; `null` for a refund's entries. */
+    paidOn: CalendarDay | null;
+    note: string | null;
+    /** ISO 8601. */
+    recordedAt: string;
+}
+/** A credit as the operator reads it: where it comes from, what was paid out, what is open. */
+interface AdminSubscriberCredit {
     id: string;
-    /** What the customer quotes, and what an invoice will carry. */
-    customerNumber: string;
-    legalName: string;
+    amount: number;
+    currency: string;
+    /**
+     * The payment that brought more than its invoice owed, the invoice whose
+     * total is negative, or the reversal the gateway gave back.
+     */
+    origin: {
+        kind: 'payment';
+        paymentRef: string;
+        invoiceNumber: string | null;
+    } | {
+        kind: 'invoice';
+        invoiceNumber: string | null;
+    } | {
+        kind: 'reversal';
+        reversalRef: string;
+        invoiceNumber: string | null;
+    };
+    /** ISO 8601. */
+    createdAt: string;
+    open: number;
+    entries: AdminSubscriberCreditEntry[];
 }
-/** One charge of an account, with the name its contract line gives it. */
-interface AdminAccountEntry {
-    /** The charge as the journal holds it. */
-    charge: SubscriberCharge;
+/** A tenant's credits as the operator reads them, the oldest first. */
+interface AdminSubscriberCredits {
+    credits: AdminSubscriberCredit[];
     /**
-     * The contract line's own title, as it was when the contract was
-     * concluded, or `null` where that line cannot be read.
+     * The installation's time zone, in which a payout's day is judged: no
+     * payout lies after today there, wherever the operator sits.
      */
-    title: string | null;
+    timeZone: string;
 }
-/**
- * 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[];
+/** A payout the operator records against a credit. */
+interface AdminSubscriberPayout {
+    amount: number;
+    reference: string;
+    paidOn: CalendarDay;
+    note?: string | null;
 }
 
 /**
@@ -5381,6 +7031,26 @@ interface SubscriptionBundleRepository {
      * 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
@@ -5565,6 +7235,405 @@ 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[]>;
+}
+/**
+ * The attempts to collect an invoice through its payment gateway.
+ *
+ * An invoice has at most one attempt that is open — planned, or sent and not
+ * settled — and none after one succeeded: the database holds that
+ * (`sql/constraints.postgres.sql`), and the turn holds it against two runs
+ * that start at once. Every write that settles
+ * or takes on an attempt names the state it expects, so of two runs one wins
+ * and the other is told.
+ *
+ * Platform-wide: the run reads across tenants inside `RlsBypassPort`.
+ */
+interface InvoiceCollectionRepository {
+    /**
+     * The invoices to collect on `today`, by id, at most `limit`, after `after`
+     * where it is given: issued with a payment method to collect with, handed
+     * to the mail — so their announcement has reached the subscriber — with no
+     * collection date or one on or before `today`, and no attempt yet, planned
+     * or sent.
+     */
+    listDue(today: CalendarDay, page: {
+        limit: number;
+        after?: string;
+    }, tx?: TransactionContext): Promise<string[]>;
+    /**
+     * Starts the invoice's first attempt in its turn and returns it, written as
+     * `SUBMITTED` before its request leaves; `null`, writing nothing, where the
+     * invoice owes nothing — its total no more than what is settled against
+     * it in `subscription_invoice_settlements` — or has an attempt already —
+     * every later one is planned (`plan`), so
+     * a run that found the invoice due before another run's attempt failed
+     * does not charge it again at once. The turn is the invoice's
+     * own row, locked for the transaction — the chain of one invoice, which a
+     * cancellation's replacement joins — so a cancellation never meets an
+     * attempt about to be sent without knowing it (`SC-PRIC-036`). The attempt
+     * is numbered after the invoice's last, and its key is
+     * `collectionAttemptKey(invoiceId, attempt)`.
+     */
+    startAttempt(attempt: NewInvoiceCollection, tx?: TransactionContext): Promise<InvoiceCollectionRecord | null>;
+    /**
+     * Plans the invoice's next attempt in its turn, as `startAttempt` starts
+     * one, and returns it, written as `SCHEDULED` for `plan.collectOn` with
+     * nothing sent; `null`, writing nothing, where the invoice owes nothing,
+     * where an attempt of it is open or one succeeded, or where its last
+     * attempt is not the one numbered `plan.after` any more.
+     */
+    plan(plan: PlannedInvoiceCollection, tx?: TransactionContext): Promise<InvoiceCollectionRecord | null>;
+    /**
+     * Records that a planned direct debit's announcement reached the subscriber
+     * at `at`, naming `collectOn`, and returns `true`; `false`, writing nothing,
+     * where it is not planned or was announced already.
+     */
+    announce(id: string, collectOn: CalendarDay, at: Date, tx?: TransactionContext): Promise<boolean>;
+    /**
+     * Takes a planned attempt up as sent — `SUBMITTED`, sent and held at `at` —
+     * in its invoice's turn, as `startAttempt` writes one, before its request
+     * leaves, and returns it; `null`, writing nothing, where it is not planned
+     * any more, so of two runs one sends it, or where its invoice owes nothing,
+     * a payment having come for it meanwhile.
+     */
+    submitPlanned(id: string, at: Date, tx?: TransactionContext): Promise<SubmittedInvoiceCollection | null>;
+    /**
+     * Withdraws a planned attempt that will not be made, at `at`, in its
+     * invoice's turn, and returns `true`; `false`, writing nothing, where it is
+     * not planned.
+     */
+    withdraw(id: string, at: Date, tx?: TransactionContext): Promise<boolean>;
+    /** The planned attempts, by id and page as above, whatever their day. */
+    listPlanned(page: {
+        limit: number;
+        after?: string;
+    }, tx?: TransactionContext): Promise<string[]>;
+    /**
+     * The failed and the reversed attempts, by id and page as above, whose
+     * follow-up is not recorded yet.
+     */
+    listToFollowUp(page: {
+        limit: number;
+        after?: string;
+    }, tx?: TransactionContext): Promise<string[]>;
+    /**
+     * The invoices, by id and page as above, that another payment method can
+     * collect: their last attempt was withdrawn, or failed or was reversed and
+     * was followed up, every attempt of theirs that was reversed was followed
+     * up, and their subscriber has a payment method in use other than the one
+     * the last attempt was made with and than every one a reversed attempt was
+     * made with (`subscriber_payment_methods`), and they still owe something.
+     * An invoice whose failed or reversed payment method is still in use, or
+     * whose subscriber has none, is not read until that changes.
+     */
+    listCollectableAgain(page: {
+        limit: number;
+        after?: string;
+    }, tx?: TransactionContext): Promise<string[]>;
+    /**
+     * Records that what follows a failed or a reversed attempt was decided, at
+     * `at`, and returns `true`; `false`, writing nothing, where it neither
+     * failed nor was reversed, or was followed up already.
+     */
+    markFollowedUp(id: string, at: Date, tx?: TransactionContext): Promise<boolean>;
+    /**
+     * Marks the attempt whose payment a reversal took back as `REVERSED`, at
+     * `at`, where the reversal opened its invoice again, and returns `true`;
+     * `false`, writing nothing, where it is neither `SUCCEEDED` nor `FAILED`.
+     * A failed one brought its payment late, beside another attempt of its
+     * invoice (`recordOutcome`). Either is followed up again, as a reversal;
+     * the invoice is then collected only by an attempt with another payment
+     * method than every reversed one, planned once the reversal is followed up.
+     */
+    markReversed(id: string, at: Date, tx?: TransactionContext): Promise<boolean>;
+    /**
+     * Records what became of an attempt that is not settled — `SUBMITTED` or
+     * `PENDING` — and returns `true`; `false`, writing nothing, where it is
+     * settled already. `PENDING` stays open; `SUCCEEDED` and `FAILED` settle it
+     * at `at`.
+     *
+     * A success reported for an attempt recorded as `FAILED` is the money
+     * arriving after all: in the invoice's turn, an attempt planned after it
+     * is withdrawn, and the attempt succeeds and `true` is returned — unless
+     * another attempt of the invoice is on its way or succeeded, which leaves
+     * it failed and returns `false`.
+     */
+    recordOutcome(id: string, outcome: CollectionOutcome, at: Date, tx?: TransactionContext): Promise<boolean>;
+    /**
+     * Decides, in the invoice's turn — the one a payment is recorded in —,
+     * what becomes of a `SUBMITTED` attempt whose request never reached the
+     * gateway: where its invoice owes nothing it is settled as
+     * `COLLECTION_NOT_SENT_PAID` at `at` (`abandoned`); where it is still
+     * `SUBMITTED` and the invoice owes, it is to be sent again (`resend`),
+     * and is held from `at`; where a report settled it or put it on its way
+     * meanwhile, nothing is (`settled`). Both `abandoned` and `resend` rest on
+     * a write conditioned on the attempt still being `SUBMITTED`, so a report
+     * recorded outside the invoice's turn — a failure, an answer that it is on
+     * its way — while the run decides is found rather than overlooked. A run
+     * asks it before it sends such a request again, so a payment that arrived
+     * meanwhile is never charged a second time.
+     */
+    abandonPaid(id: string, at: Date, tx?: TransactionContext): Promise<AbandonPaidOutcome>;
+    /**
+     * Takes on an attempt that is not settled for the run calling it at `at`,
+     * where no run took it on since `heldBefore`, and returns `true`; of two
+     * concurrent calls exactly one does.
+     */
+    hold(id: string, heldBefore: Date, at: Date, tx?: TransactionContext): Promise<boolean>;
+    /**
+     * The attempts a run should take on again, by id and page as above:
+     * `SUBMITTED` ones no run took on since `submittedBefore` — their answer
+     * was lost —, and `PENDING` ones none took on since `pendingBefore`.
+     */
+    listUnsettled(before: {
+        submittedBefore: Date;
+        pendingBefore: Date;
+    }, page: {
+        limit: number;
+        after?: string;
+    }, tx?: TransactionContext): Promise<string[]>;
+    findById(id: string, tx?: TransactionContext): Promise<InvoiceCollectionRecord | null>;
+    /** The attempt `attemptKey` names — the key the gateway keeps with what it created — or `null`. */
+    findByKey(attemptKey: string, tx?: TransactionContext): Promise<InvoiceCollectionRecord | null>;
+    /** Every attempt of one invoice, the first first. */
+    listByInvoice(invoiceId: string, tx?: TransactionContext): Promise<InvoiceCollectionRecord[]>;
+    /**
+     * Every gateway account an attempt that is not settled was sent to, each
+     * once — the accounts that have to stay configured until their attempts
+     * settle, since only the account can say what became of them
+     * (`SC-PRIC-030`). Platform-wide: a start asks it before anything is
+     * served, through `RlsBypassPort`.
+     */
+    accountsInUse(tx?: TransactionContext): Promise<string[]>;
+}
+/**
+ * What money moved between a subscriber and the operator: the payments the
+ * gateway confirmed, what each settles of its invoice, the credits the
+ * subscriber is owed, the refunds and payouts that pay them out, the reversals
+ * that take a payment back and give it back again, and the cases nothing
+ * matched (`SC-PRIC-029`, `SC-PRIC-083`, `SC-PRIC-084`, `SC-PRIC-086`,
+ * `SC-ADM-033`). Nothing is edited once written but a refund's status, what a
+ * reversal withdrew and gave back, and a case's closing; every other change is
+ * an entry of its own.
+ *
+ * Platform-wide: the gateway's callbacks and the run read across tenants
+ * inside `RlsBypassPort`.
+ */
+interface SubscriberPaymentRepository {
+    /**
+     * Records a payment the gateway confirmed for an invoice, in the invoice's
+     * turn (`SC-PRIC-036`): it settles what the invoice still owes, and what it
+     * brought beyond that is a credit on the subscriber's account. Returns what
+     * it did; `null`, writing nothing, where a payment is recorded under the
+     * same gateway account and reference already, however it was reported
+     * then (`SC-PRIC-029`). Throws for an invoice that does not exist, and for
+     * a payment in another currency than its invoice's.
+     */
+    recordPayment(payment: NewSubscriberPayment, tx?: TransactionContext): Promise<RecordedSubscriberPayment | null>;
+    /**
+     * Credits an invoice whose total is negative to its subscriber, at `at`,
+     * and returns the credit; `null`, writing nothing, where it is credited
+     * already or its total is not negative.
+     */
+    creditInvoice(invoiceId: string, at: Date, tx?: TransactionContext): Promise<SubscriberCreditRecord | null>;
+    /**
+     * The invoices whose total is negative and that are not credited yet, by
+     * id, at most `limit`, after `after` where it is given.
+     */
+    listUncredited(page: {
+        limit: number;
+        after?: string;
+    }, tx?: TransactionContext): Promise<string[]>;
+    /**
+     * Records a refund the gateway reported against the payment it pays back.
+     * Seen for the first time, it is divided across the subscriber's open
+     * credits in its currency — the credit that payment left first, then the
+     * oldest — and what none takes matches nothing, a case to reconcile. Seen
+     * again as failed or canceled, it gives back what it paid out of each
+     * credit, once, and closes its case. Every credit it reads is held for the
+     * transaction, so a payout or another refund at the same moment waits for
+     * it.
+     */
+    recordRefund(refund: ReportedSubscriberRefund, tx?: TransactionContext): Promise<RecordedSubscriberRefund>;
+    /**
+     * Records a payout the operator made outside the gateway against one
+     * credit, holding the credit for the transaction; nothing is written where
+     * the credit does not exist or owes less than the payout.
+     */
+    recordPayout(payout: NewSubscriberPayout, tx?: TransactionContext): Promise<RecordedSubscriberPayout>;
+    /** The subscriber's credits, the oldest first, each with its entries and what it still owes. */
+    listCredits(subscriberId: string, tx?: TransactionContext): Promise<SubscriberCreditStanding[]>;
+    /** The payment recorded under `id`, or `null`. */
+    findPaymentById(id: string, tx?: TransactionContext): Promise<SubscriberPaymentRecord | null>;
+    /** The reversal recorded under `id`, or `null`. */
+    findReversalById(id: string, tx?: TransactionContext): Promise<SubscriberReversalRecord | null>;
+    /** The payment recorded under a gateway account and reference, or `null`. */
+    findPaymentByRef(gatewayAccount: string, gatewayRef: string, tx?: TransactionContext): Promise<SubscriberPaymentRecord | null>;
+    /** The payments recorded for an invoice, the first first. */
+    listPaymentsByInvoice(invoiceId: string, tx?: TransactionContext): Promise<SubscriberPaymentRecord[]>;
+    /** What an invoice still owes after what is settled against it; `null` where it does not exist. */
+    owedBy(invoiceId: string, tx?: TransactionContext): Promise<number | null>;
+    /**
+     * What each of `invoiceIds` still owes, for every one that exists, in one
+     * read.
+     */
+    owedByInvoices(invoiceIds: readonly string[], tx?: TransactionContext): Promise<{
+        invoiceId: string;
+        owed: number;
+    }[]>;
+    /**
+     * Records a reversal the gateway reported against the payment it takes
+     * back, in the turn of that payment's invoice (`SC-PRIC-036`), with every
+     * credit of its subscriber held. What it withdrew and what the gateway gave
+     * back of it are reported in total; what grew since it was last recorded is
+     * applied, once however often and in whatever order it is reported. What it
+     * newly withdrew takes from the credit the payment left first — its open
+     * part shrinks it, its part already paid out is a case to reconcile —, then
+     * opens again the invoices the payment settles, the oldest first, and what
+     * exceeds both is a case as well (`SC-PRIC-084`). What it would open again
+     * is taken first of the open credits that other payments collected for
+     * those invoices left, the oldest first (`SC-PRIC-087`). What it takes of
+     * the payment's own credit beyond the open part lifts the covers that
+     * credit gave other reversals before it counts as paid out: each is given
+     * back to the credit, and its reversal opens the invoice by it
+     * (`SC-PRIC-088`, `ReversalWithdrawal.uncovered`). What the gateway gives
+     * back returns to the payment's own credit before the covering ones. What the gateway newly
+     * gave back covers the reversal's cases first, closing each it covers, then
+     * gives back what it took of the credit, then settles again what it opened
+     * as far as the invoice still owes, and what an invoice no longer owes is a
+     * credit (`SC-PRIC-086`). Throws for a reversal in another currency than
+     * its payment.
+     */
+    recordReversal(reversal: ReportedSubscriberReversal, tx?: TransactionContext): Promise<RecordedSubscriberReversal>;
+    /**
+     * The cases to reconcile in `state`, the oldest first — of one subscriber
+     * where `subscriberId` is given —, at most `limit`, after the case `after`
+     * names where it is given.
+     */
+    listCases(filter: {
+        state: ReconciliationCaseState;
+        subscriberId?: string;
+    }, page: {
+        limit: number;
+        after?: string;
+    }, tx?: TransactionContext): Promise<SubscriberReconciliationCaseRecord[]>;
+    /** Closes an open case with the operator's note, once. */
+    closeCase(close: CloseReconciliationCase, tx?: TransactionContext): Promise<ClosedReconciliationCase>;
+    /**
+     * Every gateway account a payment was collected at whose credit is still
+     * owed, in part or whole, each once — the accounts that have to stay
+     * configured, so a refund made there is recorded against the credit
+     * (`SC-PRIC-030`). Platform-wide, asked at the start through
+     * `RlsBypassPort`.
+     */
+    accountsHoldingCredits(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
@@ -5659,7 +7728,7 @@ interface SubscriptionUsageRecord {
      * `null` for subscriptions that did not originate from a CheckoutOffer
      * (direct creation, migration).
      */
-    packageSnapshot?: unknown | null;
+    packageSnapshot?: unknown;
     /**
      * P11.4: reference to the original `CheckoutOffer.id`. Mostly not needed
      * for the UI (the snapshot is self-contained), but useful for support
@@ -5907,6 +7976,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;
@@ -5976,6 +8053,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
@@ -7104,6 +9197,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`. */
@@ -7191,6 +9323,17 @@ 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>;
+    /** The attempts to collect those invoices (`chargeJournal.invoices.collections`). */
+    invoiceCollectionRepository?: PersistenceProvider<InvoiceCollectionRepository>;
+    /**
+     * The payments those collections brought, the credits and what pays them
+     * out (`chargeJournal.invoices.payments`).
+     */
+    subscriberPaymentRepository?: PersistenceProvider<SubscriberPaymentRepository>;
     subscriptionBundleRepository?: PersistenceProvider<SubscriptionBundleRepository>;
     bundleRepository?: PersistenceProvider<BundleRepository>;
 }
@@ -7234,6 +9377,11 @@ interface SaaSiCatPersistenceTenantBilling {
      * 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
@@ -7677,6 +9825,79 @@ declare const BILLING_ERROR_CODES: {
      * 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. */
@@ -7823,6 +10044,94 @@ declare const CONTRACT_ERROR_CODES: {
     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";
+    /**
+     * The subscriber's direct debit names no mandate reference
+     * (`paymentMethodId`), which has to be announced before it is debited
+     * (`SC-PRIC-028`). An invoice collected by it draws no number, and one
+     * planned with it is not announced, until the payment method is replaced.
+     */
+    readonly SUBSCRIPTION_INVOICE_MANDATE_MISSING: "SUBSCRIPTION_INVOICE_MANDATE_MISSING";
+    /**
+     * The subscriber (`subscriberId`) has no payment method in use, so the
+     * invoice is not collected until one is (`SC-PRIC-082`).
+     */
+    readonly SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD: "SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD";
+    /**
+     * A direct debit announced again after a failed collection (`attemptKey`)
+     * waits until the subscriber has been told of that failure
+     * (`SC-PRIC-080`).
+     */
+    readonly SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD: "SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD";
+    /**
+     * A file of the invoice's document has another checksum than the one
+     * recorded or archived for it (`invoiceId`, `recorded`, `rendered`), and
+     * the first stays. The run takes the archived file as the one issued, or —
+     * where nothing is archived — records the new rendering in place of the
+     * old (`SC-AUD-019`); the invoice waits only where another run changed the
+     * record or the archive in between, and the next run settles it.
+     */
+    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";
+    /** No credit under this id for the tenant's subscriber (`creditId`). */
+    readonly SUBSCRIBER_CREDIT_NOT_FOUND: "SUBSCRIBER_CREDIT_NOT_FOUND";
+    /**
+     * A payout of more than the credit still owes (`creditId`, `open`): nothing
+     * is paid out beyond it (`SC-PRIC-083`), and nothing is recorded.
+     */
+    readonly SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT: "SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT";
+    /**
+     * A payout on a day still to come (`paidOn`, `today` in the installation's
+     * zone): a payout is recorded once it left.
+     */
+    readonly SUBSCRIBER_PAYOUT_NOT_MADE_YET: "SUBSCRIBER_PAYOUT_NOT_MADE_YET";
+    /** No case to reconcile under this id (`caseId`). */
+    readonly SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND: "SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND";
+    /**
+     * A case closed before (`caseId`, `closedAt`), by the operator or by
+     * SaaSiCat; its note stands, and nothing is written (`SC-ADM-033`).
+     */
+    readonly SUBSCRIBER_RECONCILIATION_CASE_CLOSED: "SUBSCRIBER_RECONCILIATION_CASE_CLOSED";
+};
+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: {
     /**
@@ -8118,28 +10427,112 @@ declare const PLATFORM_ERROR_CODES: {
     /** 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.
+     * 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";
+    /**
+     * The subscriber's direct debit names no mandate reference
+     * (`paymentMethodId`), which has to be announced before it is debited
+     * (`SC-PRIC-028`). An invoice collected by it draws no number, and one
+     * planned with it is not announced, until the payment method is replaced.
+     */
+    readonly SUBSCRIPTION_INVOICE_MANDATE_MISSING: "SUBSCRIPTION_INVOICE_MANDATE_MISSING";
+    /**
+     * The subscriber (`subscriberId`) has no payment method in use, so the
+     * invoice is not collected until one is (`SC-PRIC-082`).
+     */
+    readonly SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD: "SUBSCRIPTION_INVOICE_NO_PAYMENT_METHOD";
+    /**
+     * A direct debit announced again after a failed collection (`attemptKey`)
+     * waits until the subscriber has been told of that failure
+     * (`SC-PRIC-080`).
+     */
+    readonly SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD: "SUBSCRIPTION_INVOICE_FAILURE_NOT_TOLD";
+    /**
+     * A file of the invoice's document has another checksum than the one
+     * recorded or archived for it (`invoiceId`, `recorded`, `rendered`), and
+     * the first stays. The run takes the archived file as the one issued, or —
+     * where nothing is archived — records the new rendering in place of the
+     * old (`SC-AUD-019`); the invoice waits only where another run changed the
+     * record or the archive in between, and the next run settles it.
+     */
+    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 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";
+    readonly SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL: "SUBSCRIPTION_INVOICE_NO_INVOICE_EMAIL";
+    /** No credit under this id for the tenant's subscriber (`creditId`). */
+    readonly SUBSCRIBER_CREDIT_NOT_FOUND: "SUBSCRIBER_CREDIT_NOT_FOUND";
     /**
-     * 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.
+     * A payout of more than the credit still owes (`creditId`, `open`): nothing
+     * is paid out beyond it (`SC-PRIC-083`), and nothing is recorded.
      */
-    readonly SUBSCRIBER_IDENTITY_INCOMPLETE: "SUBSCRIBER_IDENTITY_INCOMPLETE";
+    readonly SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT: "SUBSCRIBER_PAYOUT_EXCEEDS_CREDIT";
     /**
-     * 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`).
+     * A payout on a day still to come (`paidOn`, `today` in the installation's
+     * zone): a payout is recorded once it left.
      */
-    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";
+    readonly SUBSCRIBER_PAYOUT_NOT_MADE_YET: "SUBSCRIBER_PAYOUT_NOT_MADE_YET";
+    /** No case to reconcile under this id (`caseId`). */
+    readonly SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND: "SUBSCRIBER_RECONCILIATION_CASE_NOT_FOUND";
+    /**
+     * A case closed before (`caseId`, `closedAt`), by the operator or by
+     * SaaSiCat; its note stands, and nothing is written (`SC-ADM-033`).
+     */
+    readonly SUBSCRIBER_RECONCILIATION_CASE_CLOSED: "SUBSCRIBER_RECONCILIATION_CASE_CLOSED";
     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";
@@ -8447,6 +10840,79 @@ declare const PLATFORM_ERROR_CODES: {
      * 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. */
@@ -8674,7 +11140,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 | TaxErrorCode;
+type PlatformErrorCode = SetupErrorCode | AuthErrorCode | PromoErrorCode | CatalogErrorCode | BillingErrorCode | ContractErrorCode | InvoiceErrorCode | SubscriberErrorCode | RegistrationErrorCode | PaymentErrorCode | SettingsErrorCode | MaintenanceErrorCode | TaxErrorCode;
 /**
  * Shape of a coded error response.
  *
@@ -8759,7 +11225,21 @@ declare const OPTIONAL_CANONICAL_MODELS: {
     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 SubscriptionInvoiceCollection: readonly ["entitlement.invoiceCollectionRepository", "entitlement.subscriberPaymentRepository"];
+    readonly SubscriberPayment: readonly ["entitlement.subscriberPaymentRepository", "entitlement.invoiceCollectionRepository"];
+    readonly SubscriptionInvoiceSettlement: readonly ["entitlement.subscriberPaymentRepository", "entitlement.invoiceCollectionRepository"];
+    readonly SubscriberCredit: readonly ["entitlement.subscriberPaymentRepository", "entitlement.invoiceCollectionRepository"];
+    readonly SubscriberCreditEntry: readonly ["entitlement.subscriberPaymentRepository", "entitlement.invoiceCollectionRepository"];
+    readonly SubscriberRefund: readonly ["entitlement.subscriberPaymentRepository", "entitlement.invoiceCollectionRepository"];
+    readonly SubscriberReversal: readonly ["entitlement.subscriberPaymentRepository", "entitlement.invoiceCollectionRepository"];
+    readonly SubscriberReconciliationCase: readonly ["entitlement.subscriberPaymentRepository", "entitlement.invoiceCollectionRepository"];
     readonly PromoCodeHold: readonly ["promo.holdRepository"];
 };
 type OptionalCanonicalModel = keyof typeof OPTIONAL_CANONICAL_MODELS;
@@ -9765,6 +12245,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
@@ -9806,6 +12290,865 @@ 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;
+    /** `null` on an invoice that is not collected, and on one issued before invoices recorded it. */
+    payment: unknown;
+    collectionDate: 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;
+    payment: SubscriptionInvoicePayment | null;
+    collectionDate: CalendarDay | null;
+    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, unless collected by direct debit (`SC-PRIC-046`). */
+    paymentTermDays: number;
+    /**
+     * The subscriber's payment method as `invoicePaymentOf` records it, or
+     * `null` where it has none that can be collected.
+     */
+    payment: SubscriptionInvoicePayment | null;
+    /** Days from the issue date to the day a direct debit is collected (`SC-PRIC-028`). */
+    directDebitLeadDays: number;
+}
+/**
+ * Calendar days a direct debit is announced before it is collected where
+ * `config/saas.yaml#invoicing` names none: the SEPA rulebook's own notice.
+ */
+declare const DIRECT_DEBIT_LEAD_DAYS = 14;
+/** The lead time `invoicing` names, or `DIRECT_DEBIT_LEAD_DAYS`. */
+declare function directDebitLeadDaysOf(invoicing: Pick<PlanCatalogInvoicing, 'directDebitLeadDays'>): number;
+/**
+ * What an invoice records of the payment method it is collected with, or
+ * `null` where there is none to collect with: the subscriber has no payment
+ * method, or one that cannot be collected as an invoice announces it — a
+ * direct debit without the mandate reference its announcement has to quote
+ * (`SC-PRIC-028`).
+ */
+declare function invoicePaymentOf(method: Pick<SubscriberPaymentMethodRecord, 'id' | 'gatewayAccount' | 'type' | 'brand' | 'last4' | 'mandateReference'> | null): SubscriptionInvoicePayment | null;
+/**
+ * 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.
+ *
+ * An invoice that asks for an amount records the payment method it is
+ * collected with. A direct debit is collected the lead time after the issue
+ * date, which the invoice announces and falls due on; anything else falls due
+ * the payment term after it (`SC-PRIC-028`, `SC-PRIC-046`). An invoice that
+ * asks for nothing is collected with nothing.
+ *
+ * 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, and for
+ * a direct debit without its mandate reference, which `invoicePaymentOf`
+ * never hands over.
+ */
+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;
+
+/** Every status an attempt can stand in. */
+declare const INVOICE_COLLECTION_STATUSES: readonly InvoiceCollectionStatus[];
+/**
+ * The statuses of an attempt that has been sent and is not settled: the
+ * gateway is asked what became of it.
+ */
+declare const UNSETTLED_COLLECTION_STATUSES: readonly InvoiceCollectionStatus[];
+/**
+ * The statuses that keep an invoice from another attempt: one open — planned,
+ * or sent and not settled — or one that succeeded. An invoice has one at most,
+ * which `sql/constraints.postgres.sql` holds as well.
+ */
+declare const BLOCKING_COLLECTION_STATUSES: readonly InvoiceCollectionStatus[];
+/** The attempts what follows is decided for: a failure, and a reversal that opened the invoice again. */
+declare const FOLLOWED_UP_COLLECTION_STATUSES: readonly InvoiceCollectionStatus[];
+/**
+ * The statuses of an attempt whose payment a reversal can take back: one that
+ * succeeded, and one that failed before its payment arrived after all, beside
+ * another attempt of its invoice that was on its way or succeeded.
+ */
+declare const REVERSIBLE_COLLECTION_STATUSES: readonly InvoiceCollectionStatus[];
+/** What the turn reads of an invoice's attempts before it writes the next one. */
+interface EarlierCollection {
+    attempt: number;
+    status: string;
+}
+/** The number of the last of `earlier`, `0` for none. */
+declare function lastCollectionOf(earlier: readonly EarlierCollection[]): number;
+/**
+ * Whether the invoice's first attempt is refused: it has one already. Every
+ * later attempt is planned, so a run that found the invoice due before another
+ * run's attempt failed does not charge it again at once.
+ */
+declare function refusesFirstAttempt(earlier: readonly EarlierCollection[]): boolean;
+/**
+ * Whether a planned attempt that follows attempt `after` is refused: one of the
+ * invoice's attempts is open or succeeded, or another came after `after`.
+ */
+declare function refusesPlannedAttempt(earlier: readonly EarlierCollection[], after: number): boolean;
+/** Every reason a collection can fail for. */
+declare const COLLECTION_FAILURE_REASONS: readonly CollectionFailureReason[];
+/**
+ * A `subscription_invoice_collections` row as either adapter reads it back.
+ * `amount` is `unknown` because a Prisma row carries a `Decimal` where a
+ * Drizzle row carries a numeric string.
+ */
+interface CanonicalInvoiceCollectionRow {
+    id: string;
+    invoiceId: string;
+    attempt: number;
+    attemptKey: string;
+    gatewayAccount: string;
+    paymentMethodId: string;
+    paymentMethodType: string;
+    customerRef: string;
+    paymentMethodRef: string;
+    invoiceNumber: string;
+    amount: unknown;
+    currency: string;
+    status: string;
+    paymentRef: string | null;
+    failureReason: string | null;
+    failureCode: string | null;
+    submittedAt: Date | null;
+    heldAt: Date | null;
+    resolvedAt: Date | null;
+    /** A `date` column: a `Date` from Prisma, the text from Drizzle. */
+    collectOn: unknown;
+    announcedAt: Date | null;
+    followedUpAt: Date | null;
+}
+/**
+ * Reads an attempt row back as a record. An attempt that left carries the
+ * moment it left and was held at, and one that did not carries neither; a
+ * planned one carries its day. A row that breaks this is not one a run may act
+ * on: a planned attempt without a day would never be collected, and a sent one
+ * without a moment could not be asked about.
+ */
+declare function toInvoiceCollectionRecord(row: CanonicalInvoiceCollectionRow): InvoiceCollectionRecord;
+/** The columns an attempt is started with, numbered `attempt`. */
+interface InvoiceCollectionColumns {
+    invoiceId: string;
+    attempt: number;
+    attemptKey: string;
+    gatewayAccount: string;
+    paymentMethodId: string;
+    paymentMethodType: string;
+    customerRef: string;
+    paymentMethodRef: string;
+    invoiceNumber: string;
+    /** A decimal string of two places, as an invoice's amounts are written. */
+    amount: string;
+    currency: string;
+    status: InvoiceCollectionStatus;
+    submittedAt: Date | null;
+    heldAt: Date | null;
+    /** The day of a planned attempt; `null` for one written as sent. */
+    collectOn: string | null;
+}
+/** The columns of `attempt`, numbered `number`, written as submitted at its `at`. */
+declare function invoiceCollectionColumns(attempt: NewInvoiceCollection, number: number): InvoiceCollectionColumns;
+/** The columns of `plan`, numbered `number`, written as planned for its day. */
+declare function plannedCollectionColumns(plan: PlannedInvoiceCollection, number: number): InvoiceCollectionColumns;
+/** The columns an outcome sets: `PENDING` leaves the attempt open, the others settle it at `at`. */
+declare function collectionOutcomeColumns(outcome: CollectionOutcome, at: Date): {
+    status: InvoiceCollectionStatus;
+    paymentRef: string | null;
+    failureReason: CollectionFailureReason | null;
+    failureCode: string | null;
+    resolvedAt: Date | null;
+};
+
+/** How many days after a failure the same payment method is charged once more. */
+declare const COLLECTION_RETRY_AFTER_DAYS = 7;
+/**
+ * Whether the payment method a failed attempt charged is charged once more:
+ * its reason can pass, and no other attempt of the invoice failed with that
+ * payment method. A replacement gets its own second try.
+ */
+declare function isChargedAgain(failed: InvoiceCollectionRecord, attempts: readonly InvoiceCollectionRecord[]): boolean;
+/** The day the same payment method is charged again after a failure on `failedOn`. */
+declare function chargedAgainOn(failedOn: CalendarDay): CalendarDay;
+/**
+ * The day a direct debit announced on `announcedOn` is collected: the lead
+ * time after its announcement, and never before `earliest`.
+ */
+declare function announcedCollectionDay(earliest: CalendarDay, announcedOn: CalendarDay, leadDays: number): CalendarDay;
+
+/** A recorded `collection-failed` notice, `id` being its record's. */
+declare function toCollectionFailedNotice(content: unknown, id: string): CollectionFailedNotice;
+/** A recorded `collection-announced` notice, `id` being its record's. */
+declare function toCollectionAnnouncedNotice(content: unknown, id: string): CollectionAnnouncedNotice;
+/** A recorded `collection-reversed` notice, `id` being its record's. */
+declare function toCollectionReversedNotice(content: unknown, id: string): CollectionReversedNotice;
+
+/**
+ * What an entry against an invoice is: a payment that settles it, a reversal
+ * that opens it again by part of what a payment settled, and the same part
+ * settled again where the gateway gave the reversal back.
+ */
+type InvoiceSettlementKind = 'PAYMENT' | 'REVERSAL' | 'REINSTATEMENT';
+declare const INVOICE_SETTLEMENT_KINDS: readonly InvoiceSettlementKind[];
+/**
+ * The settlements that add back to what an invoice owes rather than take off
+ * it; an adapter that sums settlements in SQL passes it as a parameter, so the
+ * sign is decided here alone.
+ */
+declare const REOPENING_SETTLEMENT_KINDS: readonly InvoiceSettlementKind[];
+declare const SUBSCRIBER_CREDIT_ENTRY_KINDS: readonly SubscriberCreditEntryKind[];
+declare const SUBSCRIBER_REFUND_STATUSES: readonly SubscriberRefundStatus[];
+/** The statuses of a refund that gave its money back to the operator. */
+declare const ENDED_REFUND_STATUSES: readonly SubscriberRefundStatus[];
+/** Whether a refund in `status` gave its money back. */
+declare function isEndedRefund(status: SubscriberRefundStatus): boolean;
+/** A `subscriber_payments` row as either adapter reads it back. */
+interface CanonicalSubscriberPaymentRow {
+    id: string;
+    subscriberId: string;
+    tenantId: string;
+    invoiceId: string;
+    collectionId: string;
+    gatewayAccount: string;
+    provider: string;
+    gatewayRef: string;
+    amount: unknown;
+    currency: string;
+    recordedAt: Date;
+}
+declare function toSubscriberPaymentRecord(row: CanonicalSubscriberPaymentRow): SubscriberPaymentRecord;
+/** The columns a payment is written with, for the subscriber its invoice names. */
+declare function subscriberPaymentColumns(payment: NewSubscriberPayment, invoice: {
+    subscriberId: string;
+    tenantId: string;
+}): Omit<CanonicalSubscriberPaymentRow, 'id' | 'amount'> & {
+    amount: string;
+};
+/** A `subscription_invoice_settlements` row, as far as what an invoice owes reads it. */
+interface CanonicalInvoiceSettlementRow {
+    id: string;
+    kind: string;
+    amount: unknown;
+}
+/**
+ * The amount a settlement row takes off what its invoice owes: positive for a
+ * payment and a reinstatement, negative for a reversal, which opens the invoice
+ * again. Its kind is checked, so a kind a later release writes stops the read
+ * rather than being counted as a payment.
+ */
+declare function settledAmountOf(row: CanonicalInvoiceSettlementRow): number;
+/** A `subscriber_credits` row as either adapter reads it back. */
+interface CanonicalSubscriberCreditRow {
+    id: string;
+    subscriberId: string;
+    tenantId: string;
+    amount: unknown;
+    currency: string;
+    originPaymentId: string | null;
+    originInvoiceId: string | null;
+    originReversalId: string | null;
+    createdAt: Date;
+}
+/**
+ * Reads a credit back. It comes from exactly one place — a payment, an invoice
+ * or a reversal given back — which the database holds as well; a row that
+ * names several or none cannot be paid out against anything.
+ */
+declare function toSubscriberCreditRecord(row: CanonicalSubscriberCreditRow): SubscriberCreditRecord;
+/** A `subscriber_credit_entries` row as either adapter reads it back. */
+interface CanonicalSubscriberCreditEntryRow {
+    id: string;
+    creditId: string;
+    kind: string;
+    amount: unknown;
+    refundId: string | null;
+    reversalId: string | null;
+    reference: string | null;
+    /** A `date` column: a `Date` from Prisma, the text from Drizzle. */
+    paidOn: unknown;
+    recordedBy: string | null;
+    note: string | null;
+    recordedAt: Date;
+}
+declare function toSubscriberCreditEntryRecord(row: CanonicalSubscriberCreditEntryRow): SubscriberCreditEntryRecord;
+/**
+ * The columns of an entry a refund writes against one credit, carrying the
+ * refund's own reference at the gateway, which the operator finds it under.
+ */
+declare function refundEntryColumns(creditId: string, refund: {
+    id: string;
+    gatewayRef: string;
+}, kind: 'REFUND' | 'REFUND_FAILED', amount: number, at: Date): Omit<CanonicalSubscriberCreditEntryRow, 'id' | 'amount' | 'paidOn'> & {
+    amount: string;
+    paidOn: null;
+};
+/** The columns of the entry a payout writes against its credit. */
+declare function payoutEntryColumns(payout: NewSubscriberPayout): Omit<CanonicalSubscriberCreditEntryRow, 'id' | 'amount' | 'paidOn'> & {
+    amount: string;
+    paidOn: string;
+};
+/** A `subscriber_refunds` row as either adapter reads it back. */
+interface CanonicalSubscriberRefundRow {
+    id: string;
+    subscriberId: string;
+    paymentId: string;
+    gatewayAccount: string;
+    gatewayRef: string;
+    amount: unknown;
+    currency: string;
+    status: string;
+    recordedAt: Date;
+    endedAt: Date | null;
+}
+declare function toSubscriberRefundRecord(row: CanonicalSubscriberRefundRow): SubscriberRefundRecord;
+/** The columns a refund is first written with, against the payment it pays back. */
+declare function subscriberRefundColumns(refund: ReportedSubscriberRefund, payment: {
+    id: string;
+    subscriberId: string;
+}): Omit<CanonicalSubscriberRefundRow, 'id' | 'amount'> & {
+    amount: string;
+};
+/**
+ * The columns of an entry a reversal writes against one credit: what it takes
+ * of it, or gives back, carrying the reversal's own reference at the gateway.
+ */
+declare function reversalEntryColumns(creditId: string, reversal: {
+    id: string;
+    gatewayRef: string;
+}, kind: 'REVERSAL' | 'REVERSAL_TAKEN_BACK', amount: number, at: Date): Omit<CanonicalSubscriberCreditEntryRow, 'id' | 'amount' | 'paidOn'> & {
+    amount: string;
+    paidOn: null;
+};
+/** A `subscriber_reversals` row as either adapter reads it back. */
+interface CanonicalSubscriberReversalRow {
+    id: string;
+    subscriberId: string;
+    tenantId: string;
+    paymentId: string;
+    gatewayAccount: string;
+    gatewayRef: string;
+    amount: unknown;
+    currency: string;
+    fromCredit: unknown;
+    reinstated: unknown;
+    recordedAt: Date;
+    reinstatedAt: Date | null;
+}
+/**
+ * Reads a reversal back. What it took from the credit and what the gateway
+ * gave back are parts of what it withdrew, and a give-back carries when; a row
+ * that says otherwise stops the read.
+ */
+declare function toSubscriberReversalRecord(row: CanonicalSubscriberReversalRow): SubscriberReversalRecord;
+/**
+ * The columns a reversal is first written with, against the payment it takes
+ * back: nothing withdrawn or given back yet, which the entries it writes next
+ * raise.
+ */
+declare function subscriberReversalColumns(reversal: ReportedSubscriberReversal, payment: {
+    id: string;
+    subscriberId: string;
+    tenantId: string;
+}): Omit<CanonicalSubscriberReversalRow, 'id' | 'amount' | 'fromCredit' | 'reinstated'> & {
+    amount: string;
+    fromCredit: string;
+    reinstated: string;
+};
+
+/**
+ * What an invoice of `gross` still owes after the entries `settled` against
+ * it, each signed as `settledAmountOf` reads it — a reversal that opened the
+ * invoice again counts against what was settled; negative where it owes the
+ * subscriber, as an invoice whose total is negative does.
+ */
+declare function owedOn(gross: number, settled: readonly number[]): number;
+/**
+ * How a payment of `amount` divides against an invoice that still owes
+ * `owed`: it settles what is owed, and what it brought beyond that is a credit.
+ * An invoice that owes nothing, or owes the subscriber, is settled by nothing.
+ */
+declare function paymentSettlement(amount: number, owed: number): {
+    settles: number;
+    credits: number;
+};
+/**
+ * The entries that give back what an earlier entry paid out of a credit; an
+ * adapter that sums entries in SQL passes it as a parameter, so the sign is
+ * decided here alone.
+ */
+declare const GIVING_BACK_CREDIT_ENTRY_KINDS: readonly SubscriberCreditEntryKind[];
+/**
+ * What a credit of `amount` still owes after `entries`. Never below `0`: an
+ * entry that would take it there is not written.
+ */
+declare function openOfCredit(amount: number, entries: readonly {
+    kind: SubscriberCreditEntryKind;
+    amount: number;
+}[]): number;
+/** A credit as a refund is divided across it. */
+interface OpenCredit {
+    id: string;
+    origin: SubscriberCreditOrigin;
+    createdAt: Date;
+    /** What it still owes, from `openOfCredit`. */
+    open: number;
+}
+/**
+ * How a refund of `amount` that pays back payment `paymentId` divides across
+ * the subscriber's open credits: the credit that payment left first — the
+ * refund pays back what the subscriber overpaid with it —, then the oldest.
+ * What no open credit takes matches nothing, and is the operator's to
+ * reconcile.
+ */
+declare function refundParts(amount: number, paymentId: string, credits: readonly OpenCredit[]): {
+    parts: CreditPart[];
+    unmatched: number;
+};
+/** The credit a payment left, as a reversal of that payment reads it. */
+interface ReversibleCredit {
+    creditId: string;
+    /** What of the credit no reversal of the payment took yet, open or paid out. */
+    left: number;
+    /** What of the credit is still owed to the subscriber, from `openOfCredit`. */
+    open: number;
+}
+/**
+ * A credit that another payment collected for an invoice the reversed payment
+ * settles left, as the reversal reads it.
+ */
+interface CoveringCredit {
+    creditId: string;
+    /** What of the credit is still owed to the subscriber, from `openOfCredit`. */
+    open: number;
+}
+/** An invoice a payment settles, as a reversal of that payment reads it. */
+interface ReversibleInvoice {
+    invoiceId: string;
+    /** What the payment still settles there: its settlements less what reversals took back. */
+    left: number;
+}
+/** How a withdrawn amount divides across what its payment brought. */
+interface WithdrawalParts {
+    /** What it takes of the credit, open or paid out alike. */
+    fromCredit: number;
+    /** What it takes of the credit that is still open; `null` where nothing. */
+    credit: CreditPart | null;
+    /** What it takes of the covering credits instead of opening their invoices again, in the order given. */
+    covering: CreditPart[];
+    /** The invoices it opens again, in the order given, each by no more than the payment settles there. */
+    invoices: InvoicePart[];
+    /**
+     * What meets the part of the credit already paid out, and what goes beyond
+     * everything the payment brought: the operator's to reconcile.
+     */
+    unmatched: number;
+}
+/**
+ * How `amount`, newly withdrawn by a reversal of a payment, divides across what
+ * the payment brought: the credit it left first, so the operator is not left
+ * refunding what is owed again — its open part shrinks it, its part already
+ * paid out matches nothing —, then the invoices it settles, in the order given,
+ * the oldest first. What the reversal would open again of them is covered
+ * first by `covering`, the open credits other payments collected for those
+ * invoices left, in the order given: that money was collected for the same
+ * invoices, so it settles them rather than waiting to be paid out while they
+ * are collected again. Whatever exceeds the credit and the invoices matches
+ * nothing; no covering credit takes it.
+ */
+declare function withdrawalParts(amount: number, credit: ReversibleCredit | null, invoices: readonly ReversibleInvoice[], covering?: readonly CoveringCredit[]): WithdrawalParts;
+/** What a reversal took back that an amount the gateway gives back can return. */
+interface ReinstatableParts {
+    /** What of the reversal's unmatched amount is not covered by an earlier give-back yet. */
+    unmatched: number;
+    /** What it took of each credit and has not given back yet. */
+    credits: readonly {
+        creditId: string;
+        left: number;
+    }[];
+    /**
+     * What it opened again of each invoice and has not settled again yet, the
+     * oldest first, with what the invoice owes now.
+     */
+    invoices: readonly {
+        invoiceId: string;
+        left: number;
+        owed: number;
+    }[];
+}
+/** How an amount the gateway gives back divides across what its reversal took. */
+interface ReinstatementParts {
+    /** What covers the reversal's unmatched amount. */
+    covered: number;
+    /** What each credit is owed again. */
+    credits: CreditPart[];
+    /** What settles each invoice again, as far as it still owes. */
+    invoices: InvoicePart[];
+    /** What the invoices no longer owe — the subscriber paid them meanwhile —, as a credit. */
+    credited: number;
+    /** What goes beyond everything the reversal took, which nothing takes. */
+    beyond: number;
+}
+/**
+ * How `amount`, newly given back by the gateway for a reversal, takes it back
+ * part for part, in the reverse of how it was withdrawn: the unmatched part
+ * first — such as the refund the subscriber received before the dispute, which
+ * the gateway returns where the dispute is lost —, then what it took of the
+ * credits, then what it opened of the invoices, settling each again as far as
+ * it still owes. What an invoice no longer owes becomes a credit.
+ */
+declare function reinstatementParts(amount: number, took: ReinstatableParts): ReinstatementParts;
+/**
+ * What each invoice nets from `entries` — settlements signed as
+ * `settledAmountOf` reads them —, in whole cents, in the order the invoices
+ * first appear. Read over a payment's settlements, it is what the payment still
+ * settles on each; over a reversal's, the negative of what it opened and has
+ * not settled again.
+ */
+declare function netByInvoice(entries: readonly InvoicePart[]): InvoicePart[];
+/**
+ * What `entries` paid out of each credit, net of what they gave back, in whole
+ * cents, in the order the credits first appear. Read over a reversal's
+ * entries, it is what the reversal took of each credit and has not given back.
+ */
+declare function paidOutByCredit(entries: readonly {
+    creditId: string;
+    kind: SubscriberCreditEntryKind;
+    amount: number;
+}[]): CreditPart[];
+/**
+ * What other reversals took of one credit to cover what they would have opened
+ * of its invoice (`SC-PRIC-087`) and still hold: the credit's `entries` of
+ * reversals not in `own`, net of what was given back, in whole cents, in the
+ * order the reversals first appear. Where the credit's own payment is reversed
+ * as well, these covers are lifted first (`SC-PRIC-088`).
+ */
+declare function coversOf(entries: readonly {
+    reversalId: string | null;
+    kind: SubscriberCreditEntryKind;
+    amount: number;
+}[], own: ReadonlySet<string>): {
+    reversalId: string;
+    amount: number;
+}[];
+/**
+ * The covers a withdrawal lifts: what it takes of its payment's credit beyond
+ * the open part — `parts.fromCredit` less `parts.credit` — reaches the covers
+ * that credit gave other reversals (`coversOf`) before it counts as paid out,
+ * in the order given. Each lifted cover opens its reversal's invoice again;
+ * what it reaches beyond them stays unmatched (`SC-PRIC-088`).
+ */
+declare function coversLifted(parts: Pick<WithdrawalParts, 'fromCredit' | 'credit' | 'unmatched'>, covers: readonly {
+    reversalId: string;
+    amount: number;
+}[]): {
+    lifted: {
+        reversalId: string;
+        amount: number;
+    }[];
+    unmatched: number;
+};
+/**
+ * `parts` in the order a reversal of payment `paymentId` takes credits: the
+ * credit that payment left first, then the covering ones, the oldest first —
+ * so what the gateway gives back returns to them in that order, whatever order
+ * a database reads their entries in.
+ */
+declare function inWithdrawalOrder(parts: readonly CreditPart[], credits: readonly SubscriberCreditRecord[], paymentId: string): CreditPart[];
+/**
+ * The ids of `cases`, in the order given — the order they were opened —, that
+ * the first `covered` of what the gateway gave back covers in full.
+ */
+declare function casesCovered(cases: readonly {
+    id: string;
+    amount: number;
+}[], covered: number): string[];
+
+declare const RECONCILIATION_CASE_KINDS: readonly ReconciliationCaseKind[];
+/** A `subscriber_reconciliation_cases` row as either adapter reads it back. */
+interface CanonicalReconciliationCaseRow {
+    id: string;
+    subscriberId: string;
+    tenantId: string;
+    kind: string;
+    amount: unknown;
+    currency: string;
+    paymentId: string;
+    refundId: string | null;
+    reversalId: string | null;
+    gatewayAccount: string;
+    gatewayRef: string;
+    recordedAt: Date;
+    closedAt: Date | null;
+    closedBy: string | null;
+    note: string | null;
+}
+/**
+ * Reads a case back. It is about exactly what its kind says — a refund or a
+ * reversal —, and a closed case carries why it was closed; a row that says
+ * otherwise stops the read rather than reaching the operator's list as
+ * something it is not.
+ */
+declare function toSubscriberReconciliationCaseRecord(row: CanonicalReconciliationCaseRow): SubscriberReconciliationCaseRecord;
+/** What a case is opened about: a refund or a reversal, with the payment and its subscriber. */
+interface NewReconciliationCase {
+    kind: ReconciliationCaseKind;
+    amount: number;
+    currency: string;
+    payment: {
+        id: string;
+        subscriberId: string;
+        tenantId: string;
+    };
+    /** The refund's id, for a `REFUND_UNMATCHED`, or the reversal's. */
+    about: {
+        id: string;
+        gatewayAccount: string;
+        gatewayRef: string;
+    };
+    at: Date;
+}
+/** The columns a case is opened with. */
+declare function reconciliationCaseColumns(opened: NewReconciliationCase): Omit<CanonicalReconciliationCaseRow, 'id' | 'amount'> & {
+    amount: string;
+};
+/** Why SaaSiCat closes a case of a refund that failed or was canceled. */
+declare const CASE_CLOSED_REFUND_ENDED = "The refund failed or was canceled, and its money came back.";
+/** Why SaaSiCat closes a case of a reversal the gateway gave back. */
+declare const CASE_CLOSED_REVERSAL_GIVEN_BACK = "The gateway gave the reversal back, and with it what matched nothing.";
+
+/** Which column of which row a value came from, for the error that names it. */
+interface ColumnWhere {
+    table: string;
+    column: string;
+    id: string;
+}
+
+/** The amount a `numeric` column holds; throws, naming the column, for anything else. */
+declare function columnAmountOf(value: unknown, where: ColumnWhere): number;
+
+/** 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;
@@ -10182,7 +13525,7 @@ type ErrorMessageParams = Record<string, unknown>;
 /**
  * Replaces `{name}` with `params.name`. An unknown placeholder is left
  * verbatim, so a missing value is visible in the UI rather than silently
- * vanishing.
+ * vanishing — and so is a value without a text of its own.
  */
 declare function formatErrorMessage(template: string, params?: ErrorMessageParams): string;
 /**
@@ -10219,4 +13562,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 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 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 CancelSubscriptionBundleData, type CancelSubscriptionInput, type CancelSubscriptionResult, type CancellationNoticePeriods, type CanonicalBundleVersionRetirementRow, type CanonicalContractLineItemRow, type CanonicalContractRow, type CanonicalMaintenanceWindowRow, type CanonicalPlanRow, type CanonicalPlanVersionRow, type CanonicalRunningContractRow, type CanonicalSubscriberChargeRow, type CanonicalSubscriberCorrectionRow, type CanonicalSubscriberPaymentMethodRow, type CanonicalSubscriberRow, type CanonicalSubscriberTaxOriginChangeRow, type CanonicalSubscriberVatIdCheckRow, 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 HeldVatId, 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 NewBundleVersionRetirement, type NewContractLineItemData, type NewMaintenanceWindow, type NewSettingsChange, type NewSubscriberCharge, type NewSubscriberDetails, type NewSubscriptionContractData, 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 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_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 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 TaxDecision, type TaxDecisionRequest, type TaxErrorCode, type TaxIssuer, type TaxOriginWrite, type TaxTreatment, type TaxTreatmentKind, 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 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, applyPromo, assertPersistenceCapabilities, buildActivePlanVersionWhere, buildActiveVersionWhere, buildFeatureRequiresIndex, bundleDraftDefaults, bundleKeyTaken, bundleStemDefaults, canonicalJson, canonicalVatId, 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, keepsVatIdCheck, 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, taxOriginOf, taxOriginWrite, taxTreatmentToJson, toBundleStemRow, toBundleVersionRetirementRecord, toCents, toContractLineItemRecord, toDecimalString, toMaintenanceWindowRecord, toPlanRow, toPlanVersionRow, toRunningContractIssuer, toSubscriberChargeRecord, toSubscriberCorrectionRecord, toSubscriberPaymentMethodRecord, toSubscriberRecord, toSubscriberTaxOriginChangeRecord, toSubscriberVatIdCheckRecord, toSubscriptionBundleRecord, toSubscriptionContractRecord, toSubscriptionNoticeRecord, toTaxOriginValues, toTaxTreatment, toVersionRetirementRecord, vatIdCheckFromStore, versionOnSale, versionOnSaleOrNext, versionSale };
+export { ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES, AUTH_ERROR_CODES, type AbandonPaidOutcome, 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 AdminReconciliationCase, type AdminReconciliationCases, type AdminReconciliationClose, type AdminResourcesPort, type AdminSubscriberAccount, type AdminSubscriberAttention, type AdminSubscriberCorrected, type AdminSubscriberCredit, type AdminSubscriberCreditEntry, type AdminSubscriberCredits, type AdminSubscriberHistoryEntry, type AdminSubscriberPayout, type AdminSubscriptionListRow, type AdminTenantDetail, type AdminTenantInvoice, type AdminTenantListFilter, type AdminTenantListRow, type AdminTenantPayments, 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, BLOCKING_COLLECTION_STATUSES, 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, CASE_CLOSED_REFUND_ENDED, CASE_CLOSED_REVERSAL_GIVEN_BACK, CATALOGUE_KEYS, CATALOG_ERROR_CODES, COLLECTION_FAILURE_REASONS, COLLECTION_NOT_SENT_PAID, COLLECTION_NOT_SENT_REVERSED, COLLECTION_RETRY_AFTER_DAYS, CONTRACT_ERROR_CODES, CUSTOM_LIMITS_KEYS, type CalendarDay, type CancelSubscriptionBundleData, type CancelSubscriptionInput, type CancelSubscriptionResult, type CancellationNoticePeriods, type CanonicalBundleVersionRetirementRow, type CanonicalContractLineItemRow, type CanonicalContractRow, type CanonicalFeatureWithdrawalRow, type CanonicalInvoiceCollectionRow, type CanonicalInvoiceSettlementRow, type CanonicalMaintenanceWindowRow, type CanonicalPlanRow, type CanonicalPlanVersionRow, type CanonicalReconciliationCaseRow, type CanonicalRunningContractRow, type CanonicalSubscriberChargeRow, type CanonicalSubscriberCorrectionRow, type CanonicalSubscriberCreditEntryRow, type CanonicalSubscriberCreditRow, type CanonicalSubscriberPaymentMethodRow, type CanonicalSubscriberPaymentRow, type CanonicalSubscriberRefundRow, type CanonicalSubscriberReversalRow, 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 CloseReconciliationCase, type ClosedReconciliationCase, type CollectInvoiceInput, type CollectionAnnouncedNotice, type CollectionFailedNotice, type CollectionFailureNext, type CollectionFailureReason, type CollectionOutcome, type CollectionReversedNext, type CollectionReversedNotice, 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 CoveringCredit, 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 CreditPart, type CustomLimits, DIRECT_DEBIT_LEAD_DAYS, type DiffResult, type DiscoveredCapability, type DiscoveredFeature, type DiscoveredQuota, type DiscoveredQuotaPolicy, type DiscoveryCodeStatus, type DiscoverySnapshot, type DiscoveryStatus, ENDED_REFUND_STATUSES, ERROR_MESSAGES_DE, ERROR_MESSAGES_EN, type EarlierCollection, 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, FOLLOWED_UP_COLLECTION_STATUSES, 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 FindCollectionInput, type FirstTimeCustomerCheck, ForeignPaymentMethodReferenceError, GIVING_BACK_CREDIT_ENTRY_KINDS, type GatewayRefund, type GatewayReversal, type HeldVatId, INVOICE_ARCHIVE_TRIGGERS, INVOICE_COLLECTION_ASK_EVERY_MS, INVOICE_COLLECTION_LEASE_MS, INVOICE_COLLECTION_STATUSES, INVOICE_DOCUMENT_CAPABILITY, INVOICE_ERROR_CODES, INVOICE_SEQUENCE_DIGITS, INVOICE_SETTLEMENT_KINDS, type ImmediatePlanChangeInput, type InvoiceArchivePort, type InvoiceCollectionColumns, type InvoiceCollectionNotice, type InvoiceCollectionRecord, type InvoiceCollectionRepository, type InvoiceCollectionStatus, type InvoiceContentDraft, type InvoiceDocument, type InvoiceDocumentToArchive, type InvoiceDraftInput, type InvoiceErrorCode, type InvoiceGroup, type InvoiceLineItemSnapshot, type InvoiceMail, type InvoiceMailPort, type InvoiceNoticeMail, type InvoicePart, type InvoiceRenderer, type InvoiceSettlementKind, type InvoiceTaxLine, type IssuerCorrectionFault, type IssuerHistoryStep, type IssuerIdentityChange, type KpiCardDef, type KpiDisplayHint, LEGAL_IDENTITY_FIELDS, type LegalIdentity, type LegalIdentityField, type LiftedCover, 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 NewInvoiceCollection, type NewInvoiceRendering, type NewMaintenanceWindow, type NewReconciliationCase, type NewSettingsChange, type NewSubscriberCharge, type NewSubscriberDetails, type NewSubscriberPayment, type NewSubscriberPayout, 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 OpenCredit, 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 PlannedInvoiceCollection, 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, RECONCILIATION_CASE_KINDS, RECONCILIATION_CLOSE_CAPABILITY, RECONCILIATION_NOTE_MAX_LENGTH, RECONCILIATION_READ_CAPABILITY, REGISTRATION_ERROR_CODES, REGISTRATION_RESUME_TTL_MINUTES, REGISTRATION_STEP_BY_STATUS, REOPENING_SETTLEMENT_KINDS, RETIREMENT_REMINDER_LEAD_DAYS, REVERSIBLE_COLLECTION_STATUSES, type ReadCustomLimits, type ReassignTenantAdminCliResult, type RecommendablePlan, type ReconciliationCaseKind, type ReconciliationCaseState, type RecordSubscriberPaymentMethodData, type RecordSubscriberPaymentMethodOutcome, type RecordSubscriberPaymentMethodResult, type RecordedSubscriberPayment, type RecordedSubscriberPayout, type RecordedSubscriberRefund, type RecordedSubscriberReversal, 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 ReinstatableParts, type ReinstatementParts, type ReportedSubscriberRefund, type ReportedSubscriberReversal, 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 ReversalReinstatement, type ReversalWithdrawal, type ReversibleCredit, type ReversibleInvoice, 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_CREDIT_CAPABILITY, SUBSCRIBER_CREDIT_ENTRY_KINDS, SUBSCRIBER_ERROR_CODES, SUBSCRIBER_INVOICE_ADDRESS_FIELDS, SUBSCRIBER_PAYMENTS_CAPABILITY, SUBSCRIBER_PAYOUT_CAPABILITY, SUBSCRIBER_REFUND_STATUSES, SUBSCRIBER_STANDING_CAPABILITY, SUBSCRIBER_TAX_ORIGIN_FIELDS, 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 SubmittedInvoiceCollection, type SubscriberBusinessStatusData, type SubscriberBusinessStatusResult, type SubscriberCharge, type SubscriberChargeOrigin, type SubscriberChargeRecord, type SubscriberChargeSource, type SubscriberContact, type SubscriberContactChange, type SubscriberCorrectionData, type SubscriberCorrectionRecord, type SubscriberCorrectionResult, type SubscriberCreditEntryKind, type SubscriberCreditEntryRecord, type SubscriberCreditOrigin, type SubscriberCreditRecord, type SubscriberCreditStanding, 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 SubscriberPaymentRecord, type SubscriberPaymentRepository, type SubscriberReadiness, type SubscriberReconciliationCaseRecord, type SubscriberRecord, type SubscriberRefundRecord, type SubscriberRefundStatus, type SubscriberRepository, type SubscriberReversalRecord, 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 SubscriptionInvoicePayment, 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, UNSETTLED_COLLECTION_STATUSES, 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 WithdrawalParts, type WithdrawnFeature, addDaysToDay, announcedCollectionDay, applyPromo, asXmlReadsIt, assertPersistenceCapabilities, buildActivePlanVersionWhere, buildActiveVersionWhere, buildFeatureRequiresIndex, bundleDraftDefaults, bundleKeyTaken, bundleStemDefaults, canonicalJson, canonicalVatId, casesCovered, catalogDraftExists, catalogVersionAlreadyPublished, catalogVersionGone, chargedAgainOn, classifyBundleVersionDiff, classifyIssuerChange, classifyPlanDiff, classifyVersionOffer, collectUnsatisfiedRequires, collectionAttemptKey, collectionOutcomeColumns, collectionStatusOf, columnAmountOf, computeIncludedVat, concurrencyGate, concurrencyGateOf, contractPartiesOf, coverageExcludingSelf, coversLifted, coversOf, customLimitsReader, dayInZone, definedFields, diffSettings, directDebitLeadDaysOf, draftSubscriptionInvoice, endedAtOnceSubjectOf, featureWithdrawalRowOf, featuresWithdrawnAt, formatCustomerNumber, formatErrorMessage, formatInvoiceNumber, grossFromNet, holdsOnlyXmlCharacters, identityCorrectionDelta, inWithdrawalOrder, invoiceArchiveProtectionProblem, invoiceCollectionColumns, invoiceContentDraftOf, invoiceFooterOf, invoiceGroupsOf, invoiceIssuerOf, invoicePaymentOf, isBundleRedundant, isChargedAgain, isEndedRefund, isFeatureWithdrawnAt, isForeignPaymentMethodReferenceError, isInvoiceDocumentChecksum, isMaintenanceAnnouncementLapsed, isMaintenanceOverrun, isPaymentCallbackRejectedError, isPersistenceRefusal, isPlatformUserExistsError, isRetryableCollectionFailure, isVersionActiveAt, isVersionEditable, issuerIdentityOf, keepOneRecommended, keepsVatIdCheck, lastCollectionOf, lastDayInZone, maintenanceRetryAfterSeconds, maintenanceStatusOf, maintenanceWindowStatusOf, maintenanceWindowViewOf, marketingProjectionTaken, membersLeftOut, missingRequiresFor, movedIdentityFields, netByInvoice, netFromGross, nextWithdrawalChange, noActivePlanVersion, openOfCredit, owedOn, paidOutByCredit, parseZonedInstant, paymentSettlement, payoutEntryColumns, percentOf, pickActivePromo, planCatalogSettingsOf, planKeyTaken, planNotInCatalog, plannedCollectionColumns, previousUtcDay, promoCodeTaken, promoStatus, promotionOnPrice, prorate, readCustomLimits, readQuotaRecord, readQuotaValue, reconciliationCaseColumns, recordedIssuerIdentity, refundEntryColumns, refundParts, refuseForeignPaymentMethodReference, refusesFirstAttempt, refusesPlannedAttempt, reinstatementParts, resolveBundleAvailability, resolveErrorMessage, retirementCostsTheSubscription, retirementReminderDueAt, retirementReminderIsDue, retirementSwitchTerms, reversalEntryColumns, roundToCents, sameLegalIdentity, scheduledChangeAfterWrite, selectChargeableBundles, sentCollectionOf, settingsSubtreeOf, settledAmountOf, startOfUtcDay, subscriberChargeColumns, subscriberFromRegistration, subscriberPaymentColumns, subscriberPaymentMethodColumns, subscriberRefundColumns, subscriberReversalColumns, subscriptionBundleAlreadyCancelled, subscriptionBundleGone, subscriptionContractGone, subscriptionGone, subscriptionInvoiceChargeInvoiced, subscriptionInvoiceColumns, subscriptionInvoiceDocumentChanged, subscriptionInvoiceLineColumns, sumToCents, taxOriginOf, taxOriginWrite, taxPerRate, taxTreatmentToJson, toArchivedInvoiceDocument, toBundleStemRow, toBundleVersionRetirementRecord, toCents, toCollectionAnnouncedNotice, toCollectionFailedNotice, toCollectionReversedNotice, toContractLineItemRecord, toDecimalString, toFeatureWithdrawalRecord, toInvoiceCollectionRecord, toMaintenanceWindowRecord, toPlanRow, toPlanVersionRow, toRunningContractIssuer, toSubscriberChargeRecord, toSubscriberCorrectionRecord, toSubscriberCreditEntryRecord, toSubscriberCreditRecord, toSubscriberPaymentMethodRecord, toSubscriberPaymentRecord, toSubscriberReconciliationCaseRecord, toSubscriberRecord, toSubscriberRefundRecord, toSubscriberReversalRecord, toSubscriberTaxOriginChangeRecord, toSubscriberVatIdCheckRecord, toSubscriptionBundleRecord, toSubscriptionContractRecord, toSubscriptionInvoiceDocumentRecord, toSubscriptionInvoiceRecord, toSubscriptionNoticeRecord, toTaxOriginValues, toTaxTreatment, toVersionRetirementRecord, utcMidnightOf, vatCategoryOf, vatIdCheckFromStore, versionOnSale, versionOnSaleOrNext, versionSale, withdrawalParts, withdrawnFeaturesOf, yearOfDay };