@riverbankcms/sdk 0.130.2 → 0.134.0

package/dist/_dts/blocks/src/system/types/link.d.ts

@@ -3,11 +3,14 @@ export type InternalRouteOnlyLinkValue = {
     kind: 'internal';
     routeId: string;
 };
+export declare const RESOLVED_INTERNAL_LINK_ENTITY_TYPES: readonly ["page", "content", "pageSurface"];
+export type ResolvedInternalLinkEntityType = (typeof RESOLVED_INTERNAL_LINK_ENTITY_TYPES)[number];
+export declare function isResolvedInternalLinkEntityType(value: unknown): value is ResolvedInternalLinkEntityType;
 export type InternalResolvedLinkValue = {
     kind: 'internal';
     routeId: string;
     entityId: string;
-    entityType: 'page' | 'content';
+    entityType: ResolvedInternalLinkEntityType;
     href: string;
     title: string;
     typeLabel: string;
@@ -70,6 +73,7 @@ export declare const internalResolvedLinkSchema: z.ZodObject<{
     entityType: z.ZodEnum<{
         content: "content";
         page: "page";
+        pageSurface: "pageSurface";
     }>;
     href: z.ZodString;
     title: z.ZodString;
@@ -85,6 +89,7 @@ export declare const internalLinkSchema: z.ZodUnion<readonly [z.ZodObject<{
     entityType: z.ZodEnum<{
         content: "content";
         page: "page";
+        pageSurface: "pageSurface";
     }>;
     href: z.ZodString;
     title: z.ZodString;
@@ -120,6 +125,7 @@ export declare const linkSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.Zod
     entityType: z.ZodEnum<{
         content: "content";
         page: "page";
+        pageSurface: "pageSurface";
     }>;
     href: z.ZodString;
     title: z.ZodString;

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

@@ -0,0 +1,13 @@
+import { type BookingInstalmentPlanConfig } from '../../../core/src/index';
+export type BookingInstalmentScheduleRow = Readonly<{
+    id: string;
+    sequence: number;
+    stateAtBooking: 'paid_today' | 'scheduled';
+    dueAt: string;
+    amountCents: number;
+}>;
+export declare function buildBookingInstalmentSchedule(input: Readonly<{
+    anchorAt: string;
+    totalAmountCents: number;
+    plan: BookingInstalmentPlanConfig;
+}>): readonly BookingInstalmentScheduleRow[];

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

@@ -0,0 +1,7 @@
+import type { OrderStatus } from './orderTypes';
+/**
+ * Whether an order in the given status can be cancelled.
+ *
+ * `cancelled` orders cannot be cancelled again.
+ */
+export declare function isCancellableStatus(status: OrderStatus): boolean;

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

@@ -0,0 +1,48 @@
+import type { NonNegativeCents } from '../../../core/src/index';
+import type { OrderRefundMode } from './orderRefundPolicy';
+export type CanonicalRefundMethod = 'cash' | 'credit';
+export type OrderRefundRail = 'cash' | 'credit' | 'mixed';
+export type CanonicalRefundPlannerErrorCode = 'already_refunded' | 'idempotency_amount_mismatch' | 'idempotency_method_mismatch' | 'refund_in_progress' | 'invalid_amount' | 'amount_exceeds_remaining' | 'pass_revoke_requires_full_refund' | 'refund_failed';
+export type CanonicalRefundSnapshot = Readonly<{
+    id: string;
+    status: 'pending' | 'succeeded' | 'failed' | 'reconciliation_needed';
+    amountCents: NonNegativeCents;
+    refundRail: OrderRefundRail;
+    refundMode: OrderRefundMode;
+    failureCode: string | null;
+    failureMessage: string | null;
+    isStale: boolean;
+}>;
+export type CanonicalRefundPlannerInput = Readonly<{
+    refundMethod: CanonicalRefundMethod;
+    refundMode: OrderRefundMode;
+    requestedAmountCents: NonNegativeCents | undefined;
+    remainingRefundableCents: NonNegativeCents;
+    refundedSoFarCents: NonNegativeCents;
+    requireFullRemainingRefund: boolean;
+    acceptableExistingRails: readonly OrderRefundRail[];
+    existingByIdempotency: CanonicalRefundSnapshot | null;
+    latestPending: CanonicalRefundSnapshot | null;
+}>;
+export type CanonicalRefundPlannerDecision = Readonly<{
+    kind: 'existing_succeeded';
+    refund: CanonicalRefundSnapshot;
+    totalRefundedCents: NonNegativeCents;
+    remainingRefundableCents: NonNegativeCents;
+}> | Readonly<{
+    kind: 'resume_pending';
+    refund: CanonicalRefundSnapshot;
+    requestedAmountCents: NonNegativeCents;
+}> | Readonly<{
+    kind: 'create_pending';
+    requestedAmountCents: NonNegativeCents;
+}> | Readonly<{
+    kind: 'failed';
+    errorCode: CanonicalRefundPlannerErrorCode;
+    errorMessage: string;
+    refund: CanonicalRefundSnapshot | null;
+    amountCents: NonNegativeCents | null;
+    totalRefundedCents: NonNegativeCents;
+    remainingRefundableCents: NonNegativeCents;
+}>;
+export declare function planCanonicalRefundRequest(input: CanonicalRefundPlannerInput): CanonicalRefundPlannerDecision;

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

@@ -0,0 +1,39 @@
+import { type NonEmptyArray, type Result } from '../../../core/src/index';
+export type CheckoutCollectionPlanningError = Readonly<{
+    _tag: 'CheckoutCollectionPlanningError';
+    code: 'shop_shipping_not_configured';
+    message: string;
+}>;
+export type CheckoutCollectionPlan<TCountryCode extends string = string> = Readonly<{
+    kind: 'digital_only';
+    automaticTaxEnabled: boolean;
+    billingAddressCollection: 'auto';
+}> | Readonly<{
+    kind: 'requires_shipping';
+    automaticTaxEnabled: boolean;
+    billingAddressCollection: 'auto';
+    allowedShippingCountries: NonEmptyArray<TCountryCode>;
+}>;
+export type CheckoutCollectionItemKind = 'event_ticket' | 'product' | 'pass' | 'course_enrollment' | 'appointment';
+export type CheckoutCollectionProductItem = Readonly<{
+    validated: Readonly<{
+        type: 'product';
+        product: Readonly<{
+            requiresShipping: boolean;
+        }>;
+    }>;
+}>;
+export type CheckoutCollectionNonProductItem = Readonly<{
+    validated: Readonly<{
+        type: Exclude<CheckoutCollectionItemKind, 'product'>;
+    }>;
+}>;
+export type CheckoutCollectionItem = CheckoutCollectionProductItem | CheckoutCollectionNonProductItem;
+export type CheckoutCollectionCart<TItem extends CheckoutCollectionItem = CheckoutCollectionItem> = Readonly<{
+    items: readonly TItem[];
+}>;
+export declare function buildCheckoutCollectionPlan<TCountryCode extends string, TItem extends CheckoutCollectionItem>(options: Readonly<{
+    settledCart: CheckoutCollectionCart<TItem>;
+    automaticTaxEnabled: boolean;
+    allowedShippingCountries: readonly TCountryCode[];
+}>): Result<CheckoutCollectionPlan<TCountryCode>, CheckoutCollectionPlanningError>;

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

@@ -0,0 +1,40 @@
+import type { CheckoutCommitState, CheckoutPaymentRail, OrderCheckoutReconciliationState, OrderItemReconciliationState, OrderItemCommitState, OrderStatus, ReservationFinalizationState } from './orderTypes';
+import type { OrderItemPlanningRecord } from './orderPlanningTypes';
+export type CheckoutCommitOrderRecord = Readonly<{
+    status: OrderStatus;
+    commitState: CheckoutCommitState;
+    reconciliationState: OrderCheckoutReconciliationState;
+}>;
+export type CheckoutCommitOrderItemRecord = Readonly<Pick<OrderItemPlanningRecord, 'kind' | 'commitState' | 'reconciliationState' | 'fulfilledAt' | 'cancelledAt' | 'customerMembershipId'>>;
+export type CheckoutCommitPlanStepKind = 'consume_credit_reservation' | 'provision_memberships' | 'fulfill_order_items' | 'redeem_discount' | 'record_order_payment';
+export type NormalizedOrderCommitItem<TItem extends CheckoutCommitOrderItemRecord = CheckoutCommitOrderItemRecord> = Readonly<{
+    item: TItem;
+    commitState: OrderItemCommitState;
+    reconciliationState: OrderItemReconciliationState;
+}>;
+export type NormalizedOrderCommitSnapshot<TOrder extends CheckoutCommitOrderRecord = CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord = CheckoutCommitOrderItemRecord> = Readonly<{
+    order: TOrder;
+    commitState: CheckoutCommitState;
+    reconciliationState: OrderCheckoutReconciliationState;
+    items: readonly NormalizedOrderCommitItem<TItem>[];
+}>;
+export type CheckoutCommitPlanStep = Readonly<{
+    kind: CheckoutCommitPlanStepKind;
+}>;
+export type CheckoutCommitPlan<TOrder extends CheckoutCommitOrderRecord = CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord = CheckoutCommitOrderItemRecord> = Readonly<{
+    paymentRail: CheckoutPaymentRail;
+    normalized: NormalizedOrderCommitSnapshot<TOrder, TItem>;
+    steps: readonly CheckoutCommitPlanStep[];
+}>;
+export declare function normalizeOrderCommitSnapshot<TOrder extends CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord>(input: {
+    order: TOrder;
+    items: readonly TItem[];
+}): NormalizedOrderCommitSnapshot<TOrder, TItem>;
+export declare function buildCheckoutCommitPlan<TOrder extends CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord>(input: {
+    paymentRail: CheckoutPaymentRail;
+    order: TOrder;
+    items: readonly TItem[];
+    creditReservationState: ReservationFinalizationState;
+    hasDiscountRedemption: boolean;
+    paymentRecorded: boolean;
+}): CheckoutCommitPlan<TOrder, TItem>;

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

@@ -0,0 +1,80 @@
+import type { AppointmentServiceId, EventCategoryId, EventSeriesId, NonNegativeCents, PassId, ProductCategoryId, ProductId } from '../../../core/src/index';
+export type CheckoutDiscountContext = Readonly<{
+    type: 'event';
+    eventSeriesId: EventSeriesId;
+    eventCategoryId: EventCategoryId | null;
+    ticketsCount?: number;
+}> | Readonly<{
+    type: 'product';
+    productId: ProductId;
+    productCategoryId: ProductCategoryId | null;
+}> | Readonly<{
+    type: 'pass';
+    passId: PassId;
+}> | Readonly<{
+    type: 'whole_series';
+    eventSeriesId: EventSeriesId;
+    eventCategoryId: EventCategoryId | null;
+}> | Readonly<{
+    type: 'appointment';
+    serviceId: AppointmentServiceId;
+}>;
+export type CheckoutDiscountContextSource = Readonly<{
+    type: 'event_ticket';
+    ticketCount: number;
+    eventSeries: Readonly<{
+        id: EventSeriesId;
+        eventCategoryId: EventCategoryId | null;
+    }>;
+}> | Readonly<{
+    type: 'product';
+    productId: ProductId;
+    product: Readonly<{
+        productCategoryId: ProductCategoryId | null;
+    }>;
+}> | Readonly<{
+    type: 'pass';
+    passId: PassId;
+}> | Readonly<{
+    type: 'whole_series_enrollment';
+    eventSeries: Readonly<{
+        id: EventSeriesId;
+        eventCategoryId: EventCategoryId | null;
+    }>;
+}> | Readonly<{
+    type: 'appointment';
+    serviceId: AppointmentServiceId;
+}>;
+export type CheckoutDiscountContextLineInput<TLineId extends string> = Readonly<{
+    lineId: TLineId;
+    subtotalCents: number;
+    validated: CheckoutDiscountContextSource;
+}>;
+export type CheckoutDiscountContextEntry<TLineId extends string> = Readonly<{
+    identityKey: string;
+    context: CheckoutDiscountContext;
+    subtotalCents: number;
+    lineIds: readonly TLineId[];
+}>;
+export type CheckoutAutoDiscountCandidate<TCode, TLineId extends string> = Readonly<{
+    code: TCode;
+    applicableContexts: readonly CheckoutDiscountContextEntry<TLineId>[];
+}>;
+export type CheckoutAutoDiscountCandidateCode = Readonly<{
+    id: string;
+    discountType: 'fixed' | 'percent';
+    discountPercent?: number | null;
+    discountAmountCents?: number | null;
+}>;
+export declare function collectCheckoutDiscountContexts<TLineId extends string>(items: readonly CheckoutDiscountContextLineInput<TLineId>[]): readonly CheckoutDiscountContextEntry<TLineId>[];
+export declare function subtotalForCheckoutDiscountContexts<TLineId extends string>(applicableContexts: readonly CheckoutDiscountContextEntry<TLineId>[]): number;
+export declare function rankCheckoutAutoDiscountCandidates<TCode extends CheckoutAutoDiscountCandidateCode, TLineId extends string>(candidates: readonly CheckoutAutoDiscountCandidate<TCode, TLineId>[]): readonly (CheckoutAutoDiscountCandidate<TCode, TLineId> & Readonly<{
+    subtotalCents: number;
+    computedDiscountCents: NonNegativeCents;
+}>)[];
+export declare function computeCheckoutDiscountCents(options: Readonly<{
+    discountType: 'fixed' | 'percent';
+    discountPercent?: number | null;
+    discountAmountCents?: NonNegativeCents | null;
+    subtotalCents: NonNegativeCents;
+}>): NonNegativeCents;

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

@@ -0,0 +1 @@
+export type CheckoutErrorCode = "appointment_not_found" | "appointment_slot_unavailable" | "appointment_payment_terms_not_supported" | "booking_payment_terms_not_supported" | "checkout_amount_below_minimum" | "sliding_amount_required" | "sliding_amount_invalid" | "sliding_amount_below_min" | "sliding_amount_above_max" | "not_found" | "site_mismatch" | "registration_disabled" | "invalid_payment_method" | "payment_already_completed" | "invalid_payment_status" | "no_event_association" | "payment_not_required" | "customer_not_found" | "stripe_not_configured" | "stripe_commission_not_supported" | "stripe_tax_not_ready" | "stripe_tax_status_unavailable" | "course_pricing_option_not_available" | "product_not_available" | "product_not_eligible" | "insufficient_credits" | "invalid_discount_code" | "unsupported_discount_scope" | "checkout_in_progress" | "stripe_error" | "internal_error";

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

@@ -0,0 +1,22 @@
+import type { NonNegativeCents } from '../../../core/src/index';
+import type { PositiveCheckoutQuantity } from './checkoutQuantity';
+import type { LineSettlementBreakdown } from './settlement';
+export type CheckoutOrderItemMoneyInput<TLineId extends string> = Readonly<{
+    lineId: TLineId;
+    itemIndex: number;
+    unitPriceCents: NonNegativeCents;
+    quantity: PositiveCheckoutQuantity;
+    settlement: LineSettlementBreakdown;
+}>;
+export type CheckoutOrderItemMoneyProjection<TLineId extends string> = Readonly<{
+    lineKey: TLineId;
+    unitPriceCents: number;
+    quantity: number;
+    subtotalCents: number;
+    discountCents: number;
+    creditCents: number;
+    netTotalCents: number;
+    totalCents: number;
+    refundedCents: 0;
+}>;
+export declare function projectCheckoutOrderItemMoney<TLineId extends string>(input: CheckoutOrderItemMoneyInput<TLineId>): CheckoutOrderItemMoneyProjection<TLineId>;

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

@@ -0,0 +1,50 @@
+import { type NonNegativeCents } from '../../../core/src/index';
+export type CheckoutPaymentFlowPlan = Readonly<{
+    kind: 'bypass';
+    bypassReason: 'free' | 'discount_free';
+    reserveCreditCents: 0;
+}> | Readonly<{
+    kind: 'store_credit_only';
+    reserveCreditCents: NonNegativeCents;
+}> | Readonly<{
+    kind: 'stripe';
+    reserveCreditCents: NonNegativeCents;
+}>;
+export type FlexibleBalanceCreditFirstPlan = Readonly<{
+    kind: 'credit_only';
+    reserveCreditCents: NonNegativeCents;
+    cardDueNowCents: NonNegativeCents;
+    laterBalanceCents: NonNegativeCents;
+}> | Readonly<{
+    kind: 'flexible_balance';
+    reserveCreditCents: NonNegativeCents;
+    cardDueNowCents: NonNegativeCents;
+    laterBalanceCents: NonNegativeCents;
+}> | Readonly<{
+    kind: 'card_below_minimum';
+    reserveCreditCents: NonNegativeCents;
+    cardDueNowCents: NonNegativeCents;
+    laterBalanceCents: NonNegativeCents;
+}>;
+export declare function planCheckoutPaymentFlow(options: Readonly<{
+    amountDueCents: number;
+    discountCents: number;
+    availableCreditCents: number;
+    creditCurrencyMatches: boolean;
+    minimumStripeChargeCents?: number | null;
+}>): CheckoutPaymentFlowPlan;
+/**
+ * Apply site credit to a flexible-balance booking before card payment.
+ *
+ * Credit first reduces the configured payment due now. Once that payment is
+ * covered, any remaining credit reduces the later balance. If a partial credit
+ * application would leave a positive card charge below Stripe's minimum, less
+ * credit is used so the configured payment can still be collected.
+ */
+export declare function planFlexibleBalanceCreditFirst(input: Readonly<{
+    totalAfterDiscountCents: number;
+    configuredPaymentDueNowCents: number;
+    availableCreditCents: number;
+    creditCurrencyMatches: boolean;
+    minimumStripeChargeCents?: number | null;
+}>): FlexibleBalanceCreditFirstPlan;

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

@@ -0,0 +1,30 @@
+import { type BookingFlexibleBalanceConfig } from '../../../core/src/index';
+export type CheckoutStripeRequiredPaymentObligation<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+    kind: 'stripe';
+}> | Readonly<{
+    kind: 'instalment_plan';
+    planDefinition: TInstalmentPlan;
+}> | Readonly<{
+    kind: 'flexible_balance';
+    config: TFlexibleBalanceConfig;
+    initialPaymentCents: number;
+    bookingStartAt: string;
+    dueAt: string;
+}>;
+export type CheckoutStripeRequiredPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+    kind: 'standard';
+}> | Readonly<{
+    kind: 'instalment_plan';
+    planDefinition: TInstalmentPlan;
+}> | Readonly<{
+    kind: 'flexible_balance';
+    selection: Readonly<{
+        config: TFlexibleBalanceConfig;
+        bookingStartAt: string;
+        dueAt: string;
+    }>;
+}>;
+export declare function planStripeRequiredCheckoutPaymentObligation<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig>(input: Readonly<{
+    totalAfterDiscountCents: number;
+    paymentTerms?: CheckoutStripeRequiredPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig>;
+}>): CheckoutStripeRequiredPaymentObligation<TInstalmentPlan, TFlexibleBalanceConfig>;

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

@@ -0,0 +1,10 @@
+import type { BookingFlexibleBalanceConfig } from '../../../core/src/index';
+import type { CheckoutPaymentTermLine, CheckoutPaymentTerms } from './checkoutPaymentTerms';
+import type { CheckoutStripeRequiredPaymentTerms } from './checkoutPaymentPlanPlanning';
+export type AttendeeBookingCheckoutPaymentSelectionSnapshot<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+    bookingStartAt?: string | null;
+    selectedCollectionOptionKind?: 'upfront' | 'deferred_manual' | 'instalment_plan' | 'flexible_balance' | null;
+    selectedFlexibleBalanceConfig?: TFlexibleBalanceConfig | null;
+}>;
+export declare function attendeeBookingPaymentSelectionToCheckoutPaymentTermLine<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig>(selection: AttendeeBookingCheckoutPaymentSelectionSnapshot<TFlexibleBalanceConfig>): CheckoutPaymentTermLine<never, TFlexibleBalanceConfig>;
+export declare function checkoutPaymentTermsToStripeRequiredPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig>(paymentTerms: CheckoutPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig>): CheckoutStripeRequiredPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig>;

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

@@ -0,0 +1,53 @@
+import { type BookingFlexibleBalanceConfig } from '../../../core/src/index';
+import { type Result } from '../../../core/src/index';
+export type CheckoutPaymentTermCollectionOptionKind = 'upfront' | 'deferred_manual' | 'instalment_plan' | 'flexible_balance';
+export type CheckoutPaymentTermsError = Readonly<{
+    _tag: 'instalment_plan_not_supported';
+}> | Readonly<{
+    _tag: 'flexible_balance_empty_cart';
+}> | Readonly<{
+    _tag: 'flexible_balance_requires_single_item';
+}> | Readonly<{
+    _tag: 'flexible_balance_not_supported';
+}>;
+export type CheckoutAppointmentPaymentTermSelection<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig> = Readonly<{
+    kind: 'upfront' | 'deferred_manual';
+}> | Readonly<{
+    kind: 'instalment_plan';
+    plan: TInstalmentPlan;
+}> | Readonly<{
+    kind: 'flexible_balance';
+    config: TFlexibleBalanceConfig;
+}> | null;
+export type CheckoutAttendeeBookingPaymentTermSelection<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig> = Readonly<{
+    kind: 'upfront' | 'deferred_manual';
+}> | Readonly<{
+    kind: 'flexible_balance';
+    config: TFlexibleBalanceConfig;
+}> | null;
+export type CheckoutPaymentTermLine<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig> = Readonly<{
+    kind: 'appointment';
+    bookingStartAt: string;
+    selectedCollectionOption: CheckoutAppointmentPaymentTermSelection<TInstalmentPlan, TFlexibleBalanceConfig>;
+}> | Readonly<{
+    kind: 'attendee_booking';
+    bookingStartAt?: string | null;
+    selectedCollectionOption: CheckoutAttendeeBookingPaymentTermSelection<TFlexibleBalanceConfig>;
+}> | Readonly<{
+    kind: 'other';
+}>;
+export type CheckoutFlexibleBalanceSelection<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig> = Readonly<{
+    config: TFlexibleBalanceConfig;
+    bookingStartAt: string;
+    dueAt: string;
+}>;
+export type CheckoutPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig> = Readonly<{
+    instalmentPlanDefinition: TInstalmentPlan | null;
+    flexibleBalanceSelection: CheckoutFlexibleBalanceSelection<TFlexibleBalanceConfig> | null;
+}>;
+type CheckoutPaymentTermsInput<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+    requestedCollectionOptionKind?: CheckoutPaymentTermCollectionOptionKind;
+    items: readonly CheckoutPaymentTermLine<TInstalmentPlan, TFlexibleBalanceConfig>[];
+}>;
+export declare function resolveCheckoutPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig>(input: CheckoutPaymentTermsInput<TInstalmentPlan, TFlexibleBalanceConfig>): Result<CheckoutPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig>, CheckoutPaymentTermsError>;
+export {};

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

