@saasicat/core 1.0.0-rc.26 → 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.
@@ -863,8 +1029,17 @@ interface PlanCatalogSubscribers {
 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`). */
+    /**
+     * 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`).
@@ -2157,7 +2332,7 @@ interface AdminManifest {
         actions?: AuditActionDef[];
     };
 }
-type StandardPageKey = 'dashboard' | 'tenants' | 'subscriptions' | 'promoCodes' | 'plans' | 'audit' | 'users' | 'pilots' | 'discovery' | 'bundles' | 'marketingCatalog' | 'platformEmail' | 'platformEmailHistory' | 'settings' | 'maintenance' | 'featureWithdrawals';
+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;
@@ -3585,7 +3760,7 @@ interface EndedAtOnce extends EndAtOncePreview {
 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' | 'feature-withdrawn' | 'feature-withdrawal-lifted' | 'ended-at-once';
+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;
@@ -3606,7 +3781,10 @@ interface SubscriptionNoticeKey {
      * 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.
+     * 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;
 }
@@ -4516,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)`.
@@ -4689,6 +4879,78 @@ interface PromoRevenueDeductionAggregator {
     sumGrossForPromoCode(promoCodeId: string): Promise<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;
+}
+/** 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';
+};
+/**
+ * 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.
+ */
+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;
+
 /**
  * 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.
  */
@@ -4843,6 +5105,24 @@ interface SubscriptionInvoiceLineRecord {
 }
 /** 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;
@@ -4861,8 +5141,23 @@ interface SubscriptionInvoiceRecord {
     issuedAt: Date;
     /** The day it was issued, in the installation's time zone. */
     issueDate: CalendarDay;
-    /** The day it is due: the issue date plus the payment term (`SC-PRIC-046`). */
+    /**
+     * 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. */
@@ -4925,6 +5220,10 @@ interface InvoiceDocument {
  * 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>;
@@ -4971,8 +5270,16 @@ interface InvoiceMail {
     /** 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`).
+ * 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
@@ -4988,6 +5295,15 @@ interface InvoiceMail {
  */
 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 {
@@ -5835,6 +6151,676 @@ type AdminSubscriberHistoryEntry = {
     counts: boolean;
 };
 
+/**
+ * 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.
+ */
+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;
+}
+/**
+ * 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.
+ */
+declare const INVOICE_COLLECTION_LEASE_MS: number;
+/**
+ * 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.
+ */
+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;
+    subscriberId: string;
+    /** 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;
+    /**
+     * 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;
+    status: SubscriberRefundStatus;
+    at: Date;
+}
+/** 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;
+    /** 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;
+    /**
+     * 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 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.
+ */
+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;
+    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[];
+}
+/** A tenant's credits as the operator reads them, the oldest first. */
+interface AdminSubscriberCredits {
+    credits: AdminSubscriberCredit[];
+    /**
+     * The installation's time zone, in which a payout's day is judged: no
+     * payout lies after today there, wherever the operator sits.
+     */
+    timeZone: string;
+}
+/** A payout the operator records against a credit. */
+interface AdminSubscriberPayout {
+    amount: number;
+    reference: string;
+    paidOn: CalendarDay;
+    note?: string | null;
+}
+
 /**
  * Snapshot form of a `Subscription` row for the EntitlementService
  * computation. The consumer maps its Prisma structure onto this form.
@@ -6356,6 +7342,298 @@ interface SubscriptionInvoiceRepository {
         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
@@ -6450,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
@@ -8049,6 +9327,13 @@ interface SaaSiCatPersistenceEntitlement {
     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>;
 }
@@ -8778,6 +10063,24 @@ declare const INVOICE_ERROR_CODES: {
      * (`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
@@ -8808,6 +10111,25 @@ declare const INVOICE_ERROR_CODES: {
      * 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. */
