@saasicat/core 1.0.0-rc.20 → 1.0.0-rc.22

package/dist/index.d.cts

@@ -564,6 +564,15 @@ interface PaymentMethodSetupSession {
     redirectUrl: string;
     /** The customer the payment method is set up for, created if none was given. */
     customerRef: string;
+    /**
+     * The last moment a confirmation of this session can still arrive: the end
+     * of its form, after which nobody can complete it, plus the time the
+     * gateway goes on retrying a confirmation it could not deliver. `null` for
+     * a gateway that states neither. A sign-up's promo code slot is held until
+     * then, so a form paid shortly before its end still finds its slot when the
+     * confirmation arrives late, and an abandoned form gives it back.
+     */
+    confirmableUntil: Date | null;
     /**
      * A confirmation the gateway already holds when the session starts, to be
      * handled like any callback. Only a gateway without a form of its own has
@@ -634,12 +643,19 @@ interface PaymentGateway {
     /**
      * Opens the gateway's form for a payment method. Nothing is confirmed until
      * the gateway says so through `readCallback`.
+     *
+     * A failure is thrown as the provider reported it: the platform answers the
+     * person with `PAYMENT_GATEWAY_FAILED` and keeps what the error carries —
+     * its kind, code, status and request id — in the server log.
      */
     startPaymentMethodSetup(input: StartPaymentMethodSetupInput): Promise<PaymentMethodSetupSession>;
     /**
      * Verifies a callback with the account's secret and translates it.
      * Throws `PaymentCallbackRejectedError` for anything the gateway did not
-     * send, before a single field of it is trusted.
+     * send, before a single field of it is trusted. Any other failure is
+     * answered with `PAYMENT_GATEWAY_FAILED` and 502, like one of
+     * `startPaymentMethodSetup` — to the gateway's webhook, or to the person
+     * an `immediateCallback` is read for.
      */
     readCallback(callback: PaymentGatewayCallback): Promise<PaymentGatewayEvent>;
 }
