@riverbankcms/sdk 0.130.0 → 0.132.0

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[];

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

@@ -0,0 +1,125 @@
+import { type Result } from '../../../core/src/index';
+import { type LineSettlementBreakdown } from './settlement';
+export type CheckoutStripeSessionPaymentPlan = Readonly<{
+    kind: 'stripe' | 'instalment_plan';
+    creditReservationId?: string | null;
+}> | Readonly<{
+    kind: 'flexible_balance';
+    initialPaymentCents: number;
+    creditReservationId?: string | null;
+}>;
+export type CheckoutStripeSessionPaymentIntentPaymentPlan = Readonly<{
+    kind: CheckoutStripeSessionPaymentPlan['kind'];
+}>;
+export type CheckoutStripeSessionLineInput = Readonly<{
+    displayName: string;
+    quantity: number;
+    settlement: Readonly<{
+        line: LineSettlementBreakdown;
+    }>;
+}>;
+export type CheckoutStripeSessionLineItemPlan = Readonly<{
+    name: string;
+    unitAmountCents: number;
+    quantity: number;
+}>;
+export type CheckoutStripeSessionCollectionPlan = Readonly<{
+    lineItems: readonly CheckoutStripeSessionLineItemPlan[];
+    totals: Readonly<{
+        discountCents: number;
+        creditCents: number;
+    }>;
+    expiresAtEpoch: number | undefined;
+}>;
+export type CheckoutStripeSessionDiscountMetadata = Readonly<{
+    redemptionId: string;
+    discountCodeId: string;
+    discountCode: string;
+    discountPublicLabel: string;
+}>;
+export type CheckoutStripeSessionOrderReferences = Readonly<{
+    siteId: string;
+    orderId: string;
+    customerEmail: string;
+    orderPaymentPlanId: string | null;
+    flexibleBalanceContractId: string | null;
+}>;
+export type CheckoutStripeSessionApplicationFeeDecision = Readonly<{
+    kind: 'none';
+}> | Readonly<{
+    kind: 'application_fee_amount';
+    amountCents: number;
+}>;
+export type CheckoutStripeSessionPaymentIntentPlan = Readonly<{
+    customerCreation?: 'always';
+    setupFutureUsage?: 'off_session';
+    applicationFeeAmountCents?: number;
+}>;
+export type CheckoutStripeSessionSettlementPolicy = Readonly<{
+    kind: 'stripe_default';
+}> | Readonly<{
+    kind: 'must_settle_before_reservation_deadline';
+    paymentMethodSet: 'immediate_only';
+}>;
+export type CheckoutStripeSessionRequestPlan = CheckoutStripeSessionCollectionPlan & Readonly<{
+    metadata: Record<string, string>;
+    paymentIntent: CheckoutStripeSessionPaymentIntentPlan;
+    paymentMethodTypes: readonly ['card'] | undefined;
+}>;
+export type CheckoutStripeSessionPlanningError = Readonly<{
+    _tag: 'invalid_line_quantity';
+    lineIndex: number;
+    quantity: number;
+    message: string;
+}> | Readonly<{
+    _tag: 'invalid_line_money';
+    lineIndex: number;
+    field: 'stripeChargeCents';
+    amountCents: number;
+    message: string;
+}> | Readonly<{
+    _tag: 'invalid_flexible_balance_initial_payment';
+    amountCents: number;
+    message: string;
+}>;
+export declare function planCheckoutStripeSessionRequest(options: Readonly<{
+    checkoutLines: readonly CheckoutStripeSessionLineInput[];
+    paymentPlan: CheckoutStripeSessionPaymentPlan;
+    orderDisplayName: string;
+    discountExpiresAtEpoch: number | undefined;
+    creditReservationExpiresAtIso: string | null;
+    registrationHoldExpiresAtEpoch?: number;
+    discount: CheckoutStripeSessionDiscountMetadata | null;
+    orderReferences: CheckoutStripeSessionOrderReferences;
+    applicationFeeDecision: CheckoutStripeSessionApplicationFeeDecision;
+    settlementPolicy?: CheckoutStripeSessionSettlementPolicy;
+}>): Result<CheckoutStripeSessionRequestPlan, CheckoutStripeSessionPlanningError>;
+export declare function planCheckoutStripeSessionCollection(options: Readonly<{
+    checkoutLines: readonly CheckoutStripeSessionLineInput[];
+    paymentPlan: CheckoutStripeSessionPaymentPlan;
+    orderDisplayName: string;
+    discountExpiresAtEpoch: number | undefined;
+    creditReservationExpiresAtIso: string | null;
+    registrationHoldExpiresAtEpoch?: number;
+}>): Result<CheckoutStripeSessionCollectionPlan, CheckoutStripeSessionPlanningError>;
+export declare function planCheckoutStripeSessionMetadata(options: Readonly<{
+    paymentPlan: CheckoutStripeSessionPaymentPlan;
+    discount: CheckoutStripeSessionDiscountMetadata | null;
+    orderReferences: CheckoutStripeSessionOrderReferences;
+    totals: CheckoutStripeSessionCollectionPlan['totals'];
+}>): Record<string, string>;
+export declare function planCheckoutStripeSessionPaymentIntent(options: Readonly<{
+    paymentPlan: CheckoutStripeSessionPaymentIntentPaymentPlan;
+    applicationFeeDecision: CheckoutStripeSessionApplicationFeeDecision;
+}>): CheckoutStripeSessionPaymentIntentPlan;
+export declare function summarizeCheckoutSessionLines(lines: readonly CheckoutStripeSessionLineInput[]): CheckoutStripeSessionCollectionPlan['totals'];
+export declare function resolveCheckoutSessionExpiryEpoch(options: Readonly<{
+    discountExpiresAtEpoch: number | undefined;
+    creditReservationExpiresAtIso: string | null;
+    registrationHoldExpiresAtEpoch?: number;
+}>): number | undefined;
+export declare function planCheckoutStripeLineItems(options: Readonly<{
+    checkoutLines: readonly CheckoutStripeSessionLineInput[];
+    paymentPlan: CheckoutStripeSessionPaymentPlan;
+    orderDisplayName: string;
+}>): Result<readonly CheckoutStripeSessionLineItemPlan[], CheckoutStripeSessionPlanningError>;

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