@@ -9144,6 +10466,24 @@ declare const PLATFORM_ERROR_CODES: {
      * (`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
@@ -9174,6 +10514,25 @@ declare const PLATFORM_ERROR_CODES: {
      * 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";
     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";
@@ -9873,6 +11232,14 @@ declare const OPTIONAL_CANONICAL_MODELS: {
     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;
@@ -10944,6 +12311,9 @@ interface CanonicalSubscriptionInvoiceRow {
     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;
@@ -10991,6 +12361,8 @@ interface SubscriptionInvoiceColumns {
     dueDate: CalendarDay;
     servicePeriodFrom: CalendarDay;
     servicePeriodUntil: CalendarDay;
+    payment: SubscriptionInvoicePayment | null;
+    collectionDate: CalendarDay | null;
     currency: string;
     issuerParty: SubscriptionInvoiceIssuer;
     subscriberParty: SubscriptionInvoiceSubscriber;
@@ -11075,9 +12447,31 @@ interface InvoiceDraftInput {
     /** The installation's time zone, which every day the invoice states is read in (`SC-PRIC-045`). */
     timeZone: string;
     numberPrefix: string;
-    /** Days from the issue date to the due date (`SC-PRIC-046`). */
+    /** 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
@@ -11085,8 +12479,16 @@ interface InvoiceDraftInput {
  * 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.
+ * 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`). */
@@ -11154,6 +12556,584 @@ declare const INVOICE_ARCHIVE_TRIGGERS: readonly ["subscription_invoice_archive_
  */
 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. */
@@ -11545,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;
 /**
@@ -11582,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 ArchivedInvoiceDocument, type AuditActionDef, type AuditActor, type AuditEntry, type AuditPort, type AuditQuery, type AuditQueryPort, type AuditStatsPort, type AuditStatsSnapshot, type AuthErrorCode, BILLING_ERROR_CODES, BUNDLE_PRICE_LOOKUP_LIMIT, BUNDLE_VERSION_RETIREMENT_CAPABILITY, type BillingCycle, type BillingErrorCode, type BundleAvailabilityState, type BundleCompatibility, type BundleFeatureShape, type BundleListFilter, type BundlePricingOverride, type BundleRepository, type BundleRetirementAnnounced, type BundleRetirementPreview, type BundleRetirementReachedRow, type BundleRetirementSkipReason, type BundleRetirementSkippedRow, type BundleRetirementSwitchResult, type BundleRetirementSwitchTerms, type BundleRow, type BundleVersionFields, type BundleVersionMutationResult, type BundleVersionOfferView, type BundleVersionOfferedNotice, type BundleVersionRetiredNotice, type BundleVersionRetirementRecord, type BundleVersionRetirementReminder, type BundleVersionRetirementRepository, type BundleVersionRetirementView, type BundleVersionRow, type BundleVersionSide, type BundleVersionSwitchResult, CATALOGUE_KEYS, CATALOG_ERROR_CODES, CONTRACT_ERROR_CODES, CUSTOM_LIMITS_KEYS, type CalendarDay, type CancelSubscriptionBundleData, type CancelSubscriptionInput, type CancelSubscriptionResult, type CancellationNoticePeriods, type CanonicalBundleVersionRetirementRow, type CanonicalContractLineItemRow, type CanonicalContractRow, type CanonicalFeatureWithdrawalRow, type CanonicalMaintenanceWindowRow, type CanonicalPlanRow, type CanonicalPlanVersionRow, type CanonicalRunningContractRow, type CanonicalSubscriberChargeRow, type CanonicalSubscriberCorrectionRow, type CanonicalSubscriberPaymentMethodRow, type CanonicalSubscriberRow, type CanonicalSubscriberTaxOriginChangeRow, type CanonicalSubscriberVatIdCheckRow, type CanonicalSubscriptionBundleRow, type CanonicalSubscriptionInvoiceArchiveRow, type CanonicalSubscriptionInvoiceDocumentRow, type CanonicalSubscriptionInvoiceLineRow, type CanonicalSubscriptionInvoiceRow, type CanonicalSubscriptionNoticeRow, type CanonicalVersionRetirementRow, type CapabilityCatalogEntryRow, type CapabilityCodeStatus, type CapabilityKey, type CapabilityKind, type CatalogEntryFilter, type CatalogEntryI18n, type CatalogEntryI18nFields, type CatalogEntryRepository, type CatalogErrorCode, type CatalogVersionKind, type ChangeDirection, type CheckoutOfferFilter, type CheckoutOfferLineItem, type CheckoutOfferLineItemKind, type CheckoutOfferPriceBreakdown, type CheckoutOfferPromoCodeSnapshot, type CheckoutOfferPromotionSnapshot, type CheckoutOfferRepository, type CheckoutOfferRow, type CheckoutOfferSelection, type CheckoutOfferSelectionUpdate, type CheckoutOfferStatus, type CleanupResult, type CliUserRow, type ComponentKey, type ConcurrencyGate, type ConfiguratorCatalog, type ConfiguratorMarketingProvider, type ConfiguratorModel, type ConfiguratorPlanMarketing, type ConfiguratorPlanVersionRow, type ConfiguratorPriceBreakdown, type ConfiguratorSourcesLookup, type ConfirmedPaymentMethod, type ContractErrorCode, type ContractIssuerParty, type ContractLineItemKind, type ContractLineItemRecord, type ContractSubscriberParty, type CreateBundleData, type CreateBundleVersionDraftData, type CreateCheckoutOfferData, type CreateMarketingProjectionData, type CreatePlanData, type CreatePlanVersionDraftData, type CreatePromoCodeData, type CreatePromoCodeRequest, type CreatePromotionData, type CreateSubscriberData, type CreateSubscriptionBundleData, type CreateSubscriptionContractData, type CreateSuperAdminCliInput, type CreateTenantInput, type CustomLimits, type DiffResult, type DiscoveredCapability, type DiscoveredFeature, type DiscoveredQuota, type DiscoveredQuotaPolicy, type DiscoveryCodeStatus, type DiscoverySnapshot, type DiscoveryStatus, ERROR_MESSAGES_DE, ERROR_MESSAGES_EN, type EffectiveLimitsSnapshot, type EmailPort, type EndAtOncePreview, type EndNowInput, type EndSubscriptionNowResult, type EndedAtOnce, type EndedAtOnceNotice, type ErrorMessageParams, FEATURE_NOT_LICENSED, FEATURE_WITHDRAWAL_CAPABILITY, FEATURE_WITHDRAWAL_REASON_MAX_LENGTH, type FeatureCatalogEntryRow, type FeatureDef, type FeatureKey, type FeatureNotLicensedBody, type FeatureRequiresIndex, type FeatureTier, type FeatureUiMeta, type FeatureUiRegistry, type FeatureWithdrawalAnnounced, type FeatureWithdrawalBlocker, type FeatureWithdrawalLift, type FeatureWithdrawalLifted, type FeatureWithdrawalLiftedNotice, type FeatureWithdrawalLine, type FeatureWithdrawalLineKind, type FeatureWithdrawalMark, type FeatureWithdrawalNoticeLine, type FeatureWithdrawalPreview, type FeatureWithdrawalReachedRow, type FeatureWithdrawalRecord, type FeatureWithdrawalReduction, type FeatureWithdrawalRepository, type FeatureWithdrawalRow, type FeatureWithdrawalSkippedRow, type FeatureWithdrawalTarget, type FeatureWithdrawalView, type FeatureWithdrawnNotice, type FinalActivationResult, type FirstTimeCustomerCheck, ForeignPaymentMethodReferenceError, type HeldVatId, INVOICE_ARCHIVE_TRIGGERS, INVOICE_DOCUMENT_CAPABILITY, INVOICE_ERROR_CODES, INVOICE_SEQUENCE_DIGITS, type ImmediatePlanChangeInput, type InvoiceArchivePort, type InvoiceContentDraft, type InvoiceDocument, type InvoiceDocumentToArchive, type InvoiceDraftInput, type InvoiceErrorCode, type InvoiceGroup, type InvoiceLineItemSnapshot, type InvoiceMail, type InvoiceMailPort, type InvoiceRenderer, type InvoiceTaxLine, type IssuerCorrectionFault, type IssuerHistoryStep, type IssuerIdentityChange, type KpiCardDef, type KpiDisplayHint, LEGAL_IDENTITY_FIELDS, type LegalIdentity, type LegalIdentityField, MAINTENANCE_CAPABILITY, MAINTENANCE_ERROR_CODES, MAINTENANCE_MESSAGE_MAX_LENGTH, MAINTENANCE_STATE_MAX_AGE_SECONDS, MARKETING_PRIORITY_MAX, MARKETING_PRIORITY_MIN, type MaintenanceErrorCode, type MaintenanceLockView, type MaintenanceNotificationPort, type MaintenanceOverview, type MaintenanceStatusView, type MaintenanceUnlockView, type MaintenanceWindowChanges, type MaintenanceWindowEvent, type MaintenanceWindowPort, type MaintenanceWindowRecord, type MaintenanceWindowStage, type MaintenanceWindowStatus, type MaintenanceWindowView, type ManifestAccessPort, type ManifestContribution, type MarketingProjectionFilter, type MarketingProjectionRepository, type MarketingProjectionRow, type MarketingSettingsRepository, type MarketingSettingsRow, type MarketingTargetType, type MarketingTopFeature, type MaskedPaymentMethod, type MfaPort, NO_SCHEDULED_CHANGE, type NewBundleVersionRetirement, type NewContractLineItemData, type NewFeatureWithdrawal, type NewInvoiceRendering, type NewMaintenanceWindow, type NewSettingsChange, type NewSubscriberCharge, type NewSubscriberDetails, type NewSubscriptionContractData, type NewSubscriptionInvoice, type NewSubscriptionInvoiceLine, type NewVersionRetirement, type NotToldReasons, type NoticeToRecord, OPTIONAL_CANONICAL_MODELS, OTP_RATE_LIMIT_MAX_SENDS, OTP_RATE_LIMIT_WINDOW_MINUTES, OTP_TTL_MINUTES, OTP_VERIFY_MAX_ATTEMPTS, type OnboardingPromoRedemption, type OnboardingSelectionRequest, type OnboardingSelectionResponse, type OptionalBundleMember, type OptionalCanonicalModel, type OrderlyRetirementSettings, PASSWORD_RESET_TTL_MINUTES, PAYMENT_ERROR_CODES, PAYMENT_METHOD_TYPES, PENDING_CHECKOUT_TTL_DAYS, PENDING_EMAIL_TTL_HOURS, PENDING_ONBOARDING_TTL_DAYS, PLATFORM_ERROR_CODES, PROMO_ERROR_CODES, type Paginated, type PartyAddress, type PasswordHasher, type PasswordResetCliResult, PaymentCallbackRejectedError, type PaymentErrorCode, type PaymentEventClaim, type PaymentEventLog, type PaymentGateway, type PaymentGatewayCallback, type PaymentGatewayEvent, type PaymentMethodHolder, type PaymentMethodSetupSession, type PaymentMethodSetupSubject, type PaymentMethodType, type PendingRegistration, type PendingRegistrationCreateInput, type PendingRegistrationRepository, type PendingRegistrationSnapshot, type PendingRegistrationUpdateInput, type PersistenceCapabilities, PersistenceCapabilityError, type PersistenceClassRef, type PersistenceInjectionToken, type PersistenceProvider, PersistenceRefusal, type PersistenceRefusalReason, type PlanCatalog, type PlanCatalogApp, type PlanCatalogImportReport, type PlanCatalogImportSink, type PlanCatalogInvoicing, type PlanCatalogIssuer, type PlanCatalogIssuerCorrection, type PlanCatalogLookup, type PlanCatalogMarketing, type PlanCatalogNotifications, type PlanCatalogPaymentAccount, type PlanCatalogPayments, type PlanCatalogReadSink, type PlanCatalogReadSnapshot, type PlanCatalogSettings, type PlanCatalogSubscribers, type PlanCatalogTax, type PlanCatalogTenantBilling, type PlanDef, type PlanId, type PlanListFilter, type PlanRepository, type PlanRow, type PlanVersion, type PlanVersionFields, type PlanVersionMutationResult, type PlanVersionRecord, type PlanVersionRepository, type PlanVersionRow, type PlatformErrorBody, type PlatformErrorCode, type PlatformJobActor, type PlatformRole, type PlatformUserDto, PlatformUserExistsError, type ProjectPageDef, type PromoCode, type PromoCodeDurationType, type PromoCodeFilter, type PromoCodeHoldRecord, type PromoCodeHoldRepository, type PromoCodeHoldTaken, type PromoCodeRecord, type PromoCodeRedemption, type PromoCodeRedemptionListItem, type PromoCodeRedemptionRecord, type PromoCodeRedemptionRepository, type PromoCodeRedemptionStatus, type PromoCodeRepository, type PromoCodeStatsPort, type PromoCodeStatsSnapshot, type PromoCodeStatus, type PromoCodeValidationLog, type PromoCodeValidationLogRepository, type PromoCodeValidationResult, type PromoCodeValueType, type PromoErrorCode, type PromoPreviewInvalidReason, type PromoPreviewRequest, type PromoPreviewResponse, type PromoPreviewValidResponse, type PromoRevenueDeductionAggregator, type PromoSubscriptionLookup, type PromotionBillingCycle, type PromotionI18n, type PromotionI18nFields, type PromotionOnPrice, type PromotionRepository, type PromotionResult, type PromotionRow, type PromotionStatus, type PromotionTargetType, type PromotionType, type PromotionValue, type PublicBootResponse, type PublicComparisonRow, type PublicMarketingBundle, type PublicMarketingCatalogResponse, type PublicMarketingPlan, type PublicMarketingPromo, type PublicNewPaymentMethods, type PublicSignupPlan, type PublishBundleVersionData, type PublishBundleVersionMeta, type PublishPlanVersionData, type QuotaCatalogEntryRow, type QuotaEnforcementMode, type QuotaKey, type QuotaProvider, REGISTRATION_ERROR_CODES, REGISTRATION_RESUME_TTL_MINUTES, REGISTRATION_STEP_BY_STATUS, RETIREMENT_REMINDER_LEAD_DAYS, type ReadCustomLimits, type ReassignTenantAdminCliResult, type RecommendablePlan, type RecordSubscriberPaymentMethodData, type RecordSubscriberPaymentMethodOutcome, type RecordSubscriberPaymentMethodResult, type RecordedVatIdCheck, type RedeemPromoInTransactionCallback, type RegistrationActivation, type RegistrationAuditContext, type RegistrationAuditEvent, type RegistrationAuditEventType, type RegistrationAuditLogger, type RegistrationBillingDetails, type RegistrationConfigSelection, type RegistrationConfiguratorLookup, type RegistrationErrorCode, type RegistrationOtpDelivery, type RegistrationPromoPreview, type RegistrationResumeDelivery, type RegistrationResumeTokenSigner, type RegistrationStatus, type RegistrationStep, type RequiredCapabilities, type ResolvableErrorBody, type ResumeRegistrationInput, type ResumeRegistrationResult, type RetiredBundleVersionRef, type RetiredVersionRef, type RetirementAnnounced, type RetirementBlocker, type RetirementMoveRun, type RetirementPreview, type RetirementPricedSide, type RetirementProgress, type RetirementReachedRow, type RetirementSide, type RetirementSkipReason, type RetirementSkippedRow, type RetirementSwitchResult, type RetirementSwitchTerms, type ReviewCatalogEntryData, type RlsBypassPort, type RunningContractIssuer, type RunningContractIssuers, SETTINGS_ERROR_CODES, SETUP_ERROR_CODES, SUBSCRIBER_ACCOUNT_CAPABILITY, SUBSCRIBER_ATTENTION_CAPABILITY, SUBSCRIBER_ATTENTION_PAGE_SIZE, SUBSCRIBER_CHARGE_ORIGINS, SUBSCRIBER_CHARGE_SOURCES, SUBSCRIBER_CORRECTION_CAPABILITY, SUBSCRIBER_ERROR_CODES, SUBSCRIBER_INVOICE_ADDRESS_FIELDS, SUBSCRIBER_STANDING_CAPABILITY, SUBSCRIBER_TAX_ORIGIN_FIELDS, type SaaSiCatPersistenceAdapter, type SaaSiCatPersistenceAdminResources, type SaaSiCatPersistenceCatalog, type SaaSiCatPersistenceCore, type SaaSiCatPersistenceEntitlement, type SaaSiCatPersistencePayments, type SaaSiCatPersistencePromo, type SaaSiCatPersistenceTenantBilling, type SaveRegistrationConfigInput, type SaveRegistrationConfigResult, type ScheduledChangeColumns, type ScheduledPlanChangeInput, type SecretSealer, type SelectPlanInput, type SelectPlanResult, type SelectableBundleShape, type SelfServiceBlockedPlans, type SetCatalogEntryReviewData, type SettingsChangeFilter, type SettingsChangeRecord, type SettingsDifference, type SettingsErrorCode, type SetupConfirmMfaRequest, type SetupConfirmMfaResponse, type SetupErrorCode, type SetupRequest, type SetupResult, type SetupStatusResponse, type SlugAvailabilityCheck, type StandardPageDef, type StandardPageKey, type StartCheckoutInput, type StartCheckoutResult, type StartPaymentMethodSetupInput, type StartRegistrationInput, type StartRegistrationResult, type StoredBundleStem, type StrictModeWarning, type StrictModeWarningCode, type SubscriberBusinessStatusData, type SubscriberBusinessStatusResult, type SubscriberCharge, type SubscriberChargeOrigin, type SubscriberChargeRecord, type SubscriberChargeSource, type SubscriberContact, type SubscriberContactChange, type SubscriberCorrectionData, type SubscriberCorrectionRecord, type SubscriberCorrectionResult, type SubscriberDetails, type SubscriberErrorCode, type SubscriberIdentityCorrection, type SubscriberIdentityDelta, type SubscriberIdentityValues, type SubscriberInvoiceAddressField, type SubscriberLedgerRepository, type SubscriberPaymentMethodRecord, type SubscriberPaymentMethodReference, type SubscriberPaymentMethodRepository, type SubscriberPaymentMethodSetupData, type SubscriberPaymentMethodSetupMatch, type SubscriberPaymentMethodStatus, type SubscriberReadiness, type SubscriberRecord, type SubscriberRepository, type SubscriberTaxOrigin, type SubscriberTaxOriginChangeRecord, type SubscriberTaxOriginField, type SubscriberTaxOriginValues, type SubscriberTaxStatus, type SubscriberVatIdCheckRecord, type SubscriberVatIdCheckResult, type SubscriberWithCurrentCheck, type Subscription, type SubscriptionBundleRecord, type SubscriptionBundleRepository, type SubscriptionBundleView, type SubscriptionContractFilter, type SubscriptionContractInvoiceSnapshot, type SubscriptionContractParties, type SubscriptionContractPriceSnapshot, type SubscriptionContractRecord, type SubscriptionContractRepository, type SubscriptionContractStatus, type SubscriptionInvoiceColumns, type SubscriptionInvoiceDocumentRecord, type SubscriptionInvoiceIssuer, type SubscriptionInvoiceLineColumns, type SubscriptionInvoiceLineRecord, type SubscriptionInvoiceRecord, type SubscriptionInvoiceRepository, type SubscriptionInvoiceSubscriber, type SubscriptionNotice, type SubscriptionNoticeDelivery, type SubscriptionNoticeKey, type SubscriptionNoticeKind, type SubscriptionNoticePort, type SubscriptionNoticeRecord, type SubscriptionNoticeRepository, type SubscriptionRecord, type SubscriptionRepository, type SubscriptionStatsPort, type SubscriptionStatsSnapshot, type SubscriptionStatus, type SubscriptionUsagePort, type SubscriptionUsageRecord, type SuperAdminProvisioningPort, type SupersedeSubscriptionContractData, type SyncDiscoveryResult, TAX_ERROR_CODES, TAX_TREATMENT_KINDS, type TaxAdapter, type TaxAdapterFactory, type TaxAdapterIdentity, type TaxAtRate, type TaxDecision, type TaxDecisionRequest, type TaxErrorCode, type TaxIssuer, type TaxOriginWrite, type TaxPerRate, type TaxTreatment, type TaxTreatmentKind, type TenantActionDef, type TenantColumnDef, type TenantDto, type TenantFeatureWithdrawal, type TenantFeatureWithdrawalLine, type TenantListFilter, type TenantPort, type TenantSubscriptionUsage, type TenantSubscriptionWritePort, type TerminateSubscriptionContractData, type TopPromoCode, type TransactionContext, type TransactionRunner, type UpdateBundleData, type UpdateBundleVersionDraftData, type UpdateCatalogEntryBaseData, type UpdateCatalogEntryI18nData, type UpdateCheckoutOfferData, type UpdateMarketingProjectionData, type UpdateMarketingSettingsData, type UpdatePlanData, type UpdatePlanVersionDraftData, type UpdatePromoCodeData, type UpdatePromoCodeRequest, type UpdatePromotionData, type UpsellOffer, type UpsellOfferResolver, type UpsertCapabilityEntryData, type UpsertFeatureCatalogEntryInput, type UpsertFeatureEntryData, type UpsertPlanInput, type UpsertPlanVersionInput, type UpsertQuotaEntryData, type UpsertResult, type UsageSnapshotPort, type UserAccountLookup, type UserListFilter, type UserManagementPort, type UserPort, VERSION_RETIREMENT_CAPABILITY, type VatCategory, type VatIdCheck, type VatIdCheckOutcome, type VerifyRegistrationOtpResult, type VersionChange, type VersionChangeDirection, type VersionEditability, type VersionEditableReason, type VersionOffer, type VersionOfferClass, type VersionOfferFields, type VersionOfferSide, type VersionOfferView, type VersionOfferedNotice, type VersionRetiredNotice, type VersionRetirementRecord, type VersionRetirementReminder, type VersionRetirementRepository, type VersionRetirementView, type VersionSale, type VersionSaleDates, type VersionSaleKind, type VersionSwitchResult, type VersionWindow, type VersionedEntityBase, type WithdrawnFeature, addDaysToDay, applyPromo, asXmlReadsIt, assertPersistenceCapabilities, buildActivePlanVersionWhere, buildActiveVersionWhere, buildFeatureRequiresIndex, bundleDraftDefaults, bundleKeyTaken, bundleStemDefaults, canonicalJson, canonicalVatId, catalogDraftExists, catalogVersionAlreadyPublished, catalogVersionGone, classifyBundleVersionDiff, classifyIssuerChange, classifyPlanDiff, classifyVersionOffer, collectUnsatisfiedRequires, computeIncludedVat, concurrencyGate, concurrencyGateOf, contractPartiesOf, coverageExcludingSelf, customLimitsReader, dayInZone, definedFields, diffSettings, draftSubscriptionInvoice, endedAtOnceSubjectOf, featureWithdrawalRowOf, featuresWithdrawnAt, formatCustomerNumber, formatErrorMessage, formatInvoiceNumber, grossFromNet, holdsOnlyXmlCharacters, identityCorrectionDelta, invoiceArchiveProtectionProblem, invoiceContentDraftOf, invoiceFooterOf, invoiceGroupsOf, invoiceIssuerOf, isBundleRedundant, isFeatureWithdrawnAt, isForeignPaymentMethodReferenceError, isInvoiceDocumentChecksum, isMaintenanceAnnouncementLapsed, isMaintenanceOverrun, isPaymentCallbackRejectedError, isPersistenceRefusal, isPlatformUserExistsError, isVersionActiveAt, isVersionEditable, issuerIdentityOf, keepOneRecommended, keepsVatIdCheck, lastDayInZone, maintenanceRetryAfterSeconds, maintenanceStatusOf, maintenanceWindowStatusOf, maintenanceWindowViewOf, marketingProjectionTaken, membersLeftOut, missingRequiresFor, movedIdentityFields, netFromGross, nextWithdrawalChange, noActivePlanVersion, parseZonedInstant, percentOf, pickActivePromo, planCatalogSettingsOf, planKeyTaken, planNotInCatalog, previousUtcDay, promoCodeTaken, promoStatus, promotionOnPrice, prorate, readCustomLimits, readQuotaRecord, readQuotaValue, recordedIssuerIdentity, refuseForeignPaymentMethodReference, resolveBundleAvailability, resolveErrorMessage, retirementCostsTheSubscription, retirementReminderDueAt, retirementReminderIsDue, retirementSwitchTerms, roundToCents, sameLegalIdentity, scheduledChangeAfterWrite, selectChargeableBundles, settingsSubtreeOf, startOfUtcDay, subscriberChargeColumns, subscriberFromRegistration, subscriberPaymentMethodColumns, subscriptionBundleAlreadyCancelled, subscriptionBundleGone, subscriptionContractGone, subscriptionGone, subscriptionInvoiceChargeInvoiced, subscriptionInvoiceColumns, subscriptionInvoiceDocumentChanged, subscriptionInvoiceLineColumns, sumToCents, taxOriginOf, taxOriginWrite, taxPerRate, taxTreatmentToJson, toArchivedInvoiceDocument, toBundleStemRow, toBundleVersionRetirementRecord, toCents, toContractLineItemRecord, toDecimalString, toFeatureWithdrawalRecord, toMaintenanceWindowRecord, toPlanRow, toPlanVersionRow, toRunningContractIssuer, toSubscriberChargeRecord, toSubscriberCorrectionRecord, toSubscriberPaymentMethodRecord, toSubscriberRecord, toSubscriberTaxOriginChangeRecord, toSubscriberVatIdCheckRecord, toSubscriptionBundleRecord, toSubscriptionContractRecord, toSubscriptionInvoiceDocumentRecord, toSubscriptionInvoiceRecord, toSubscriptionNoticeRecord, toTaxOriginValues, toTaxTreatment, toVersionRetirementRecord, utcMidnightOf, vatCategoryOf, vatIdCheckFromStore, versionOnSale, versionOnSaleOrNext, versionSale, withdrawnFeaturesOf, yearOfDay };
+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 };