@riverbankcms/sdk 0.148.0 → 0.150.0

package/dist/_dts/commerce/src/purchase/oneTimeCheckoutPlanning.d.ts

@@ -1,10 +1,10 @@
-import { type NonEmptyArray, type Result } from '../../../core/src/index';
+import { type BookingInstalmentPlanConfig, type NonEmptyArray, type Result } from '../../../core/src/index';
 import { type CurrencyCode, type Money } from './settlement';
 import type { CartCheckout } from './types';
 import type { OrderPaymentMethod, OrderStatus } from './orderTypes';
 export type CheckoutPlanningError = {
     _tag: 'CheckoutPlanningError';
-    code: 'empty_cart';
+    code: 'empty_cart' | 'instalment_charge_mismatch';
     message: string;
 };
 type CheckoutPlanningSettledCart = Readonly<{
@@ -33,10 +33,13 @@ export type DeferredManualCheckoutPaymentPlan = CheckoutPaymentPlanBase & Readon
 }>;
 export type InstalmentCheckoutPaymentPlan = CheckoutPaymentPlanBase & Readonly<{
     kind: 'instalment_plan';
+    planDefinition: BookingInstalmentPlanConfig;
+    /** Charged now; has to be the plan's first instalment of the settled total. */
+    chargeNowCents: number;
 }>;
 export type FlexibleBalanceCheckoutPaymentPlan = CheckoutPaymentPlanBase & Readonly<{
     kind: 'flexible_balance';
-    initialPaymentCents: number;
+    chargeNowCents: number;
 }>;
 export type OneTimeCheckoutPlanningPaymentPlan = StripeCheckoutPaymentPlan | BypassCheckoutPaymentPlan | DeferredManualCheckoutPaymentPlan | InstalmentCheckoutPaymentPlan | FlexibleBalanceCheckoutPaymentPlan;
 type CheckoutPlanningContext = Readonly<Record<string, unknown>>;
@@ -56,9 +59,11 @@ export type OrderSettlementPlan<TItem, TDiscount, TDiscountApplication> = Readon
     discount: TDiscount;
     discountApplication: TDiscountApplication;
 }>;