@@ -915,6 +931,11 @@ interface PromoCode {
     validUntil: string | null;
     maxRedemptions: number | null;
     redemptionsCount: number;
+    /**
+     * Slots held for checkouts that started and have not concluded. A code has
+     * a free slot while `redemptionsCount + heldCount` is below `maxRedemptions`.
+     */
+    heldCount: number;
     appliesToPlans: PlanId[];
     appliesToBilling: BillingCycle | null;
     firstTimeCustomersOnly: boolean;
@@ -1089,7 +1110,7 @@ interface SubscriptionBundleRecord {
      * or on one whose plan has no period; readers fall back to the plan's
      * cycle, which is what every booking used before.
      */
-    billingCycle: string | null;
+    billingCycle: BillingCycle | null;
     currentPeriodStart: Date | null;
     currentPeriodEnd: Date | null;
     createdAt: Date;
@@ -1123,7 +1144,7 @@ interface CreateSubscriptionBundleData {
     /** Null unless a commitment was configured or asked for. */
     minimumTermEndsAt?: Date | null;
     /** The rhythm and window worked out above this port. */
-    billingCycle?: string | null;
+    billingCycle?: BillingCycle | null;
     currentPeriodStart?: Date | null;
     currentPeriodEnd?: Date | null;
 }
@@ -1729,8 +1750,35 @@ type PromotionResult = {
     original: number;
     months: number;
 };
-/** Applies the promotion math to a base price. */
+/**
+ * Applies the promotion math to a base price, or `null` where the promotion
+ * takes nothing off it.
+ *
+ * The discounted price stays between 0 and the base price, whatever the
+ * promotion states: a promotion lowers the price of what it is on and nothing
+ * else. Creating one refuses a value no price could make sense of, but whether
+ * an intro price or an amount fits depends on the price it meets — which
+ * differs per plan and rhythm and moves when a new version is published — so
+ * the bound is held here, where every place that resolves a promotion reads it:
+ * the public catalogue, a checkout offer, the operator's preview.
+ */
 declare function applyPromo(promo: PromotionRow | null, basePrice: number | null): PromotionResult | null;
+/** A promotion on a price, and what it makes of that price. */
+interface PromotionOnPrice {
+    promotion: PromotionRow;
+    result: PromotionResult;
+}
+/**
+ * The promotion a price carries: the one `pickActivePromo` selects for the key,
+ * language and rhythm, where `applyPromo` finds that it lowers the price at
+ * all — or `null`.
+ *
+ * One question, asked the same way by every place that shows or charges a
+ * promotion: the public catalogue, a checkout offer, and the operator's
+ * preview. A promotion that lowers nothing is no promotion there, so it carries
+ * no badge and takes nothing off.
+ */
+declare function promotionOnPrice(promotions: PromotionRow[], targetKey: string, locale: string, cycle: 'monthly' | 'yearly', basePrice: number | null, today?: Date, targetType?: PromotionTargetType): PromotionOnPrice | null;
 
 type CheckoutOfferLineItemKind = 'plan' | 'bundle' | 'discount';
 /** Frozen billable line item in the offer. */
@@ -2015,12 +2063,32 @@ interface PublicComparisonRow {
     /** Quotas only: display unit. */
     unit?: string;
 }
+/**
+ * What this installation takes a new payment method with, so a page offering the
+ * plans can say it before anybody reaches the form.
+ *
+ * It is the account `config/saas.yaml#payments.newPaymentMethods` names, with the
+ * gateway bound for it — the same account a sign-up's payment step and a tenant's
+ * own change both go to. Whether an installation runs sign-ups at all is not part
+ * of it: that is the application's own wiring, and the application knows it.
+ *
+ * Which account it is and who keeps the payment method stay inside: a prospect is
+ * told that a card or a direct debit will be asked for, not where it is kept.
+ */
+interface PublicNewPaymentMethods {
+    /** Whether a new payment method is taken here at all. */
+    taken: boolean;
+    /** The methods the form offers, in the order the installation names them; empty where none is taken. */
+    methods: PaymentMethodType[];
+}
 /** Response of `GET /public/marketing-catalog`. */
 interface PublicMarketingCatalogResponse {
     locale: string;
     currency: string;
     /** VAT rate in percent — for the CheckoutOffer price breakdown. */
     vatRate: number;
+    /** What a new payment method is taken with here, if one is taken. */
+    newPaymentMethods: PublicNewPaymentMethods;
     /** Visible, marketed plans — sorted by `priority` DESC. */
     plans: PublicMarketingPlan[];
     /**
@@ -2145,6 +2213,16 @@ interface EffectiveLimitsSnapshot {
     plan: string;
     quotas: Record<string, number>;
     features: string[];
+    /**
+     * The add-ons a contract left out of these entitlements because their
+     * cancellation was already declared when it was written. Each is granted by
+     * its booking until its effective date, and by this snapshot never.
+     *
+     * Absent where nothing was left out — and on a snapshot written by an
+     * application, or before the platform left anything out, which then counts
+     * every add-on it names as its own.
+     */
+    leftOutBundleVersionIds?: string[];
 }
 
 interface FeatureUiMeta {
@@ -2390,7 +2468,7 @@ declare const CATALOGUE_KEYS: ReadonlySet<keyof PlanCatalog>;
  */
 declare function planCatalogSettingsOf(catalog: PlanCatalog): PlanCatalogSettings;
 /** Everything in the catalogue that is configuration, as it was resolved. */
-declare function settingsSubtreeOf(catalog: PlanCatalog): AppliedSettingsValues;
+declare function settingsSubtreeOf(catalog: PlanCatalog | PlanCatalogSettings): AppliedSettingsValues;
 /**
  * `JSON.stringify` with object keys in sorted order at every depth, so that two
  * documents saying the same thing in a different order serialise identically.
@@ -2858,6 +2936,11 @@ interface PromoCodeRecord {
     validUntil: Date | null;
     maxRedemptions: number | null;
     redemptionsCount: number;
+    /**
+     * Slots held for checkouts that started and have not concluded
+     * (`PromoCodeHoldRepository`). An adapter without holds reports 0.
+     */
+    heldCount: number;
     appliesToPlans: string[];
     appliesToBilling: BillingCycle | null;
     firstTimeCustomersOnly: boolean;
@@ -2947,7 +3030,7 @@ interface PromoCodeRedemptionListItem extends PromoCodeRedemptionRecord {
 /**
  * Adapter for PromoCode persistence. Atomic slot reservation lives in the
  * adapter because it is DB-specific (Postgres `UPDATE ... WHERE ... AND
- * (maxRedemptions IS NULL OR redemptionsCount < maxRedemptions)`).
+ * (maxRedemptions IS NULL OR redemptionsCount + heldCount < maxRedemptions)`).
  */
 interface PromoCodeRepository {
     findById(id: string): Promise<PromoCodeRecord | null>;
@@ -2958,12 +3041,17 @@ interface PromoCodeRepository {
     softDelete(id: string): Promise<void>;
     /**
      * Atomic slot reservation: increments `redemptionsCount` and checks
-     * `status === 'ACTIVE' && (maxRedemptions IS NULL || redemptionsCount < maxRedemptions)`.
+     * `status === 'ACTIVE' && (maxRedemptions IS NULL || redemptionsCount + heldCount < maxRedemptions)`.
      * Returns true if the slot was reserved, false if EXHAUSTED
-     * or the status is not ACTIVE.
+     * or the status is not ACTIVE. A slot held for a checkout is not free, so
+     * an adapter that keeps holds counts `heldCount` here.
      */
     claimSlot(id: string, tx?: TransactionContext): Promise<boolean>;
-    /** Sets the status to `EXHAUSTED` when `redemptionsCount >= maxRedemptions`. */
+    /**
+     * Sets the status to `EXHAUSTED` when `redemptionsCount >= maxRedemptions`.
+     * Holds do not count: a code full only because of held slots stays ACTIVE,
+     * and gets its slots back when the holds end.
+     */
     markExhaustedIfFull(id: string, tx?: TransactionContext): Promise<void>;
     /** Decrements `redemptionsCount` by 1 (min 0); EXHAUSTED → ACTIVE. */
     releaseSlot(id: string, tx?: TransactionContext): Promise<void>;
@@ -2973,6 +3061,98 @@ interface PromoCodeRepository {
      */
     expireDueCodes(now: Date): Promise<number>;
 }
+/**
+ * A slot of a code kept for a checkout offer, from the start of its checkout
+ * until the checkout concludes, the offer's code changes, or `expiresAt`
+ * passes, whichever comes first. For a sign-up, `expiresAt` is the last moment
+ * a confirmation of its payment form can arrive
+ * (`PaymentMethodSetupSession.confirmableUntil`), not the checkout's lifetime.
+ */
+interface PromoCodeHoldRecord {
+    id: string;
+    promoCodeId: string;
+    checkoutOfferId: string;
+    expiresAt: Date;
+    createdAt: Date;
+}
+/** What `PromoCodeHoldRepository.take` did. */
+type PromoCodeHoldTaken = {
+    outcome: 'taken';
+    hold: PromoCodeHoldRecord;
+}
+/** The code is not ACTIVE, is deleted, or has no free slot. */
+ | {
+    outcome: 'no-slot';
+}
+/** The offer holds a slot already, perhaps taken by a concurrent call. */
+ | {
+    outcome: 'offer-holds-one';
+};
+/**
+ * Adapter for the slots a code keeps for checkouts. Every method that ends a
+ * hold deletes its row and gives its slot back in one statement, so a hold is
+ * counted in `PromoCodeRecord.heldCount` exactly as long as its row exists.
+ *
+ * Optional in the promo module: an adapter that has no holds leaves
+ * `heldCount` at 0, and taking a hold then refuses to start rather than
+ * quietly holding nothing.
+ */
+interface PromoCodeHoldRepository {
+    /** The offer's hold, live or past its expiry and not yet given back. */
+    findByCheckoutOffer(checkoutOfferId: string, tx?: TransactionContext): Promise<PromoCodeHoldRecord | null>;
+    /**
+     * Takes a slot of an ACTIVE, undeleted code for the offer, atomically with
+     * `claimSlot`'s rule: `maxRedemptions IS NULL OR redemptionsCount +
+     * heldCount < maxRedemptions`. An offer holds one slot at most. Runs on a
+     * transaction of its own: a checkout starts outside any other, and the
+     * slot is committed before the gateway's form opens.
+     */
+    take(hold: {
+        promoCodeId: string;
+        checkoutOfferId: string;
+        expiresAt: Date;
+    }): Promise<PromoCodeHoldTaken>;
+    /**
+     * Moves the expiry of the offer's hold on that code to `expiresAt`, and
+     * never earlier than it stands: the later of the two is written in the one
+     * statement, so a start of the same checkout that asks for less cannot
+     * shorten the slot a form opened by another start relies on, however the
+     * two interleave. False when the offer holds no slot of it any more — it
+     * ended in the meantime.
+     */
+    extend(checkoutOfferId: string, promoCodeId: string, expiresAt: Date): Promise<boolean>;
+    /** Ends the offer's hold and gives its slot back. False when it had none. */
+    release(checkoutOfferId: string, tx?: TransactionContext): Promise<boolean>;
+    /**
+     * Ends the offer's hold and gives its slot back only while it still expires
+     * at `expiresAt` — the hold as the caller wrote it. A hold another start
+     * moved since stays, and so does its slot, in the same statement. False when
+     * nothing was given back.
+     */
+    releaseIfUnmoved(checkoutOfferId: string, expiresAt: Date): Promise<boolean>;
+    /**
+     * Marks the offer's hold, if it is live at `now`, as the slot of the
+     * redemption that runs on `tx`. The mark never outlives the transaction: the
+     * redemption turns the hold into its slot (`convertHandedOver`), or the
+     * caller releases it before committing. False when the offer has no live
+     * hold.
+     */
+    handOver(checkoutOfferId: string, now: Date, tx: TransactionContext): Promise<boolean>;
+    /**
+     * Turns the hold of that code handed over on `tx` into a redemption's slot:
+     * the row goes, `heldCount` drops by one and `redemptionsCount` rises by one,
+     * whatever the code's status. False when nothing was handed over on `tx`.
+     */
+    convertHandedOver(promoCodeId: string, tx: TransactionContext): Promise<boolean>;
+    /**
+     * Ends every hold past its expiry at `now` — of one code when `promoCodeId`
+     * is given — and gives the slots back. A hold handed over on `tx` is left
+     * to the conclusion running there; one handed over on another running
+     * transaction is waited for, and is gone once that transaction ends.
+     * Returns how many ended.
+     */
+    expireDue(now: Date, promoCodeId?: string, tx?: TransactionContext): Promise<number>;
+}
 /** Adapter for PromoCodeRedemption persistence. */
 interface PromoCodeRedemptionRepository {
     findBySubscription(subscriptionId: string, tx?: TransactionContext): Promise<PromoCodeRedemptionRecord | null>;
@@ -3054,7 +3234,14 @@ interface ContractLineItemRecord {
     descriptionSnapshot: string | null;
     quantity: number;
     unit: string | null;
+    /**
+     * What the line costs over one of its billing periods, `quantity` already
+     * in it — not a unit price. A contract's totals take its lines as they
+     * stand, each counted as often as it falls due in one period of the
+     * contract, and are refused where they do not add up.
+     */
     priceNet: number;
+    /** `priceNet` with the line's share of the tax its rhythm owes. */
     priceGross: number;
     billingCycle: 'monthly' | 'yearly';
     /**
@@ -3341,6 +3528,128 @@ interface SubscriberCorrectionResult {
     correction: SubscriberCorrectionRecord | null;
 }
 
+/**
+ * What made the charge arise. activation: the first period of a subscription. renewal: a later period. planChange: what an immediate plan change adds. bundleBooking: the first, short period of an add-on. credit: a decision that reduces what is owed. correction: a counter-entry reversing an earlier charge, which is how the append-only journal answers a mistake.
+ */
+type SubscriberChargeOrigin = 'activation' | 'renewal' | 'planChange' | 'bundleBooking' | 'credit' | 'correction';
+/**
+ * Which kind of contract line the charge realises.
+ */
+type SubscriberChargeSource = 'plan' | 'bundle' | 'discount';
+/**
+ * One charge in a subscriber's account: an amount that became due for a period, derived from a line of the contract in force. The journal is append-only — a charge is never updated, and a mistake is answered with a counter-entry rather than an edit, so the account says what happened rather than what somebody thinks today. A charge is net: the tax is decided by the tax adapter when the charge is invoiced, from the subscriber's origin on that day, and computed once per rate on the invoice.
+ */
+interface SubscriberCharge {
+    /**
+     * The charge's own identifier. Never shown to a customer as an invoice number: invoice numbering is sequential, gapless and legally constrained per country, and an identifier somebody has already seen on a screen cannot become one later without confusion.
+     */
+    id: string;
+    /**
+     * The party the contract is concluded with, whose account this is. It outlives the tenant.
+     */
+    subscriberId: string;
+    /**
+     * The tenant the subscription belonged to when the charge arose.
+     */
+    tenantId: string;
+    /**
+     * The subscription the charge arose on. Part of the natural key.
+     */
+    subscriptionId: string;
+    /**
+     * The contract whose line the charge realises.
+     */
+    contractId: string;
+    /**
+     * The contract line the charge came from, so that every invoice line can be traced back to what was agreed.
+     */
+    contractLineItemId: string;
+    origin: SubscriberChargeOrigin;
+    source: SubscriberChargeSource;
+    /**
+     * Which thing of its source the charge is for, stable across contracts: the subscription id for the plan, the booking id for an add-on, the discount's key for a discount. Part of the natural key (subscriptionId, source, sourceRef, periodStart, origin), which is unique — a charge derived twice is written once.
+     */
+    sourceRef: string;
+    /**
+     * The start of the period the charge belongs to — the grouping key for an invoice.
+     */
+    periodStart: string;
+    periodEnd: string;
+    /**
+     * ISO 4217, as the contract line records it — recorded per charge so that a charge written in 2026 still means what it meant after the configured currency changes.
+     */
+    currency: string;
+    /**
+     * Net, rounded to the currency's decimal places once, when the charge is written; the written figure is the truth from then on. Negative for a discount.
+     */
+    amountNet: number;
+    /**
+     * When the amount became due. The account is ordered by this, not by when the row was written.
+     */
+    bookedAt: string;
+    createdAt: string;
+}
+
+/** A charge as a store reads it back: the wire format, with its dates as dates. */
+interface SubscriberChargeRecord {
+    id: string;
+    subscriberId: string;
+    tenantId: string;
+    subscriptionId: string;
+    contractId: string;
+    contractLineItemId: string;
+    origin: SubscriberChargeOrigin;
+    source: SubscriberChargeSource;
+    /** The subscription id for the plan, the booking id for an add-on, the discount's key. */
+    sourceRef: string;
+    periodStart: Date;
+    periodEnd: Date;
+    currency: string;
+    /** Net, rounded to the cent when written. Negative for a discount. */
+    amountNet: number;
+    /** When the amount became due. */
+    bookedAt: Date;
+    createdAt: Date;
+}
+/** A charge to write: everything but what the store assigns. */
+type NewSubscriberCharge = Omit<SubscriberChargeRecord, 'id' | 'createdAt'>;
+/**
+ * The manifest capability that announces the operator's view of an account.
+ * The platform sets it where it serves the view, and the admin UI shows the
+ * view only where it is set.
+ */
+declare const SUBSCRIBER_ACCOUNT_CAPABILITY = "charges.read";
+/** Whose account it is, as the operator is shown it. */
+interface AdminAccountHolder {
+    id: string;
+    /** What the customer quotes, and what an invoice will carry. */
+    customerNumber: string;
+    legalName: string;
+}
+/** One charge of an account, with the name its contract line gives it. */
+interface AdminAccountEntry {
+    /** The charge as the journal holds it. */
+    charge: SubscriberCharge;
+    /**
+     * The contract line's own title, as it was when the contract was
+     * concluded, or `null` where that line cannot be read.
+     */
+    title: string | null;
+}
+/**
+ * A tenant's account as the operator reads it: the charges of the subscription
+ * it holds, newest first — by when each became due, then by its period, then
+ * the plan before its add-ons before its discounts.
+ *
+ * No total: without invoices and payments, a sum would be what was charged so
+ * far, and it would be read as what is owed.
+ */
+interface AdminSubscriberAccount {
+    /** `null` for a tenant that has no subscriber. */
+    holder: AdminAccountHolder | null;
+    entries: AdminAccountEntry[];
+}
+
 /**
  * Snapshot form of a `Subscription` row for the EntitlementService
  * computation. The consumer maps its Prisma structure onto this form.
@@ -3588,6 +3897,27 @@ interface SubscriberRepository {
     /** Every correction of this subscriber, the latest first. */
     listCorrections(subscriberId: string): Promise<SubscriberCorrectionRecord[]>;
 }
+/**
+ * The subscriber's account: the charges that became due, one per contract line
+ * and period. Append-only — nothing here updates or deletes a charge, and a
+ * mistake is answered with a counter-entry (`SC-PRIC-020`).
+ *
+ * Owned by the subscriber rather than the tenant, so that it outlives the
+ * tenant it arose for (ADR 0012).
+ */
+interface SubscriberLedgerRepository {
+    /**
+     * Writes the charges that are not there yet and returns them.
+     *
+     * A charge whose natural key — subscription, source, source reference,
+     * period start and origin — is already written is left as it is and not
+     * returned, however often it is derived and whoever derives it at the same
+     * time: the unique index decides, not a read before the write.
+     */
+    recordCharges(charges: readonly NewSubscriberCharge[], tx?: TransactionContext): Promise<SubscriberChargeRecord[]>;
+    /** Every charge of one subscription, oldest period first. */
+    listBySubscription(subscriptionId: string, tx?: TransactionContext): Promise<SubscriberChargeRecord[]>;
+}
 /**
  * Display form of a subscription for the tenant self-service UI.
  * Richer than `SubscriptionRecord` (which is only the aggregation form); contains
@@ -3832,6 +4162,14 @@ interface CancelSubscriptionResult {
     alreadyCanceled: boolean;
 }
 interface TenantSubscriptionWritePort {
+    /**
+     * Whether the writes that change a plan — the immediate change and the
+     * onboarding selection — bind the subscription's `planVersionId` to the
+     * version they sell. A contract freeze records the bound version, so it
+     * refuses to start beside a write that says `false`. Left out, it is taken
+     * on trust: the platform cannot see into a write it did not ship.
+     */
+    readonly bindsPlanVersion?: boolean;
     /** Immediate change: set plan + cycle, clear pending fields, optionally reset the period. */
     changePlanImmediate(tenantId: string, input: ImmediatePlanChangeInput): Promise<{
         plan: string;
@@ -4110,13 +4448,14 @@ interface AdminResourcesPort {
 }
 /**
  * Read adapter for the current AdminManifest. The consumer implementation
- * delegates to its `AdminManifestService.getManifest()`. The platform CLI
- * uses this for `<app> manifest dump|hash|check` etc.
+ * delegates to its `AdminManifestService.getManifest()`, which reads the plan
+ * catalogue on every call and therefore answers asynchronously. The platform
+ * CLI uses this for `<app> manifest dump|hash|check` etc.
  */
 interface ManifestAccessPort {
-    getManifest(): AdminManifest;
+    getManifest(): Promise<AdminManifest>;
     /** Optional: forces a rebuild from the contributions (e.g. after code reload). */
-    rebuild?(): AdminManifest;
+    rebuild?(): Promise<AdminManifest>;
 }
 /**
  * Adapter for the RLS bypass context. Platform code calls `runWithBypass`,
@@ -4606,6 +4945,26 @@ interface SubscriberPaymentMethodSetupMatch {
     sessionRef: string;
     subscriberId: string;
 }
+/**
+ * Which payment method a read by reference asks about.
+ *
+ * All three together, because `(gatewayAccount, paymentMethodRef)` is unique
+ * account-wide rather than per subscriber: without the subscriber the question
+ * has no answer that is this caller's.
+ *
+ * One argument rather than three strings in a row, for the reason
+ * `SubscriberPaymentMethodSetupMatch` is one — at a call site three strings of
+ * the same type can be swapped with nothing saying so — and for a second that
+ * is specific to a port. `TransactionContext` is `unknown`, so it accepts a
+ * string: against a positional signature, an implementation whose parameters
+ * are offset by one typechecks and then reads the account out of the
+ * subscriber's place. Against an object it does not.
+ */
+interface SubscriberPaymentMethodReference {
+    subscriberId: string;
+    gatewayAccount: string;
+    paymentMethodRef: string;
+}
 interface RecordSubscriberPaymentMethodResult {
     method: SubscriberPaymentMethodRecord;
     outcome: RecordSubscriberPaymentMethodOutcome;
@@ -4666,24 +5025,66 @@ interface PaymentEventLog {
  *
  * A subscriber has at most one `ACTIVE` payment method; the database holds
  * that, so two confirmations recorded at once for one subscriber end with one.
+ *
+ * **Within an account, a reference belongs to exactly one subscriber**, and
+ * keeps belonging to it once a newer payment method has replaced it. Every
+ * method that reaches a payment method therefore names the subscriber it is
+ * about, and an implementation answers about that one only. `accountsInUse` is
+ * the exception and says so at itself: it counts accounts rather than handing
+ * out a row.
+ *
+ * That matters on a gateway callback, which is where these are reached: it
+ * arrives without a session, so an installation that keeps its tenants apart
+ * with a policy lifts that policy for it, and what the question names is then
+ * all that bounds it.
  */
 interface SubscriberPaymentMethodRepository {
     /**
      * Records a confirmed payment method for its subscriber, under a lock on the
      * subscriber so two confirmations take turns. See
      * `RecordSubscriberPaymentMethodOutcome` for the three outcomes.
+     *
+     * A confirmation carrying a reference **another** subscriber holds is a
+     * fourth case and has no outcome: it is refused with
+     * `ForeignPaymentMethodReferenceError`, because the account's reference is
+     * that subscriber's and answering `already-recorded` would hand its payment
+     * method to a caller acting for somebody else.
+     *
+     * Two subscribers can reach that reference at the same time: the lock is on
+     * the subscriber, so confirmations for two of them do not take turns, and a
+     * read sees nothing of a row the other has not committed. Reading is
+     * therefore not enough to decide it. **Claim the reference with the first
+     * write, conflict-free** — `ON CONFLICT DO NOTHING` on its unique key, or
+     * whatever the store spells that as — and refuse when the claim takes no
+     * row. Both shipped adapters do exactly that, and it is what lets the
+     * refusal say the same thing everywhere: the key decides, not an error
+     * whose shape belongs to one driver.
+     *
+     * The order is part of the contract, not an implementation detail. Because
+     * the claim is the first write, a refusal leaves the caller's transaction
+     * as it found it — nothing to undo, and nothing that makes it unusable.
+     * An implementation that writes before it claims cannot promise that.
      */
     recordConfirmed(data: RecordSubscriberPaymentMethodData, tx?: TransactionContext): Promise<RecordSubscriberPaymentMethodResult>;
     /** The subscriber's payment method in use, or `null` when it has none. */
     findActive(subscriberId: string, tx?: TransactionContext): Promise<SubscriberPaymentMethodRecord | null>;
     /**
-     * The payment method an account's reference names, whatever its status.
+     * The payment method the reference names, whatever its status — and `null`
+     * when that subscriber holds none under it, which includes the case of
+     * another subscriber holding the reference.
      *
      * The one read that reaches a payment method a newer one replaced, which is
      * how `@saasicat/persistence-testing` verifies that an implementation keeps
      * the history rather than overwriting the row (`SC-PRIC-030`).
+     *
+     * The subscriber is what bounds the read. Without it an implementation
+     * would have only the account's reference to go on, which is unique
+     * account-wide: inside a tenant's context a policy would answer `null` and
+     * on a gateway callback, where that policy is lifted, the same call would
+     * answer with somebody else's row. One question, two answers by where it
+     * was asked, is what naming the subscriber removes.
      */
-    findByReference(gatewayAccount: string, paymentMethodRef: string, tx?: TransactionContext): Promise<SubscriberPaymentMethodRecord | null>;
+    findByReference(reference: SubscriberPaymentMethodReference, tx?: TransactionContext): Promise<SubscriberPaymentMethodRecord | null>;
     /**
      * Every account that holds a payment method in use, each once.
      *
@@ -4844,6 +5245,8 @@ interface SaaSiCatPersistenceEntitlement {
     subscriptionContractRepository?: PersistenceProvider<SubscriptionContractRepository>;
     /** The parties contracts are concluded with; required wherever contracts are written. */
     subscriberRepository?: PersistenceProvider<SubscriberRepository>;
+    /** The charges a subscriber's contracts give rise to (`tenantBilling.chargeJournal`). */
+    subscriberLedgerRepository?: PersistenceProvider<SubscriberLedgerRepository>;
     subscriptionBundleRepository?: PersistenceProvider<SubscriptionBundleRepository>;
     bundleRepository?: PersistenceProvider<BundleRepository>;
 }
@@ -4895,6 +5298,8 @@ interface SaaSiCatPersistencePromo {
     validationLogRepository: PersistenceProvider<PromoCodeValidationLogRepository>;
     subscriptionLookup: PersistenceProvider<PromoSubscriptionLookup>;
     revenueAggregator: PersistenceProvider<PromoRevenueDeductionAggregator>;
+    /** The slots a code keeps for checkouts; left out, no checkout holds one. */
+    holdRepository?: PersistenceProvider<PromoCodeHoldRepository>;
 }
 /**
  * Aggregate persistence bundle. Produced by adapter factories such as
@@ -5006,6 +5411,12 @@ declare const CATALOG_ERROR_CODES: {
     readonly FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND";
     readonly QUOTA_NOT_FOUND: "QUOTA_NOT_FOUND";
     readonly PROMOTION_NOT_FOUND: "PROMOTION_NOT_FOUND";
+    /**
+     * A promotion's value is not one its type takes: a percentage above 0 and
+     * at most 100, an amount above 0, an intro price of at least 0 for a whole
+     * number of months, or a whole number of free months.
+     */
+    readonly PROMOTION_VALUE_INVALID: "PROMOTION_VALUE_INVALID";
     readonly MARKETING_PROJECTION_NOT_FOUND: "MARKETING_PROJECTION_NOT_FOUND";
     readonly PLAN_ALREADY_EXISTS: "PLAN_ALREADY_EXISTS";
     readonly BUNDLE_ALREADY_EXISTS: "BUNDLE_ALREADY_EXISTS";
@@ -5152,6 +5563,13 @@ declare const CONTRACT_ERROR_CODES: {
     readonly SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH: "SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH";
     readonly SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT: "SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT";
     readonly SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH: "SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH";
+    /**
+     * The lines do not add up to a total the contract states, counted as often
+     * as each falls due in one period. `field` names the total.
+     */
+    readonly SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP: "SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP";
+    /** Something that takes money off states a negative amount. */
+    readonly SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE: "SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE";
     readonly SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START: "SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START";
     readonly CHECKOUT_OFFER_NOT_FOUND: "CHECKOUT_OFFER_NOT_FOUND";
     readonly CHECKOUT_OFFER_EXPIRED: "CHECKOUT_OFFER_EXPIRED";
@@ -5274,6 +5692,13 @@ declare const PAYMENT_ERROR_CODES: {
      * does not name. Carries `field`.
      */
     readonly PAYMENT_RETURN_URL_NOT_ALLOWED: "PAYMENT_RETURN_URL_NOT_ALLOWED";
+    /**
+     * The gateway failed — unreachable, refusing the account's keys, or
+     * answering with an error — while opening its form or reading a callback
+     * back. Answered with 502; what the gateway answered stays in the server
+     * log.
+     */
+    readonly PAYMENT_GATEWAY_FAILED: "PAYMENT_GATEWAY_FAILED";
 };
 type PaymentErrorCode = (typeof PAYMENT_ERROR_CODES)[keyof typeof PAYMENT_ERROR_CODES];
 /** Codes of the settings record (`GET /admin/settings`, the acknowledgement). */
@@ -5306,6 +5731,13 @@ declare const PLATFORM_ERROR_CODES: {
      * does not name. Carries `field`.
      */
     readonly PAYMENT_RETURN_URL_NOT_ALLOWED: "PAYMENT_RETURN_URL_NOT_ALLOWED";
+    /**
+     * The gateway failed — unreachable, refusing the account's keys, or
+     * answering with an error — while opening its form or reading a callback
+     * back. Answered with 502; what the gateway answered stays in the server
+     * log.
+     */
+    readonly PAYMENT_GATEWAY_FAILED: "PAYMENT_GATEWAY_FAILED";
     readonly PENDING_REGISTRATION_NOT_FOUND: "PENDING_REGISTRATION_NOT_FOUND";
     readonly PENDING_REGISTRATION_EXPIRED: "PENDING_REGISTRATION_EXPIRED";
     readonly INVALID_REGISTRATION_STATE: "INVALID_REGISTRATION_STATE";
@@ -5359,6 +5791,13 @@ declare const PLATFORM_ERROR_CODES: {
     readonly SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH: "SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH";
     readonly SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT: "SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT";
     readonly SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH: "SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH";
+    /**
+     * The lines do not add up to a total the contract states, counted as often
+     * as each falls due in one period. `field` names the total.
+     */
+    readonly SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP: "SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP";
+    /** Something that takes money off states a negative amount. */
+    readonly SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE: "SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE";
     readonly SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START: "SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START";
     readonly CHECKOUT_OFFER_NOT_FOUND: "CHECKOUT_OFFER_NOT_FOUND";
     readonly CHECKOUT_OFFER_EXPIRED: "CHECKOUT_OFFER_EXPIRED";
@@ -5527,6 +5966,12 @@ declare const PLATFORM_ERROR_CODES: {
     readonly FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND";
     readonly QUOTA_NOT_FOUND: "QUOTA_NOT_FOUND";
     readonly PROMOTION_NOT_FOUND: "PROMOTION_NOT_FOUND";
+    /**
+     * A promotion's value is not one its type takes: a percentage above 0 and
+     * at most 100, an amount above 0, an intro price of at least 0 for a whole
+     * number of months, or a whole number of free months.
+     */
+    readonly PROMOTION_VALUE_INVALID: "PROMOTION_VALUE_INVALID";
     readonly MARKETING_PROJECTION_NOT_FOUND: "MARKETING_PROJECTION_NOT_FOUND";
     readonly PLAN_ALREADY_EXISTS: "PLAN_ALREADY_EXISTS";
     readonly BUNDLE_ALREADY_EXISTS: "BUNDLE_ALREADY_EXISTS";
@@ -6310,6 +6755,16 @@ interface StartCheckoutInput {
     successUrl: string;
     /** Where the gateway's form sends the person who leaves it. */
     cancelUrl: string;
+    /**
+     * The checkout offer the sign-up concludes on activation. When it carries a
+     * promo code, a slot of that code is held for it from this step until a
+     * confirmation of the gateway's form can no longer arrive
+     * (`PaymentMethodSetupSession.confirmableUntil`), so the code cannot run
+     * out between this step and the payment confirmation; a code that cannot
+     * be held refuses the step before the gateway's form opens. Left out,
+     * nothing is held.
+     */
+    checkoutOfferId?: string | null;
 }
 interface StartCheckoutResult {
     pendingRegistrationId: string;
@@ -6500,6 +6955,47 @@ type IssuerIdentityChange =
  */
 declare function classifyIssuerChange(recorded: LegalIdentity | null, issuer: PlanCatalogIssuer | undefined): IssuerIdentityChange;
 
+/**
+ * A `subscriber_ledger_entries` row as either adapter reads it back. The amount
+ * is `unknown` because a Prisma row carries a `Decimal` where a Drizzle row
+ * carries a numeric string.
+ */
+interface CanonicalSubscriberChargeRow {
+    id: string;
+    subscriberId: string;
+    tenantId: string;
+    subscriptionId: string;
+    contractId: string;
+    contractLineItemId: string;
+    origin: string;
+    source: string;
+    sourceRef: string;
+    periodStart: Date;
+    periodEnd: Date;
+    currency: string;
+    amountNet: unknown;
+    bookedAt: Date;
+    createdAt: Date;
+}
+/**
+ * Reads a row back as a record. The origin and the source are checked rather
+ * than cast: a value written by hand or by a later release would otherwise
+ * reach an invoice as a charge nobody knows how to read.
+ */
+declare function toSubscriberChargeRecord(row: CanonicalSubscriberChargeRow): SubscriberChargeRecord;
+/**
+ * The columns a charge is written with. The amount goes as a decimal string of
+ * two places, which both a Prisma `Decimal` and a PostgreSQL `numeric` take
+ * exactly — a JavaScript number on its way to either is where a cent is lost.
+ *
+ * An amount that is not already a whole number of cents is refused rather than
+ * rounded: a charge is rounded once, where it is derived, and a second rounding
+ * here would make the written figure differ from the one that was computed.
+ */
+declare function subscriberChargeColumns(charge: NewSubscriberCharge): Omit<CanonicalSubscriberChargeRow, 'id' | 'createdAt' | 'amountNet'> & {
+    amountNet: string;
+};
+
 /** A `subscribers` row as either adapter reads it back. */
 interface CanonicalSubscriberRow {
     id: string;
@@ -6589,6 +7085,75 @@ interface CanonicalSubscriberPaymentMethodRow {
 declare function toSubscriberPaymentMethodRecord(row: CanonicalSubscriberPaymentMethodRow): SubscriberPaymentMethodRecord;
 /** The columns a confirmed payment method is written with, and nothing a caller added beside them. */
 declare function subscriberPaymentMethodColumns(data: RecordSubscriberPaymentMethodData): Omit<CanonicalSubscriberPaymentMethodRow, 'id' | 'status' | 'replacedAt' | 'createdAt'>;
+/**
+ * A confirmation naming a reference that belongs to another subscriber.
+ *
+ * `(gatewayAccount, paymentMethodRef)` is unique account-wide rather than per
+ * subscriber, and that is what makes the reference one subscriber's for good:
+ * the second row cannot be written. This is the same boundary drawn for the
+ * caller, so that a confirmation is refused rather than answered as the
+ * duplicate of a payment method that is not this subscriber's — on a gateway
+ * callback, which arrives without a session and with the tenant policy lifted,
+ * so nothing else there bounds the question.
+ *
+ * That a provider issues a reference once per payer is a property of that
+ * provider and no promise of this platform's, which is why the condition is
+ * checked rather than assumed.
+ *
+ * It names neither the subscriber that holds the reference nor the tenant
+ * behind it: whoever reads the log of the refused confirmation is on the other
+ * side of the boundary this refusal draws. The account and the reference are
+ * carried as fields so that a caller can say which confirmation was refused
+ * without taking the sentence apart.
+ */
+declare class ForeignPaymentMethodReferenceError extends Error {
+    readonly gatewayAccount: string;
+    readonly paymentMethodRef: string;
+    readonly code = "FOREIGN_PAYMENT_METHOD_REFERENCE";
+    constructor(gatewayAccount: string, paymentMethodRef: string);
+}
+/** Realm-safe type guard, like `isPaymentCallbackRejectedError`. */
+declare function isForeignPaymentMethodReferenceError(error: unknown): error is ForeignPaymentMethodReferenceError;
+/**
+ * Refuses a reference of `gatewayAccount` that another subscriber already
+ * holds, where the row could be read.
+ *
+ * A write cannot rely on this alone: a read does not see a row a concurrent
+ * transaction has not committed. What the reference's unique key refuses is
+ * refused with the same error — see `SubscriberPaymentMethodRepository`.
+ */
+declare function refuseForeignPaymentMethodReference(recorded: Pick<CanonicalSubscriberPaymentMethodRow, 'subscriberId' | 'gatewayAccount' | 'paymentMethodRef'>, subscriberId: string): void;
+
+/**
+ * A `subscription_bundles` row as either adapter reads it back.
+ *
+ * The three billing columns are optional because a Prisma client generated from
+ * a schema that predates them returns a row without them; an absent column
+ * reads as null, the same as a booking made before they existed.
+ */
+interface CanonicalSubscriptionBundleRow {
+    id: string;
+    subscriptionId: string;
+    bundleVersionId: string;
+    startedAt: Date;
+    minimumTermEndsAt: Date | null;
+    billingCycle?: string | null;
+    currentPeriodStart?: Date | null;
+    currentPeriodEnd?: Date | null;
+    canceledAt: Date | null;
+    canceledEffectiveAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Reads a row back as a record.
+ *
+ * `billingCycle` is a text column the platform only ever writes as `MONTHLY` or
+ * `YEARLY`, and a price is chosen by asking whether it is `YEARLY` — so any
+ * other value would be billed monthly without a word. It is checked rather than
+ * cast, and a value outside the two stops the read.
+ */
+declare function toSubscriptionBundleRecord(row: CanonicalSubscriptionBundleRow): SubscriptionBundleRecord;
 
 /** A `subscription_contracts` row as either adapter reads it back. */
 interface CanonicalContractRow {
@@ -6733,4 +7298,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 AdminActor, type AdminAuditListFilter, type AdminManifest, type AdminResourcesPort, type AdminSubscriptionListRow, type AdminTenantDetail, type AdminTenantListFilter, type AdminTenantListRow, type AdminTenantStateResult, type AdminUserListFilter, type AdminUserListRow, type AppliedSettingsPort, type AppliedSettingsRecord, type AppliedSettingsValues, type ApplyOnboardingSelectionInput, type ApplyOnboardingSelectionResult, type ApprovedCatalogKeys, type AuditActionDef, type AuditEntry, type AuditPort, type AuditQuery, type AuditQueryPort, type AuditStatsPort, type AuditStatsSnapshot, type AuthErrorCode, BILLING_ERROR_CODES, BUNDLE_PRICE_LOOKUP_LIMIT, type BillingCycle, type BillingErrorCode, type BundleAvailabilityState, type BundleCompatibility, type BundleFeatureShape, type BundleListFilter, type BundlePricingOverride, type BundleRepository, type BundleRow, type BundleVersionFields, type BundleVersionMutationResult, type BundleVersionRow, CATALOGUE_KEYS, CATALOG_ERROR_CODES, CONTRACT_ERROR_CODES, type CancelSubscriptionBundleData, type CancelSubscriptionInput, type CancelSubscriptionResult, type CancellationNoticePeriods, type CanonicalContractLineItemRow, type CanonicalContractRow, type CanonicalPlanRow, type CanonicalPlanVersionRow, type CanonicalRunningContractRow, type CanonicalSubscriberCorrectionRow, type CanonicalSubscriberPaymentMethodRow, type CanonicalSubscriberRow, type CapabilityCatalogEntryRow, type CapabilityCodeStatus, type CapabilityKey, type CapabilityKind, type CatalogEntryFilter, type CatalogEntryI18n, type CatalogEntryI18nFields, type CatalogEntryRepository, type CatalogErrorCode, 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 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 DiffResult, type DiscoveredCapability, type DiscoveredFeature, type DiscoveredQuota, type DiscoveredQuotaPolicy, type DiscoveryCodeStatus, type DiscoverySnapshot, type DiscoveryStatus, ERROR_MESSAGES_DE, ERROR_MESSAGES_EN, type EffectiveLimitsSnapshot, type EmailPort, type ErrorMessageParams, FEATURE_NOT_LICENSED, type FeatureCatalogEntryRow, type FeatureDef, type FeatureKey, type FeatureNotLicensedBody, type FeatureRequiresIndex, type FeatureTier, type FeatureUiMeta, type FeatureUiRegistry, type FinalActivationResult, type FirstTimeCustomerCheck, type ImmediatePlanChangeInput, type InvoiceLineItemSnapshot, type IssuerCorrectionFault, type IssuerIdentityChange, type KpiCardDef, type KpiDisplayHint, LEGAL_IDENTITY_FIELDS, type LegalIdentity, type LegalIdentityField, MARKETING_PRIORITY_MAX, MARKETING_PRIORITY_MIN, type ManifestAccessPort, type ManifestContribution, type MarketingProjectionFilter, type MarketingProjectionRepository, type MarketingProjectionRow, type MarketingSettingsRepository, type MarketingSettingsRow, type MarketingTargetType, type MarketingTopFeature, type MaskedPaymentMethod, type MfaPort, type NewContractLineItemData, type NewSettingsChange, type NewSubscriberDetails, type NewSubscriptionContractData, OTP_RATE_LIMIT_MAX_SENDS, OTP_RATE_LIMIT_WINDOW_MINUTES, OTP_TTL_MINUTES, OTP_VERIFY_MAX_ATTEMPTS, type OnboardingPromoRedemption, type OnboardingSelectionRequest, type OnboardingSelectionResponse, 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, type PlanCatalog, type PlanCatalogApp, type PlanCatalogImportReport, type PlanCatalogImportSink, type PlanCatalogIssuer, type PlanCatalogIssuerCorrection, type PlanCatalogLookup, type PlanCatalogMarketing, type PlanCatalogNotifications, type PlanCatalogPaymentAccount, type PlanCatalogPayments, type PlanCatalogReadSink, type PlanCatalogReadSnapshot, type PlanCatalogSettings, type PlanCatalogSubscribers, type PlanCatalogTenantBilling, type PlanDef, type PlanId, type PlanListFilter, type PlanRepository, type PlanRow, type PlanVersion, type PlanVersionFields, type PlanVersionMappingFields, type PlanVersionMutationResult, type PlanVersionRecord, type PlanVersionRepository, type PlanVersionRow, type PlatformErrorBody, type PlatformErrorCode, type PlatformRole, type PlatformUserDto, PlatformUserExistsError, type ProjectPageDef, type PromoCode, type PromoCodeDurationType, type PromoCodeFilter, 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 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 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, type ReassignTenantAdminCliResult, type RecommendablePlan, type RecordSubscriberPaymentMethodData, type RecordSubscriberPaymentMethodOutcome, type RecordSubscriberPaymentMethodResult, type RedeemPromoInTransactionCallback, type RegistrationActivation, type RegistrationAuditContext, type RegistrationAuditEvent, type RegistrationAuditEventType, type RegistrationAuditLogger, type RegistrationBillingDetails, type RegistrationConfigSelection, type RegistrationConfiguratorLookup, type RegistrationErrorCode, type RegistrationOtpDelivery, type RegistrationPromoPreview, type RegistrationResumeDelivery, type RegistrationResumeTokenSigner, type RegistrationStatus, type RegistrationStep, type RequiredCapabilities, type ResolvableErrorBody, type ResumeRegistrationInput, type ResumeRegistrationResult, type ReviewCatalogEntryData, type RlsBypassPort, type RunningContractIssuer, type RunningContractIssuers, SETTINGS_ERROR_CODES, SETUP_ERROR_CODES, SUBSCRIBER_ERROR_CODES, type SaaSiCatPersistenceAdapter, type SaaSiCatPersistenceAdminResources, type SaaSiCatPersistenceCatalog, type SaaSiCatPersistenceCore, type SaaSiCatPersistenceEntitlement, type SaaSiCatPersistencePayments, type SaaSiCatPersistencePromo, type SaaSiCatPersistenceTenantBilling, type SaveRegistrationConfigInput, type SaveRegistrationConfigResult, type ScheduledPlanChangeInput, 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 SubscriberContact, type SubscriberContactChange, type SubscriberCorrectionData, type SubscriberCorrectionRecord, type SubscriberCorrectionResult, type SubscriberDetails, type SubscriberErrorCode, type SubscriberIdentityCorrection, type SubscriberIdentityDelta, type SubscriberIdentityValues, type SubscriberPaymentMethodRecord, type SubscriberPaymentMethodRepository, type SubscriberPaymentMethodSetupData, type SubscriberPaymentMethodSetupMatch, type SubscriberPaymentMethodStatus, type SubscriberRecord, type SubscriberRepository, type Subscription, type SubscriptionBundleRecord, type SubscriptionBundleRepository, type SubscriptionBundleView, type SubscriptionContractFilter, type SubscriptionContractInvoiceSnapshot, type SubscriptionContractParties, type SubscriptionContractPriceSnapshot, type SubscriptionContractRecord, type SubscriptionContractRepository, type SubscriptionContractStatus, type SubscriptionRecord, type SubscriptionRepository, type SubscriptionStatsPort, type SubscriptionStatsSnapshot, type SubscriptionStatus, type SubscriptionUsagePort, type SubscriptionUsageRecord, type SuperAdminProvisioningPort, type SyncDiscoveryResult, type TenantActionDef, type TenantColumnDef, type TenantDto, type TenantListFilter, type TenantPort, 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, type VerifyRegistrationOtpResult, type VersionChange, type VersionChangeDirection, type VersionEditability, type VersionEditableReason, type VersionedEntityBase, applyPromo, assertPersistenceCapabilities, buildActivePlanVersionWhere, buildActiveVersionWhere, buildFeatureRequiresIndex, bundleDraftDefaults, bundleStemDefaults, canonicalJson, classifyBundleVersionDiff, classifyIssuerChange, classifyPlanDiff, collectUnsatisfiedRequires, contractPartiesOf, coverageExcludingSelf, definedFields, diffSettings, formatCustomerNumber, formatErrorMessage, identityCorrectionDelta, isBundleRedundant, isPaymentCallbackRejectedError, isPlatformUserExistsError, isVersionEditable, issuerIdentityOf, keepOneRecommended, missingRequiresFor, movedIdentityFields, pickActivePromo, planCatalogSettingsOf, previousUtcDay, promoStatus, readQuotaRecord, readQuotaValue, recordedIssuerIdentity, resolveBundleAvailability, resolveErrorMessage, sameLegalIdentity, selectChargeableBundles, settingsSubtreeOf, startOfUtcDay, subscriberFromRegistration, subscriberPaymentMethodColumns, toBundleStemRow, toContractLineItemRecord, toPlanRow, toPlanVersionRow, toRunningContractIssuer, toSubscriberCorrectionRecord, toSubscriberPaymentMethodRecord, toSubscriberRecord, toSubscriptionContractRecord };
+export { ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES, AUTH_ERROR_CODES, type ActionKey, type ActivationOrchestrator, type ActivePlanVersionWhere, type ActivePlanVersionWhereWithEndsAt, type ActiveVersionWhere, type ActiveVersionWhereWithEndsAt, type ActorTag, type AdminAccountEntry, type AdminAccountHolder, type AdminActor, type AdminAuditListFilter, type AdminManifest, type AdminResourcesPort, type AdminSubscriberAccount, type AdminSubscriptionListRow, type AdminTenantDetail, type AdminTenantListFilter, type AdminTenantListRow, type AdminTenantStateResult, type AdminUserListFilter, type AdminUserListRow, type AppliedSettingsPort, type AppliedSettingsRecord, type AppliedSettingsValues, type ApplyOnboardingSelectionInput, type ApplyOnboardingSelectionResult, type ApprovedCatalogKeys, type AuditActionDef, type AuditEntry, type AuditPort, type AuditQuery, type AuditQueryPort, type AuditStatsPort, type AuditStatsSnapshot, type AuthErrorCode, BILLING_ERROR_CODES, BUNDLE_PRICE_LOOKUP_LIMIT, type BillingCycle, type BillingErrorCode, type BundleAvailabilityState, type BundleCompatibility, type BundleFeatureShape, type BundleListFilter, type BundlePricingOverride, type BundleRepository, type BundleRow, type BundleVersionFields, type BundleVersionMutationResult, type BundleVersionRow, CATALOGUE_KEYS, CATALOG_ERROR_CODES, CONTRACT_ERROR_CODES, type CancelSubscriptionBundleData, type CancelSubscriptionInput, type CancelSubscriptionResult, type CancellationNoticePeriods, type CanonicalContractLineItemRow, type CanonicalContractRow, type CanonicalPlanRow, type CanonicalPlanVersionRow, type CanonicalRunningContractRow, type CanonicalSubscriberChargeRow, type CanonicalSubscriberCorrectionRow, type CanonicalSubscriberPaymentMethodRow, type CanonicalSubscriberRow, type CanonicalSubscriptionBundleRow, type CapabilityCatalogEntryRow, type CapabilityCodeStatus, type CapabilityKey, type CapabilityKind, type CatalogEntryFilter, type CatalogEntryI18n, type CatalogEntryI18nFields, type CatalogEntryRepository, type CatalogErrorCode, 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 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 DiffResult, type DiscoveredCapability, type DiscoveredFeature, type DiscoveredQuota, type DiscoveredQuotaPolicy, type DiscoveryCodeStatus, type DiscoverySnapshot, type DiscoveryStatus, ERROR_MESSAGES_DE, ERROR_MESSAGES_EN, type EffectiveLimitsSnapshot, type EmailPort, type ErrorMessageParams, FEATURE_NOT_LICENSED, type FeatureCatalogEntryRow, type FeatureDef, type FeatureKey, type FeatureNotLicensedBody, type FeatureRequiresIndex, type FeatureTier, type FeatureUiMeta, type FeatureUiRegistry, type FinalActivationResult, type FirstTimeCustomerCheck, ForeignPaymentMethodReferenceError, type ImmediatePlanChangeInput, type InvoiceLineItemSnapshot, type IssuerCorrectionFault, type IssuerIdentityChange, type KpiCardDef, type KpiDisplayHint, LEGAL_IDENTITY_FIELDS, type LegalIdentity, type LegalIdentityField, MARKETING_PRIORITY_MAX, MARKETING_PRIORITY_MIN, type ManifestAccessPort, type ManifestContribution, type MarketingProjectionFilter, type MarketingProjectionRepository, type MarketingProjectionRow, type MarketingSettingsRepository, type MarketingSettingsRow, type MarketingTargetType, type MarketingTopFeature, type MaskedPaymentMethod, type MfaPort, type NewContractLineItemData, type NewSettingsChange, type NewSubscriberCharge, type NewSubscriberDetails, type NewSubscriptionContractData, OTP_RATE_LIMIT_MAX_SENDS, OTP_RATE_LIMIT_WINDOW_MINUTES, OTP_TTL_MINUTES, OTP_VERIFY_MAX_ATTEMPTS, type OnboardingPromoRedemption, type OnboardingSelectionRequest, type OnboardingSelectionResponse, 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, type PlanCatalog, type PlanCatalogApp, type PlanCatalogImportReport, type PlanCatalogImportSink, type PlanCatalogIssuer, type PlanCatalogIssuerCorrection, type PlanCatalogLookup, type PlanCatalogMarketing, type PlanCatalogNotifications, type PlanCatalogPaymentAccount, type PlanCatalogPayments, type PlanCatalogReadSink, type PlanCatalogReadSnapshot, type PlanCatalogSettings, type PlanCatalogSubscribers, type PlanCatalogTenantBilling, type PlanDef, type PlanId, type PlanListFilter, type PlanRepository, type PlanRow, type PlanVersion, type PlanVersionFields, type PlanVersionMappingFields, type PlanVersionMutationResult, type PlanVersionRecord, type PlanVersionRepository, type PlanVersionRow, type PlatformErrorBody, type PlatformErrorCode, 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, type ReassignTenantAdminCliResult, type RecommendablePlan, type RecordSubscriberPaymentMethodData, type RecordSubscriberPaymentMethodOutcome, type RecordSubscriberPaymentMethodResult, type RedeemPromoInTransactionCallback, type RegistrationActivation, type RegistrationAuditContext, type RegistrationAuditEvent, type RegistrationAuditEventType, type RegistrationAuditLogger, type RegistrationBillingDetails, type RegistrationConfigSelection, type RegistrationConfiguratorLookup, type RegistrationErrorCode, type RegistrationOtpDelivery, type RegistrationPromoPreview, type RegistrationResumeDelivery, type RegistrationResumeTokenSigner, type RegistrationStatus, type RegistrationStep, type RequiredCapabilities, type ResolvableErrorBody, type ResumeRegistrationInput, type ResumeRegistrationResult, type ReviewCatalogEntryData, type RlsBypassPort, type RunningContractIssuer, type RunningContractIssuers, SETTINGS_ERROR_CODES, SETUP_ERROR_CODES, SUBSCRIBER_ACCOUNT_CAPABILITY, SUBSCRIBER_ERROR_CODES, type SaaSiCatPersistenceAdapter, type SaaSiCatPersistenceAdminResources, type SaaSiCatPersistenceCatalog, type SaaSiCatPersistenceCore, type SaaSiCatPersistenceEntitlement, type SaaSiCatPersistencePayments, type SaaSiCatPersistencePromo, type SaaSiCatPersistenceTenantBilling, type SaveRegistrationConfigInput, type SaveRegistrationConfigResult, type ScheduledPlanChangeInput, type SelectPlanInput, type SelectPlanResult, type SelectableBundleShape, type SelfServiceBlockedPlans, type SetCatalogEntryReviewData, type SettingsChangeFilter, type SettingsChangeRecord, type SettingsDifference, type SettingsErrorCode, type SetupConfirmMfaRequest, type SetupConfirmMfaResponse, type SetupErrorCode, type SetupRequest, type SetupResult, type SetupStatusResponse, type SlugAvailabilityCheck, type StandardPageDef, type StandardPageKey, type StartCheckoutInput, type StartCheckoutResult, type StartPaymentMethodSetupInput, type StartRegistrationInput, type StartRegistrationResult, type StoredBundleStem, type StrictModeWarning, type StrictModeWarningCode, type SubscriberCharge, type SubscriberChargeOrigin, type SubscriberChargeRecord, type SubscriberChargeSource, type SubscriberContact, type SubscriberContactChange, type SubscriberCorrectionData, type SubscriberCorrectionRecord, type SubscriberCorrectionResult, type SubscriberDetails, type SubscriberErrorCode, type SubscriberIdentityCorrection, type SubscriberIdentityDelta, type SubscriberIdentityValues, type SubscriberLedgerRepository, type SubscriberPaymentMethodRecord, type SubscriberPaymentMethodReference, type SubscriberPaymentMethodRepository, type SubscriberPaymentMethodSetupData, type SubscriberPaymentMethodSetupMatch, type SubscriberPaymentMethodStatus, type SubscriberRecord, type SubscriberRepository, type Subscription, type SubscriptionBundleRecord, type SubscriptionBundleRepository, type SubscriptionBundleView, type SubscriptionContractFilter, type SubscriptionContractInvoiceSnapshot, type SubscriptionContractParties, type SubscriptionContractPriceSnapshot, type SubscriptionContractRecord, type SubscriptionContractRepository, type SubscriptionContractStatus, type SubscriptionRecord, type SubscriptionRepository, type SubscriptionStatsPort, type SubscriptionStatsSnapshot, type SubscriptionStatus, type SubscriptionUsagePort, type SubscriptionUsageRecord, type SuperAdminProvisioningPort, type SyncDiscoveryResult, type TenantActionDef, type TenantColumnDef, type TenantDto, type TenantListFilter, type TenantPort, 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, type VerifyRegistrationOtpResult, type VersionChange, type VersionChangeDirection, type VersionEditability, type VersionEditableReason, type VersionedEntityBase, applyPromo, assertPersistenceCapabilities, buildActivePlanVersionWhere, buildActiveVersionWhere, buildFeatureRequiresIndex, bundleDraftDefaults, bundleStemDefaults, canonicalJson, classifyBundleVersionDiff, classifyIssuerChange, classifyPlanDiff, collectUnsatisfiedRequires, contractPartiesOf, coverageExcludingSelf, definedFields, diffSettings, formatCustomerNumber, formatErrorMessage, identityCorrectionDelta, isBundleRedundant, isForeignPaymentMethodReferenceError, isPaymentCallbackRejectedError, isPlatformUserExistsError, isVersionEditable, issuerIdentityOf, keepOneRecommended, missingRequiresFor, movedIdentityFields, pickActivePromo, planCatalogSettingsOf, previousUtcDay, promoStatus, promotionOnPrice, readQuotaRecord, readQuotaValue, recordedIssuerIdentity, refuseForeignPaymentMethodReference, resolveBundleAvailability, resolveErrorMessage, sameLegalIdentity, selectChargeableBundles, settingsSubtreeOf, startOfUtcDay, subscriberChargeColumns, subscriberFromRegistration, subscriberPaymentMethodColumns, toBundleStemRow, toContractLineItemRecord, toPlanRow, toPlanVersionRow, toRunningContractIssuer, toSubscriberChargeRecord, toSubscriberCorrectionRecord, toSubscriberPaymentMethodRecord, toSubscriberRecord, toSubscriptionBundleRecord, toSubscriptionContractRecord };