@@ -0,0 +1,55 @@
+import type { BookingFlexibleBalanceConfig } from '../../../core/src/index';
+import type { CheckoutPaymentTermCollectionOptionKind } from './checkoutPaymentTerms';
+export type SelectedAppointmentCheckoutCollectionOption<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+    kind: 'upfront' | 'deferred_manual';
+}> | Readonly<{
+    kind: 'instalment_plan';
+    plan: TInstalmentPlan;
+}> | Readonly<{
+    kind: 'flexible_balance';
+    config: TFlexibleBalanceConfig;
+}> | null;
+export type SelectedAttendeeBookingCheckoutCollectionOption<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+    kind: 'upfront' | 'deferred_manual';
+}> | Readonly<{
+    kind: 'flexible_balance';
+    config: TFlexibleBalanceConfig;
+}> | null;
+export type AttendeeBookingCollectionOptionInput<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+    kind: 'upfront' | 'deferred_manual';
+}> | Readonly<{
+    kind: 'flexible_balance';
+    config: TFlexibleBalanceConfig;
+}> | Readonly<{
+    kind: 'instalment_plan';
+}> | null;
+export type ValidatedAttendeeBookingPaymentSelection<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+    bookingStartAt: string;
+    selectedCollectionOptionKind: 'flexible_balance';
+    selectedFlexibleBalanceConfig: TFlexibleBalanceConfig;
+}> | Readonly<{
+    bookingStartAt: string;
+    selectedCollectionOptionKind: Exclude<CheckoutPaymentTermCollectionOptionKind, 'flexible_balance'> | null;
+    selectedFlexibleBalanceConfig: null;
+}>;
+export type ValidatedAppointmentPaymentSelection<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+    selectedCollectionOptionKind: 'instalment_plan';
+    selectedInstalmentPlan: TInstalmentPlan;
+    selectedFlexibleBalanceConfig: null;
+}> | Readonly<{
+    selectedCollectionOptionKind: 'flexible_balance';
+    selectedInstalmentPlan: null;
+    selectedFlexibleBalanceConfig: TFlexibleBalanceConfig;
+}> | Readonly<{
+    selectedCollectionOptionKind: 'upfront' | 'deferred_manual' | null;
+    selectedInstalmentPlan: null;
+    selectedFlexibleBalanceConfig: null;
+}>;
+export declare function buildValidatedAttendeeBookingPaymentSelection<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig>(input: Readonly<{
+    bookingStartAt: string;
+    selectedCollectionOption: SelectedAttendeeBookingCheckoutCollectionOption<TFlexibleBalanceConfig>;
+}>): ValidatedAttendeeBookingPaymentSelection<TFlexibleBalanceConfig>;
+export declare function toSelectedAttendeeBookingCheckoutCollectionOption<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig>(option: AttendeeBookingCollectionOptionInput<TFlexibleBalanceConfig>): SelectedAttendeeBookingCheckoutCollectionOption<TFlexibleBalanceConfig>;
+export declare function buildValidatedAppointmentPaymentSelection<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig>(input: Readonly<{
+    selectedCollectionOption: SelectedAppointmentCheckoutCollectionOption<TInstalmentPlan, TFlexibleBalanceConfig>;
+}>): ValidatedAppointmentPaymentSelection<TInstalmentPlan, TFlexibleBalanceConfig>;