+/** The ways a one-time checkout's order can be paid; passes, memberships and waivers never check out here. */
+export type OneTimeCheckoutOrderPaymentMethod = Extract<OrderPaymentMethod, 'free' | 'store_credit' | 'manual' | 'stripe' | 'mixed'>;
 export type OrderDraftPlan = Readonly<{
     status: OrderStatus;
-    paymentMethod: OrderPaymentMethod;
+    paymentMethod: OneTimeCheckoutOrderPaymentMethod;
     paidTotal: Money<CurrencyCode>;
 }>;
 export type OneTimeCheckoutPlan<TContext extends CheckoutPlanningContext, TSettledCart extends CheckoutPlanningSettledCart> = Readonly<{

package/dist/_dts/commerce/src/purchase/orderInstalmentClosure.d.ts

@@ -1,6 +1,6 @@
 import { type NonNegativeCents } from '../../../core/src/index';
 import type { OrderInstalmentPlanStatus, OrderInstalmentStatus } from './orderInstalmentPlan';
-type InstalmentClosureReason = 'cancelled' | 'refunded';
+export type InstalmentClosureReason = 'cancelled' | 'refunded';
 type InstalmentClosurePlanSnapshot = Readonly<{
     status: OrderInstalmentPlanStatus;
     remainingBalanceCents: NonNegativeCents;
@@ -15,12 +15,24 @@ type InstalmentStatusUpdate = Readonly<{
 }>;
 export type OrderInstalmentClosurePlan = Readonly<{
     kind: 'already_applied';
+}> | Readonly<{
+    kind: 'conflict';
 }> | Readonly<{
     kind: 'apply';
     nextPlanStatus: Extract<OrderInstalmentPlanStatus, 'cancelled' | 'refunded'>;
     nextRemainingBalanceCents: NonNegativeCents;
     instalmentUpdates: readonly InstalmentStatusUpdate[];
 }>;
+/**
+ * Whether closing the plan for this reason has nothing to do: it already has
+ * that status, or (for a cancel) it isn't live or has nothing left to
+ * collect. This only describes local accounting; it never proves that provider
+ * collection has stopped.
+ */
+export declare function isOrderInstalmentClosureAlreadyApplied(input: Readonly<{
+    paymentPlan: InstalmentClosurePlanSnapshot;
+    reason: InstalmentClosureReason;
+}>): boolean;
 export declare function planOrderInstalmentClosure(input: Readonly<{
     paymentPlan: InstalmentClosurePlanSnapshot;
     instalments: readonly InstalmentClosureRowSnapshot[];

package/dist/_dts/commerce/src/purchase/orderInstalmentLifecycle.d.ts

@@ -25,6 +25,10 @@ export type ApplyRecurringInstalmentPaymentPlan = Readonly<{
 export type ApplyRecurringInstalmentFailurePlan = Readonly<{
     kind: 'already_applied';
     instalmentId: string;
+}>
+/** The plan is finished or closed: a late failed invoice changes nothing. */
+ | Readonly<{
+    kind: 'plan_closed';
 }> | Readonly<{
     kind: 'apply_failure';
     instalmentId: string;
@@ -38,6 +42,7 @@ export declare function planRecurringInstalmentInvoicePaid(input: Readonly<{
     amountPaidCents: NonNegativeCents;
 }>): ApplyRecurringInstalmentPaymentPlan;
 export declare function planRecurringInstalmentInvoiceFailed(input: Readonly<{
+    planStatus: OrderInstalmentPlanStatus;
     instalments: readonly InstalmentLifecycleRowSnapshot[];
     stripeInvoiceId: string;
 }>): ApplyRecurringInstalmentFailurePlan;

package/dist/_dts/commerce/src/purchase/orderItemMetadata.d.ts

@@ -1,6 +1,6 @@
 import { type StripeBookingCommissionOrderItemMetadata } from './stripeCommissionMetadata';
 export { parseStripeBookingCommissionMetadata, type StripeBookingCommissionOrderItemMetadata } from './stripeCommissionMetadata';
-import { type BrandedIdParseError, type CheckoutLineId, type RetiredCourseId, type CustomerId, type DatedOfferingCapacityHoldAuditRef, type DatedOfferingCapacityHoldId, type EventSeriesId, type EventInstanceId, type OccurrenceId, type PassId, type PricingOptionId, type Result } from '../../../core/src/index';
+import { type BrandedIdParseError, type CheckoutLineId, type RetiredCourseId, type CustomerId, type DatedOfferingCapacityHoldAuditRef, type DatedOfferingCapacityHoldId, type EventSeriesId, type MembershipId, type EventInstanceId, type OccurrenceId, type PassId, type PricingOptionId, type Result } from '../../../core/src/index';
 import type { OrderItemKind } from './orderTypes';
 export type CheckoutLineMetadata = Readonly<{
     checkoutLineId?: CheckoutLineId;
@@ -150,6 +150,9 @@ export type MembershipBundleFulfillmentMetadata = Readonly<{
     membershipName: string;
 }>;
 export type MembershipOrderItemMetadata = CheckoutLineMetadata & StripeBookingCommissionOrderItemMetadata & Readonly<{
+    /** Written by checkout; identifies a standalone purchase. Older rows and renewals lack it. */
+    membershipId?: MembershipId;
+    billingInterval?: 'month' | 'year';
     bundleFulfillment?: MembershipBundleFulfillmentMetadata;
 }>;
 export type OrderItemMetadataByKind = {

package/dist/_dts/commerce/src/purchase/orderTypes.d.ts

@@ -1,6 +1,12 @@
 export declare const ORDER_STATUSES: readonly ["pending", "paid", "partially_refunded", "refunded", "failed", "cancelled"];
 export type OrderStatus = (typeof ORDER_STATUSES)[number];
 export declare function isOrderStatus(value: string): value is OrderStatus;
+/**
+ * Orders that ended without being paid: a failed checkout or a cancellation.
+ * Nothing is collected or chased against them.
+ */
+export declare const CLOSED_ORDER_STATUSES: readonly ["failed", "cancelled"];
+export declare function isClosedOrderStatus(status: string): status is (typeof CLOSED_ORDER_STATUSES)[number];
 export declare const ORDER_PAYMENT_METHODS: readonly ["stripe", "store_credit", "mixed", "pass_redemption", "membership_access", "free", "manual", "waived"];
 export type OrderPaymentMethod = (typeof ORDER_PAYMENT_METHODS)[number];
 export declare function isOrderPaymentMethod(value: string): value is OrderPaymentMethod;
@@ -20,7 +26,7 @@ export declare const RESERVATION_FINALIZATION_STATES: readonly ["not_applicable"
 export type ReservationFinalizationState = (typeof RESERVATION_FINALIZATION_STATES)[number];
 export declare function isReservationFinalizationState(value: string): value is ReservationFinalizationState;
 export type CheckoutPaymentRail = 'bypass' | 'stripe';
-export type CheckoutCommitFailureStep = 'credit_consumption' | 'membership_provision' | 'fulfillment' | 'discount_redemption' | 'payment_record';
+export type CheckoutCommitFailureStep = 'credit_consumption' | 'membership_provision' | 'fulfillment' | 'discount_redemption';
 export type CheckoutCompensationDecision = Readonly<{
     kind: 'release_reservations';
     reason: string;

package/dist/_dts/commerce/src/purchase/refundRailSplit.d.ts

@@ -34,7 +34,7 @@ export declare function computeRailAwareRefundSplit(originalCashCents: NonNegati
  *
  * Pure function — just array reduction.
  */
-export declare function summarizePriorRefundsByRail(refunds: ReadonlyArray<RefundWithAllocations>, orderItemId: string): Result<RefundRailSplit, Readonly<{
+export declare function summarizePriorRefundsByRail(refunds: ReadonlyArray<RefundWithAllocations>, orderItemIds: readonly string[]): Result<RefundRailSplit, Readonly<{
     kind: 'mixed_rail_attribution_missing';
 }>>;
 export {};

package/dist/_dts/commerce/src/purchase/stateTransitions.d.ts

@@ -1,13 +1,13 @@
 import { type Result } from '../../../core/src/index';
 import type { CheckoutCommitFailureStep, CheckoutCompensationDecision, CheckoutPaymentRail, DiscountRedemptionStatus, OrderStatus } from './orderTypes';
+import type { CheckoutCommitProgress } from './checkoutCommitPlan';
 export type OrderStatusEvent = 'checkout_failed' | 'stripe_payment_completed' | 'cancel' | 'partial_refund' | 'full_refund';
 export declare function advanceOrderStatus(from: OrderStatus, event: OrderStatusEvent): Result<OrderStatus, string>;
 export declare function transitionOrderStatusTo(from: OrderStatus, to: OrderStatus): Result<OrderStatus, string>;
 export declare function classifyCheckoutCompensationDecision(input: {
     paymentRail: CheckoutPaymentRail;
     failedStep: CheckoutCommitFailureStep;
-    reservationsConsumed: boolean;
-    fulfillmentCommitted: boolean;
+    progress: CheckoutCommitProgress;
 }): CheckoutCompensationDecision;
 export type DiscountRedemptionEvent = 'redeem' | 'release' | 'expire';
 export declare function advanceDiscountRedemptionStatus(from: DiscountRedemptionStatus, event: DiscountRedemptionEvent): Result<DiscountRedemptionStatus, string>;

package/dist/_dts/commerce/src/purchase/stripeCheckoutReturnUrl.d.ts

@@ -1,8 +1,15 @@
+import type { CheckoutPresentation } from './checkoutPresentation';
 export declare const STRIPE_CHECKOUT_SESSION_ID_PLACEHOLDER = "{CHECKOUT_SESSION_ID}";
 /**
- * Completes a Stripe success URL with the session correlation parameter.
+ * Completes a Stripe return URL with the session correlation parameter.
  *
  * URL owns the query/fragment boundary so the parameter can never be appended
  * inside a hash fragment. Stripe requires its placeholder to remain literal.
  */
-export declare function ensureStripeCheckoutSessionIdInSuccessUrl(successUrl: string): string;
+export declare function ensureStripeCheckoutSessionIdInReturnUrl(returnUrl: string): string;
+/**
+ * The page Stripe returns a completed session to: the checkout's own success
+ * (hosted) or return (embedded) URL, with the session filled in where Stripe
+ * would have put it.
+ */
+export declare function completedStripeCheckoutReturnUrl(presentation: CheckoutPresentation, sessionId: string): string;

package/dist/_dts/commerce/src/purchase/stripeMinimumCharge.d.ts

@@ -8,3 +8,9 @@ export declare function isStripeChargeBelowMinimum(options: Readonly<{
     amountCents: number;
     currency: string;
 }>): boolean;
+/**
+ * The smallest deposit a plan that starts with one may ask for: the card
+ * minimum for the currency, or any positive amount for a currency Stripe has
+ * no minimum on record for.
+ */
+export declare function getInstalmentDepositMinimumCents(currency: string): number;

package/dist/_dts/commerce/src/purchase/types.d.ts

@@ -1,3 +1,4 @@
+import type { CheckoutMode, CheckoutPresentation } from './checkoutPresentation';
 /**
  * Purchase domain types — the unified model for all customer acquisitions.
  *
@@ -5,6 +6,7 @@
  * course, membership), it's a Purchase. Payment method is an attribute
  * of the purchase, not a separate concept (Model B: unified).
  */
+import type { BookingPaymentCollectionOptionKind } from '../../../core/src/index';
 import type { OccurrenceId, PricingOptionId, ProductId, ProductVariantId, PassId, MembershipId, CustomerId, OrderId, AttendeeId, CustomerPassId, CustomerMembershipId, EventSeriesRegistrationId, AppointmentId, NonEmptyArray, SiteId, EventSeriesId } from '../../../core/src/index';
 import type { PositiveCheckoutQuantity } from './checkoutQuantity';
 export type CheckoutItem = EventTicketItem | ProductItem | PassItem | EventSeriesRegistrationItem | AppointmentItem;
@@ -61,24 +63,22 @@ export type AttendeeInfo = Readonly<{
 }>;
 export type AttendeeBearingCheckoutItem = EventTicketItem | EventSeriesRegistrationItem;
 export type Checkout = CartCheckout | MembershipCheckout;
-export type CartCheckout = {
+export type CartCheckout<M extends CheckoutMode = CheckoutMode> = {
     mode: 'one_time';
     siteId: SiteId;
     items: NonEmptyArray<CheckoutItem>;
     customer: CustomerInfo;
     discountCode?: string;
-    collectionOptionKind?: 'upfront' | 'deferred_manual' | 'instalment_plan' | 'flexible_balance';
-    successUrl: string;
-    cancelUrl: string;
+    collectionOptionKind?: BookingPaymentCollectionOptionKind;
+    presentation: CheckoutPresentation<M>;
 };
-export type MembershipCheckout = {
+export type MembershipCheckout<M extends CheckoutMode = CheckoutMode> = {
     mode: 'subscription';
     siteId: SiteId;
     membership: MembershipItem;
     customer: CustomerInfo;
     discountCode?: string;
-    successUrl: string;
-    cancelUrl: string;
+    presentation: CheckoutPresentation<M>;
 };
 export type CustomerInfo = {
     email: string;

package/dist/_dts/content-editor/src/FooterComposerOverview.d.ts

@@ -1,5 +1,5 @@
 import { type FooterCompositionV1, type FooterNavigationLayout } from '../../core/src/index';
-import type { FooterRuntimeViewModel } from '../../blocks/src/client/site-chrome';
+import type { FooterAttribution, FooterRuntimeViewModel } from '../../blocks/src/client/site-chrome';
 import { type FooterEditorTarget, type planFooterEditorView } from './footerComposer';
 import type { SaveState } from './useFooterComposerState';
 type FooterPlan = ReturnType<typeof planFooterEditorView>;
@@ -9,7 +9,8 @@ export declare function SaveBadge({ state }: {
 export declare function FooterPreview({ runtime, }: {
     runtime: FooterRuntimeViewModel;
 }): import("react").JSX.Element;
-export declare function FooterOverview({ plan, composition, onTarget, onChange, manageLinksHref, manageSettingsHref, navigationLayout, onEngagement, onNavigationLayoutChange, }: {
+export declare function FooterOverview({ attribution, plan, composition, onTarget, onChange, manageLinksHref, manageSettingsHref, navigationLayout, onEngagement, onNavigationLayoutChange, }: {
+    attribution: FooterAttribution | null;
     plan: FooterPlan;
     composition: FooterCompositionV1;
     onTarget: (target: FooterEditorTarget) => void;

package/dist/_dts/content-editor/src/controller/editLeaseHandover.d.ts

@@ -0,0 +1,30 @@
+import { type EditorClientId } from '../../../core/src/index';
+/** After the lease TTL, the departed document's lease has expired anyway. */
+export declare const EDIT_LEASE_HANDOVER_TTL_MS: number;
+export type EditLeaseHandover = Readonly<{
+    clientId: EditorClientId;
+    savedAt: number;
+}>;
+export declare function parseEditLeaseHandover(raw: string | null): EditLeaseHandover | null;
+/** Checked when each acquire is sent, not only when the entry is read. */
+export declare function freshHandover(handover: EditLeaseHandover | null, now: number): EditLeaseHandover | null;
+export type EditLeaseHandoverPort = Readonly<{
+    storage: () => Storage | null;
+    clientId: () => string;
+    now: () => number;
+    onPageTransition: (type: 'pagehide' | 'pageshow', listener: (event: PageTransitionEvent) => void) => void;
+}>;
+export type DocumentEditLeaseHandover = Readonly<{
+    /** Called by each lease session; only documents that edited hand over. */
+    markParticipant: () => void;
+    previousClientIdForAcquire: () => EditorClientId | null;
+}>;
+/**
+ * One handover per document: it's taken once so lease sessions in the document can't
+ * race for it, and it's written from a document listener so it survives the editor
+ * unmounting before the page is left. A document that never edited passes on the
+ * handover it took, unchanged, so editor → other page → editor still hands over.
+ */
+export declare function createDocumentEditLeaseHandover(port: EditLeaseHandoverPort): DocumentEditLeaseHandover;
+export declare function markEditLeaseParticipant(): void;
+export declare function previousEditorClientIdForAcquire(): EditorClientId | null;

package/dist/_dts/content-editor/src/footerPreviewRuntime.d.ts

@@ -1,4 +1,4 @@
-import { type FooterResolvedEngagement, type FooterRuntimeViewModel } from '../../blocks/src/client/site-chrome';
+import { type FooterAttribution, type FooterResolvedEngagement, type FooterRuntimeViewModel } from '../../blocks/src/client/site-chrome';
 import type { FooterCompositionV1, FooterNavigationLayout, PublicProfile } from '../../core/src/index';
 export type FooterPreviewRuntimeInput = Readonly<{
     composition: FooterCompositionV1;
@@ -10,5 +10,10 @@ export type FooterPreviewRuntimeInput = Readonly<{
     legalRegion: 'integrated' | 'separate';
     navigationLayout: FooterNavigationLayout;
     engagement: FooterResolvedEngagement;
+    /**
+     * The plan's attribution line, from the composition read. The preview adds
+     * it the same way the served footer does, so the two match.
+     */
+    attribution: FooterAttribution | null;
 }>;
 export declare function buildFooterPreviewRuntime(input: FooterPreviewRuntimeInput): FooterRuntimeViewModel;

package/dist/_dts/content-editor/src/lib/browserStorage.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The browser's storage, or null during server rendering or when the browser blocks
+ * access (privacy settings, sandboxed frames).
+ */
+export declare function browserStorage(kind: 'local' | 'session'): Storage | null;

package/dist/_dts/content-editor/src/useFooterComposerState.d.ts

@@ -29,6 +29,13 @@ export declare function useFooterComposerState({ apiClient, canEdit, initialTarg
     siteId: import("../../core/src/index").SiteId;
     target: FooterEditorTarget;
     setTarget: import("react").Dispatch<import("react").SetStateAction<FooterEditorTarget>>;
+    attribution: Readonly<{
+        lead: string;
+        link: Readonly<{
+            href: string;
+            label: string;
+        }>;
+    }> | null;
     compositionSnapshot: FooterCompositionSnapshot | null;
     engagementOptions: Readonly<{
         forms: readonly import("../../api/src/footerSettings").FooterFormSummary[];

package/dist/_dts/core/src/booking-flexible-balance.d.ts

@@ -11,7 +11,7 @@ export type BookingFlexibleBalanceConfig = Readonly<{
     dueDateRule: BookingFlexibleBalanceDueDateRule;
     depositRefundability: BookingDepositRefundPolicy;
 }>;
-export type BookingFlexibleBalanceContractStatus = 'active' | 'payment_pending' | 'overdue' | 'completed' | 'waived' | 'cancelled_due_to_non_payment' | 'refunded';
+export type BookingFlexibleBalanceContractStatus = 'active' | 'payment_pending' | 'overdue' | 'completed' | 'waived' | 'cancelled_due_to_non_payment' | 'refunded' | 'closed_order_failed';
 export type BookingFlexibleBalanceReminderKind = 'due_7_days' | 'due_1_day' | 'overdue_1_day';
 export declare const DEFAULT_FLEXIBLE_BALANCE_STRIPE_MINIMUM_CHARGE_CENTS = 50;
 export type BookingFlexibleBalanceReminderState = Readonly<{
@@ -30,7 +30,7 @@ export type FlexibleBalancePaymentEligibility = Readonly<{
     reason: 'overdue' | 'dust_balance';
 }> | Readonly<{
     kind: 'unavailable';
-    reason: 'already_settled' | 'payment_pending' | 'cancelled_due_to_non_payment' | 'refunded' | 'waived';
+    reason: 'already_settled' | 'payment_pending' | 'cancelled_due_to_non_payment' | 'refunded' | 'waived' | 'order_failed';
 }>;
 export declare function resolveFlexibleBalanceInitialPaymentCents(input: Readonly<{
     totalAmountCents: number;

package/dist/_dts/core/src/booking-instalment-deposit.d.ts

@@ -0,0 +1,20 @@
+import { type Result } from './result';
+import { type BookingInstalmentPlanConfig } from './booking-instalments';
+import type { BookingPaymentCollectionOption } from './booking-payment-options';
+/** A plan that starts with a deposit whose deposit is below the card minimum. */
+export type InstalmentDepositBelowMinimum = Readonly<{
+    kind: 'instalment_deposit_below_minimum';
+    minimumCents: number;
+}>;
+/**
+ * A plan that starts with a deposit takes it by card when the customer books
+ * and saves the card for the later payments, so the deposit must be at least
+ * the card minimum for the site's currency. Plans without a deposit step
+ * (equal instalments) charge their first instalment instead and are not
+ * checked here.
+ */
+export declare function checkInstalmentPlanDeposit(plan: BookingInstalmentPlanConfig, minimumCents: number): Result<void, InstalmentDepositBelowMinimum>;
+/** The deposit check for whichever instalment option a set of payment options offers. */
+export declare function checkPaymentOptionsInstalmentDeposit(allowedOptions: readonly BookingPaymentCollectionOption[], minimumCents: number): Result<void, InstalmentDepositBelowMinimum>;
+/** The one message for a deposit below the minimum, shown in the editor and returned by the server. */
+export declare function describeInstalmentDepositBelowMinimum(failure: InstalmentDepositBelowMinimum, currency: string): string;

package/dist/_dts/core/src/booking-live-payment-terms.d.ts

@@ -0,0 +1,72 @@
+import type { BookingFlexibleBalanceContractStatus } from './booking-flexible-balance';
+import type { OrderInstalmentPlanStatus } from './booking-instalments';
+/**
+ * Whether an order still has payment terms being collected: an instalment plan
+ * or a flexible-balance contract that hasn't been settled, closed or cancelled.
+ *
+ * Both tables are total over their status unions, so a new status is a compile
+ * error here until someone decides whether it counts as live.
+ */
+declare const LIVE_PLAN_STATUSES: {
+    readonly pending_initial_payment: true;
+    readonly active: true;
+    readonly payment_failed: true;
+    readonly reconciliation_required: true;
+    readonly completed: false;
+    readonly cancelled: false;
+    readonly cancelled_as_paid_early: false;
+    readonly refunded: false;
+};
+declare const LIVE_CONTRACT_STATUSES: {
+    readonly active: true;
+    readonly payment_pending: true;
+    readonly overdue: true;
+    readonly completed: false;
+    readonly waived: false;
+    readonly refunded: false;
+    readonly cancelled_due_to_non_payment: false;
+    readonly closed_order_failed: false;
+};
+type LiveKeys<TTable extends Record<string, boolean>> = {
+    [K in keyof TTable]: TTable[K] extends true ? K : never;
+}[keyof TTable];
+/** The plan statuses in which instalments are still being collected. */
+export type LiveOrderInstalmentPlanStatus = LiveKeys<typeof LIVE_PLAN_STATUSES>;
+export declare function isLiveOrderInstalmentPlanStatus(status: OrderInstalmentPlanStatus): status is LiveOrderInstalmentPlanStatus;
+/** The contract statuses in which a balance is still being collected. */
+export type LiveFlexibleBalanceContractStatus = LiveKeys<typeof LIVE_CONTRACT_STATUSES>;
+export declare function isLiveFlexibleBalanceContractStatus(status: BookingFlexibleBalanceContractStatus): status is LiveFlexibleBalanceContractStatus;
+export type LivePaymentTermsInput = Readonly<{
+    plan: Readonly<{
+        status: OrderInstalmentPlanStatus;
+    }> | null;
+    contract: Readonly<{
+        status: BookingFlexibleBalanceContractStatus;
+    }> | null;
+}>;
+export declare function hasLivePaymentTerms(input: LivePaymentTermsInput): boolean;
+/** Partial refunds must also protect a cancelled contract that staff can reopen. */
+export declare function paymentTermsBlockPartialRefund(input: LivePaymentTermsInput): boolean;
+/**
+ * Whether an instalment plan's remaining balance can take a payment now, by
+ * hand or online: it's live and no collection is in flight.
+ */
+export declare function isSettleableOrderInstalmentPlanStatus(status: OrderInstalmentPlanStatus): boolean;
+/**
+ * Whether a flexible-balance contract's remaining balance can take a payment
+ * now, by hand or online: it's live and no collection is in flight.
+ */
+export declare function isSettleableFlexibleBalanceContractStatus(status: BookingFlexibleBalanceContractStatus): boolean;
+/**
+ * What happens to a flexible-balance contract when its order fails or is
+ * retired before it completes. Only a live contract is closed; one that was
+ * already settled, waived, refunded, cancelled or closed keeps its status.
+ */
+export type FailedOrderContractClosure = Readonly<{
+    kind: 'close';
+    from: LiveFlexibleBalanceContractStatus;
+}> | Readonly<{
+    kind: 'keep';
+}>;
+export declare function decideContractClosureForFailedOrder(status: BookingFlexibleBalanceContractStatus): FailedOrderContractClosure;
+export {};

package/dist/_dts/core/src/booking-payment-options.d.ts

@@ -0,0 +1,24 @@
+import type { BookingFlexibleBalanceConfig } from './booking-flexible-balance';
+import type { BookingInstalmentPlanConfig } from './booking-instalments';
+import { type Result } from './result';
+/**
+ * One way a customer may pay for a booking. This is the single definition of
+ * the option type; `booking-payment-schemas.typetest.ts` keeps it equal to the
+ * schema's output in both directions.
+ */
+export type BookingPaymentCollectionOption = Readonly<{
+    kind: 'upfront';
+}> | Readonly<{
+    kind: 'deferred_manual';
+}> | Readonly<{
+    kind: 'instalment_plan';
+    plan: BookingInstalmentPlanConfig;
+}> | Readonly<{
+    kind: 'flexible_balance';
+    config: BookingFlexibleBalanceConfig;
+}>;
+/** The ways a customer may pay for a booking: the one kind set. */
+export type BookingPaymentCollectionOptionKind = BookingPaymentCollectionOption['kind'];
+export type BookingPaymentOptionKindsError = 'no_options' | 'duplicate_kind' | 'incompatible_collection_options';
+/** Automatic instalments and a flexible balance cannot share one booking offer. */
+export declare function validateBookingPaymentOptionKinds(kinds: readonly BookingPaymentCollectionOptionKind[]): Result<void, BookingPaymentOptionKindsError>;