@@ -0,0 +1,8 @@
+import { type Brand, type Result } from '../../../core/src/index';
+export type PositiveCheckoutQuantity = Brand<number, 'PositiveCheckoutQuantity'>;
+export type PositiveCheckoutQuantityParseError = Readonly<{
+    kind: 'not_positive_whole_quantity';
+    quantity: number;
+}>;
+export declare function parsePositiveCheckoutQuantity(quantity: number): Result<PositiveCheckoutQuantity, PositiveCheckoutQuantityParseError>;
+export declare function unsafeAsPositiveCheckoutQuantity(quantity: number): PositiveCheckoutQuantity;

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

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+export declare const DatedOfferingSharedEngineMetadataSchema: z.ZodObject<{
+    datedOfferingEngineContractVersion: z.ZodLiteral<"shared_v1">;
+    datedOfferingEngineRouteKind: z.ZodLiteral<"shared_whole_series_registration">;
+    datedOfferingCapacityHoldId: z.ZodString;
+    datedOfferingCapacityHoldAuditRef: z.ZodString;
+    customerId: z.ZodString;
+    eventSeriesId: z.ZodString;
+}, z.core.$strip>;
+export declare const OrderCheckoutSessionMetadataSchema: z.ZodUnion<readonly [z.ZodObject<{
+    datedOfferingEngineContractVersion: z.ZodLiteral<"shared_v1">;
+    datedOfferingEngineRouteKind: z.ZodLiteral<"shared_whole_series_registration">;
+    datedOfferingCapacityHoldId: z.ZodString;
+    datedOfferingCapacityHoldAuditRef: z.ZodString;
+    customerId: z.ZodString;
+    eventSeriesId: z.ZodString;
+    type: z.ZodLiteral<"order">;
+    site_id: z.ZodString;
+    order_id: z.ZodOptional<z.ZodString>;
+    customer_email: z.ZodString;
+    customer_name: z.ZodOptional<z.ZodString>;
+    product_id: z.ZodOptional<z.ZodString>;
+    attendee_id: z.ZodOptional<z.ZodString>;
+    occurrence_id: z.ZodOptional<z.ZodString>;
+    tickets_count: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    discount_redemption_id: z.ZodOptional<z.ZodString>;
+    discount_code_id: z.ZodOptional<z.ZodString>;
+    discount_code: z.ZodOptional<z.ZodString>;
+    discount_public_label: z.ZodOptional<z.ZodString>;
+    credit_reservation_id: z.ZodOptional<z.ZodString>;
+    credit_reserved_cents: z.ZodOptional<z.ZodString>;
+    discount_code_amount_cents: z.ZodOptional<z.ZodString>;
+    order_payment_reason: z.ZodOptional<z.ZodEnum<{
+        flexible_balance_paydown: "flexible_balance_paydown";
+        instalment_payoff: "instalment_payoff";
+        flexible_balance_initial: "flexible_balance_initial";
+    }>>;
+    order_payment_plan_id: z.ZodOptional<z.ZodString>;
+    order_flexible_balance_contract_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    datedOfferingEngineContractVersion: z.ZodOptional<z.ZodNever>;
+    datedOfferingEngineRouteKind: z.ZodOptional<z.ZodNever>;
+    datedOfferingCapacityHoldId: z.ZodOptional<z.ZodNever>;
+    datedOfferingCapacityHoldAuditRef: z.ZodOptional<z.ZodNever>;
+    customerId: z.ZodOptional<z.ZodNever>;
+    eventSeriesId: z.ZodOptional<z.ZodNever>;
+    type: z.ZodLiteral<"order">;
+    site_id: z.ZodString;
+    order_id: z.ZodOptional<z.ZodString>;
+    customer_email: z.ZodString;
+    customer_name: z.ZodOptional<z.ZodString>;
+    product_id: z.ZodOptional<z.ZodString>;
+    attendee_id: z.ZodOptional<z.ZodString>;
+    occurrence_id: z.ZodOptional<z.ZodString>;
+    tickets_count: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    discount_redemption_id: z.ZodOptional<z.ZodString>;
+    discount_code_id: z.ZodOptional<z.ZodString>;
+    discount_code: z.ZodOptional<z.ZodString>;
+    discount_public_label: z.ZodOptional<z.ZodString>;
+    credit_reservation_id: z.ZodOptional<z.ZodString>;
+    credit_reserved_cents: z.ZodOptional<z.ZodString>;
+    discount_code_amount_cents: z.ZodOptional<z.ZodString>;
+    order_payment_reason: z.ZodOptional<z.ZodEnum<{
+        flexible_balance_paydown: "flexible_balance_paydown";
+        instalment_payoff: "instalment_payoff";
+        flexible_balance_initial: "flexible_balance_initial";
+    }>>;
+    order_payment_plan_id: z.ZodOptional<z.ZodString>;
+    order_flexible_balance_contract_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export type OrderCheckoutSessionMetadata = z.infer<typeof OrderCheckoutSessionMetadataSchema>;
+export type OrderCheckoutSessionMetadataWithOrderId = OrderCheckoutSessionMetadata & Readonly<{
+    order_id: string;
+}>;

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

@@ -0,0 +1,46 @@
+import { type NonNegativeCents, type Result } from '../../../core/src/index';
+import { type CurrencyCode, type LineSettlementBreakdown, type LineSettlementMoneyField } from './settlement';
+export type CheckoutSettlementMoneyField = LineSettlementMoneyField | 'totalAfterDiscountCents';
+export type CheckoutSettlementError<TLineId extends string = string> = Readonly<{
+    _tag: 'empty_cart';
+    message: string;
+}> | Readonly<{
+    _tag: 'invalid_credit_requested';
+    message: string;
+}> | Readonly<{
+    _tag: 'invalid_line_money';
+    lineId: TLineId;
+    field: CheckoutSettlementMoneyField;
+    message: string;
+}> | Readonly<{
+    _tag: 'inconsistent_line_totals';
+    lineId: TLineId;
+    message: string;
+}>;
+export type CheckoutSettlementLineInput<TLineId extends string, TPayload> = Readonly<{
+    lineId: TLineId;
+    subtotalCents: NonNegativeCents;
+    discountCents: NonNegativeCents;
+    totalAfterDiscountCents: NonNegativeCents;
+    payload: TPayload;
+}>;
+export type CheckoutSettlementInput<TLineId extends string, TPayload> = Readonly<{
+    currency: CurrencyCode;
+    creditRequestedCents: NonNegativeCents;
+    items: readonly CheckoutSettlementLineInput<TLineId, TPayload>[];
+}>;
+export type CheckoutSettlementLine<TLineId extends string, TPayload> = Readonly<{
+    lineId: TLineId;
+    payload: TPayload;
+    settlement: LineSettlementBreakdown;
+}>;
+export type CheckoutSettlement<TLineId extends string, TPayload> = Readonly<{
+    currency: CurrencyCode;
+    items: readonly CheckoutSettlementLine<TLineId, TPayload>[];
+    subtotalCents: NonNegativeCents;
+    discountCents: NonNegativeCents;
+    totalAfterDiscountCents: NonNegativeCents;
+    creditCents: NonNegativeCents;
+    totalAfterCreditsCents: NonNegativeCents;
+}>;
+export declare function settleCheckoutCart<TLineId extends string, TPayload>(input: CheckoutSettlementInput<TLineId, TPayload>): Result<CheckoutSettlement<TLineId, TPayload>, CheckoutSettlementError<TLineId>>;

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

@@ -0,0 +1,12 @@
+export type CheckoutStripeFinalizationPaymentPlanKind = 'stripe' | 'instalment_plan' | 'flexible_balance';
+export type CheckoutStripeSessionRecordUpdateTarget = 'order' | 'order_payment_plan' | 'flexible_balance_contract';
+export type CheckoutStripeSessionRecordUpdatePlan = Readonly<{
+    target: CheckoutStripeSessionRecordUpdateTarget;
+    orderId: string;
+    sessionId: string;
+}>;
+export declare function planCheckoutStripeSessionRecordUpdates(options: Readonly<{
+    paymentPlanKind: CheckoutStripeFinalizationPaymentPlanKind;
+    orderId: string;
+    sessionId: string;
+}>): readonly CheckoutStripeSessionRecordUpdatePlan[];