@riverbankcms/sdk 0.130.2 → 0.134.0

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

@@ -0,0 +1,184 @@
+import { type ManualPaymentOperationId, type NonNegativeCents, type OrderFlexibleBalanceContractId, type OrderId, type OrderItemId, type OrderPaymentPlanId, type OrderPaymentPlanInstalmentId, type OrderPaymentReceiptId, type PositiveCents, type Result, type SiteId, type StripeAccountRef, type StripeCheckoutSessionId, type StripeInvoiceId, type StripePaymentIntentRef, type UserId, type UtcIsoDateTimeString } from '../../../core/src/index';
+import { type CurrencyCode } from './settlement';
+export type StripeCheckoutPaymentRail = Readonly<{
+    kind: 'stripe_checkout';
+    stripeAccountRef: StripeAccountRef;
+    checkoutSessionId: StripeCheckoutSessionId;
+    paymentIntentRef: StripePaymentIntentRef;
+    invoiceId: StripeInvoiceId | null;
+}>;
+export type StripeInvoicePaymentRail = Readonly<{
+    kind: 'stripe_invoice';
+    stripeAccountRef: StripeAccountRef;
+    invoiceId: StripeInvoiceId;
+    paymentIntentRef: StripePaymentIntentRef | null;
+}>;
+export type ManualPaymentRail = Readonly<{
+    kind: 'manual';
+    operationId: ManualPaymentOperationId;
+    recordedByUserId: UserId;
+    externalReference: string | null;
+    note: string | null;
+}>;
+export type OrderPaymentRail = StripeCheckoutPaymentRail | StripeInvoicePaymentRail | ManualPaymentRail;
+export type InitialCheckoutPaymentTarget = Readonly<{
+    kind: 'immediate';
+}> | Readonly<{
+    kind: 'flexible_balance';
+    contractId: OrderFlexibleBalanceContractId;
+}> | Readonly<{
+    kind: 'instalment_plan';
+    paymentPlanId: OrderPaymentPlanId;
+}>;
+export type OrderPaymentPurpose = Readonly<{
+    kind: 'initial_checkout';
+    target: InitialCheckoutPaymentTarget;
+}> | Readonly<{
+    kind: 'flexible_balance_paydown';
+    contractId: OrderFlexibleBalanceContractId;
+}> | Readonly<{
+    kind: 'instalment';
+    paymentPlanId: OrderPaymentPlanId;
+    instalmentId: OrderPaymentPlanInstalmentId;
+}> | Readonly<{
+    kind: 'instalment_payoff';
+    paymentPlanId: OrderPaymentPlanId;
+}> | Readonly<{
+    kind: 'subscription_renewal';
+}>;
+export type OrderPaymentReceiptProvenance = 'live' | 'backfilled_exact';
+type SuccessfulOrderPaymentBase = Readonly<{
+    siteId: SiteId;
+    orderId: OrderId;
+    amountCents: PositiveCents;
+    currency: CurrencyCode;
+    paidAt: UtcIsoDateTimeString;
+}>;
+type SuccessfulOrderPaymentDetails = Readonly<{
+    purpose: OrderPaymentPurpose;
+    rail: ManualPaymentRail;
+}> | Readonly<{
+    purpose: Extract<OrderPaymentPurpose, {
+        kind: 'initial_checkout';
+    }>;
+    rail: StripeCheckoutPaymentRail;
+}> | Readonly<{
+    purpose: Extract<OrderPaymentPurpose, {
+        kind: 'flexible_balance_paydown';
+    }>;
+    rail: StripeCheckoutPaymentRail;
+}> | Readonly<{
+    purpose: Extract<OrderPaymentPurpose, {
+        kind: 'instalment';
+    }>;
+    rail: StripeInvoicePaymentRail;
+}> | Readonly<{
+    purpose: Extract<OrderPaymentPurpose, {
+        kind: 'subscription_renewal';
+    }>;
+    rail: StripeInvoicePaymentRail;
+}> | Readonly<{
+    purpose: Extract<OrderPaymentPurpose, {
+        kind: 'instalment_payoff';
+    }>;
+    rail: StripeCheckoutPaymentRail;
+}>;
+export type ApplySuccessfulOrderPayment = SuccessfulOrderPaymentBase & SuccessfulOrderPaymentDetails;
+export type ProviderSuccessfulOrderPayment = Exclude<ApplySuccessfulOrderPayment, Readonly<{
+    rail: ManualPaymentRail;
+}>>;
+export declare function isProviderSuccessfulOrderPayment(command: ApplySuccessfulOrderPayment): command is ProviderSuccessfulOrderPayment;
+export type OrderPaymentReceipt = Readonly<{
+    id: OrderPaymentReceiptId;
+    provenance: OrderPaymentReceiptProvenance;
+    appliedCents: NonNegativeCents;
+    applicationState: 'applied' | 'reconciliation_needed';
+}> & SuccessfulOrderPaymentBase & SuccessfulOrderPaymentDetails;
+export type AppliedOrderPaymentProjection = Readonly<{
+    orderPaidCents: NonNegativeCents;
+    orderStatus: 'pending' | 'paid';
+    contractPaidCents: NonNegativeCents | null;
+    contractRemainingCents: NonNegativeCents | null;
+    planRemainingCents: NonNegativeCents | null;
+}>;
+export type ApplySuccessfulOrderPaymentResult = Readonly<{
+    kind: 'applied' | 'already_applied';
+    receipt: OrderPaymentReceipt;
+    projection: AppliedOrderPaymentProjection;
+}> | Readonly<{
+    kind: 'reconciliation_needed';
+    receipt: OrderPaymentReceipt;
+}>;
+export type ApplySuccessfulOrderPaymentError = Readonly<{
+    kind: 'order_not_found';
+}> | Readonly<{
+    kind: 'payment_identity_conflict';
+    existingReceiptId: OrderPaymentReceiptId;
+}> | Readonly<{
+    kind: 'currency_mismatch';
+}> | Readonly<{
+    kind: 'amount_exceeds_outstanding';
+}> | Readonly<{
+    kind: 'invalid_order_state';
+}> | Readonly<{
+    kind: 'payment_terms_mismatch';
+}> | Readonly<{
+    kind: 'allocation_invariant_failed';
+}> | Readonly<{
+    kind: 'invalid_payment_fact';
+}> | Readonly<{
+    kind: 'concurrent_payment_application';
+}> | Readonly<{
+    kind: 'persistence_failed';
+    cause: unknown;
+}>;
+export declare function purposeFromSuccessfulOrderPayment(command: ApplySuccessfulOrderPayment): OrderPaymentPurpose;
+export type OrderPaymentReceiptAllocationInput = Readonly<{
+    orderItemId: OrderItemId;
+    allocationBasisCents: NonNegativeCents;
+    remainingCashCollectableCents: NonNegativeCents;
+    remainingRecognisableTaxCents: NonNegativeCents;
+}>;
+export type OrderPaymentReceiptAllocation = Readonly<{
+    orderItemId: OrderItemId;
+    amountCents: PositiveCents;
+    allocatedTaxCents: NonNegativeCents;
+}>;
+/**
+ * A receipt application planned against one observed order projection.
+ * The atomic adapter must compare the expected collected amount after taking
+ * the order lock before it is allowed to persist these allocations.
+ */
+export type PlannedOrderPaymentApplication = Readonly<{
+    command: ApplySuccessfulOrderPayment;
+    expectedOrderPaidCents: NonNegativeCents;
+    allocations: readonly OrderPaymentReceiptAllocation[];
+}>;
+export type PlanOrderPaymentReceiptAllocationsError = Readonly<{
+    kind: 'no_collectable_lines';
+}> | Readonly<{
+    kind: 'duplicate_order_item';
+    orderItemId: OrderItemId;
+}> | Readonly<{
+    kind: 'amount_exceeds_remaining';
+    requestedCents: PositiveCents;
+    remainingCents: NonNegativeCents;
+}> | Readonly<{
+    kind: 'allocation_invariant_failed';
+}>;
+export declare function planOrderPaymentReceiptAllocations(input: Readonly<{
+    lines: readonly OrderPaymentReceiptAllocationInput[];
+    amountCents: PositiveCents;
+}>): Result<readonly OrderPaymentReceiptAllocation[], PlanOrderPaymentReceiptAllocationsError>;
+/**
+ * Attribute provider-proven cash that cannot safely advance the obligation.
+ *
+ * Unlike an application plan, attribution deliberately ignores remaining
+ * obligation caps: the full cash movement must stay visible and refundable.
+ * It recognises no tax until an operator reconciles the excess.
+ */
+export declare function planUnappliedOrderPaymentReceiptAllocations(input: Readonly<{
+    lines: readonly OrderPaymentReceiptAllocationInput[];
+    amountCents: PositiveCents;
+}>): Result<readonly OrderPaymentReceiptAllocation[], PlanOrderPaymentReceiptAllocationsError>;
+export {};

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

@@ -0,0 +1,135 @@
+import { type BookingFlexibleBalanceContractStatus, type NonNegativeCents, type OrderFlexibleBalanceContractId, type OrderInstalmentPlanStatus, type OrderPaymentPlanId, type Result } from '../../../core/src/index';
+import type { OrderPaymentMethod, OrderStatus } from './orderTypes';
+export type PaymentTerms = Readonly<{
+    kind: 'immediate';
+}> | Readonly<{
+    kind: 'manual';
+}> | Readonly<{
+    kind: 'flexible_balance';
+    contractId: OrderFlexibleBalanceContractId;
+    status: BookingFlexibleBalanceContractStatus;
+    dueAt: string | null;
+    upfrontAmountCents: NonNegativeCents;
+}> | Readonly<{
+    kind: 'instalment_plan';
+    paymentPlanId: OrderPaymentPlanId;
+    status: OrderInstalmentPlanStatus;
+    nextDueAt: string | null;
+    nextDueAmountCents: NonNegativeCents | null;
+}>;
+export type OrderPaymentPosition = Readonly<{
+    kind: 'not_required';
+    reason: 'free' | 'waived' | 'pass' | 'membership';
+    totalCents: NonNegativeCents;
+    collectedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    outstandingCents: NonNegativeCents;
+}> | Readonly<{
+    kind: 'waived';
+    totalCents: NonNegativeCents;
+    collectedCents: NonNegativeCents;
+    waivedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    outstandingCents: 0 & NonNegativeCents;
+    terms: PaymentTerms;
+}> | Readonly<{
+    kind: 'unpaid';
+    totalCents: NonNegativeCents;
+    collectedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    outstandingCents: NonNegativeCents;
+    terms: PaymentTerms;
+}> | Readonly<{
+    kind: 'partially_paid';
+    totalCents: NonNegativeCents;
+    collectedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    outstandingCents: NonNegativeCents;
+    terms: PaymentTerms;
+}> | Readonly<{
+    kind: 'paid';
+    totalCents: NonNegativeCents;
+    collectedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    outstandingCents: 0 & NonNegativeCents;
+    settledVia: Exclude<OrderPaymentMethod, 'waived'>;
+    terms: PaymentTerms;
+}> | Readonly<{
+    kind: 'collection_failed';
+    totalCents: NonNegativeCents;
+    collectedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    outstandingCents: NonNegativeCents;
+    terms: PaymentTerms;
+}> | Readonly<{
+    kind: 'refunded';
+    totalCents: NonNegativeCents;
+    collectedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    outstandingCents: 0 & NonNegativeCents;
+    terms: PaymentTerms;
+}> | Readonly<{
+    kind: 'cancelled';
+    totalCents: NonNegativeCents;
+    collectedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    outstandingCents: 0 & NonNegativeCents;
+    terms: PaymentTerms;
+}>;
+export type OrderPaymentPositionInconsistency = Readonly<{
+    kind: 'paid_exceeds_collectable';
+}> | Readonly<{
+    kind: 'refunded_exceeds_collected';
+}> | Readonly<{
+    kind: 'projection_receipt_mismatch';
+    projection: 'flexible_balance' | 'instalment_plan';
+}> | Readonly<{
+    kind: 'conflicting_payment_terms';
+}> | Readonly<{
+    kind: 'managed_terms_for_non_monetary_order';
+}>;
+export type OrderPaymentPositionInput = Readonly<{
+    status: OrderStatus;
+    paymentMethod: OrderPaymentMethod;
+    grandTotalCents: NonNegativeCents;
+    paidCents: NonNegativeCents;
+    waivedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    flexibleBalance: Readonly<{
+        contractId: OrderFlexibleBalanceContractId;
+        status: BookingFlexibleBalanceContractStatus;
+        remainingBalanceCents: NonNegativeCents;
+        dueAt: string | null;
+        upfrontAmountCents: NonNegativeCents;
+    }> | null;
+    instalmentPlan: Readonly<{
+        paymentPlanId: OrderPaymentPlanId;
+        status: OrderInstalmentPlanStatus;
+        remainingBalanceCents: NonNegativeCents;
+        nextDueAt: string | null;
+        nextDueAmountCents: NonNegativeCents | null;
+    }> | null;
+    hasCollectionFailure?: boolean;
+}>;
+export declare function calculateOrderBalanceDueCents(input: Readonly<{
+    grandTotalCents: NonNegativeCents;
+    paidCents: NonNegativeCents;
+    waivedCents?: NonNegativeCents;
+}>): Result<NonNegativeCents, Extract<OrderPaymentPositionInconsistency, {
+    kind: 'paid_exceeds_collectable';
+}>>;
+export declare function deriveOrderPaymentPosition(input: OrderPaymentPositionInput): Result<OrderPaymentPosition, OrderPaymentPositionInconsistency>;
+export type PaymentPresentation = Readonly<{
+    tone: 'neutral' | 'positive' | 'warning' | 'critical';
+    label: 'Not required' | 'Waived' | 'Unpaid' | 'Partially paid' | 'Paid' | 'Payment failed' | 'Refunded' | 'Cancelled';
+    collectedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    outstandingCents: NonNegativeCents;
+    dueAt: string | null;
+    nextDueAt: string | null;
+}>;
+export declare function buildPaymentPresentation(position: OrderPaymentPosition): PaymentPresentation;
+export declare function hasOnlineOrderPaymentPath(input: Readonly<{
+    position: OrderPaymentPosition;
+    paymentMethod: OrderPaymentMethod;
+}>): boolean;

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

@@ -0,0 +1,102 @@
+import type { AttendeeId } from '../../../core/src/index';
+import type { AppointmentOrderItemMetadata, CourseEnrollmentOrderItemMetadata, EventTicketOrderItemMetadata, MembershipOrderItemMetadata, PassOrderItemMetadata, ProductOrderItemMetadata } from './orderItemMetadata';
+import type { OrderItemReconciliationState, OrderItemCommitState } from './orderTypes';
+/**
+ * Structural input records for pure order-planning helpers.
+ *
+ * Dashboard OrderItemRecord rows satisfy this shape, but this package keeps the
+ * boundary structural so commerce planning code does not depend on dashboard DB
+ * helper types. Tests and non-dashboard callers can provide the same domain
+ * facts without pulling in the app's data-access layer.
+ */
+type OrderItemPlanningBase = Readonly<{
+    id: string;
+    orderId: string;
+    siteId: string;
+    quantity: number;
+    subtotalCents: number | null;
+    discountCents: number | null;
+    creditCents: number | null;
+    netTotalCents: number | null;
+    totalCents: number | null;
+    refundedCents: number | null;
+    unitPriceCents: number | null;
+    createdAt: string;
+    fulfilledAt: string | null;
+    fulfillmentClaimedAt: string | null;
+    fulfillmentClaimToken: string | null;
+    commitState: OrderItemCommitState;
+    reconciliationState: OrderItemReconciliationState;
+    cancelledAt: string | null;
+    cancelledReason: string | null;
+    cancellationCategory: string | null;
+    cancellationInternalNote: string | null;
+}>;
+export type EventTicketOrderItemPlanningRecord = OrderItemPlanningBase & Readonly<{
+    kind: 'event_ticket';
+    metadata: EventTicketOrderItemMetadata;
+    eventAttendeeId: AttendeeId | null;
+    productId: null;
+    productVariantId: null;
+    customerPassId: null;
+    courseEnrollmentId: null;
+    appointmentId: null;
+    customerMembershipId: null;
+}>;
+export type ProductOrderItemPlanningRecord = OrderItemPlanningBase & Readonly<{
+    kind: 'product';
+    metadata: ProductOrderItemMetadata;
+    productId: string;
+    productVariantId: string | null;
+    eventAttendeeId: null;
+    customerPassId: null;
+    courseEnrollmentId: null;
+    appointmentId: null;
+    customerMembershipId: null;
+}>;
+export type PassOrderItemPlanningRecord = OrderItemPlanningBase & Readonly<{
+    kind: 'pass';
+    metadata: PassOrderItemMetadata;
+    customerPassId: string | null;
+    eventAttendeeId: AttendeeId | null;
+    productId: null;
+    productVariantId: null;
+    courseEnrollmentId: null;
+    appointmentId: null;
+    customerMembershipId: null;
+}>;
+export type CourseEnrollmentOrderItemPlanningRecord = OrderItemPlanningBase & Readonly<{
+    kind: 'course_enrollment';
+    metadata: CourseEnrollmentOrderItemMetadata;
+    courseEnrollmentId: string | null;
+    eventAttendeeId: null;
+    productId: null;
+    productVariantId: null;
+    customerPassId: null;
+    appointmentId: null;
+    customerMembershipId: null;
+}>;
+export type AppointmentOrderItemPlanningRecord = OrderItemPlanningBase & Readonly<{
+    kind: 'appointment';
+    metadata: AppointmentOrderItemMetadata;
+    appointmentId: string | null;
+    eventAttendeeId: null;
+    productId: null;
+    productVariantId: null;
+    customerPassId: string | null;
+    courseEnrollmentId: null;
+    customerMembershipId: null;
+}>;
+export type MembershipOrderItemPlanningRecord = OrderItemPlanningBase & Readonly<{
+    kind: 'membership';
+    metadata: MembershipOrderItemMetadata;
+    customerMembershipId: string | null;
+    eventAttendeeId: AttendeeId | null;
+    productId: null;
+    productVariantId: null;
+    customerPassId: null;
+    courseEnrollmentId: null;
+    appointmentId: null;
+}>;
+export type OrderItemPlanningRecord = EventTicketOrderItemPlanningRecord | ProductOrderItemPlanningRecord | PassOrderItemPlanningRecord | CourseEnrollmentOrderItemPlanningRecord | AppointmentOrderItemPlanningRecord | MembershipOrderItemPlanningRecord;
+export {};

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

@@ -0,0 +1,50 @@
+import { type OrderItemId, type NonNegativeCents, type Result } from '../../../core/src/index';
+export type OrderRefundLineInput = Readonly<{
+    orderItemId: OrderItemId;
+    netTotalCents: NonNegativeCents;
+    alreadyRefundedCents?: NonNegativeCents;
+}>;
+export type RequestedOrderLineRefund = Readonly<{
+    orderItemId: OrderItemId;
+    amountCents: NonNegativeCents;
+}>;
+export type PlannedOrderLineRefund = Readonly<{
+    orderItemId: OrderItemId;
+    requestedCents: NonNegativeCents;
+    refundableRemainingCents: NonNegativeCents;
+    appliedCents: NonNegativeCents;
+}>;
+export type OrderRefundPlan = Readonly<{
+    lines: PlannedOrderLineRefund[];
+    requestedTotalCents: NonNegativeCents;
+    appliedTotalCents: NonNegativeCents;
+    nextRefundedCents: NonNegativeCents;
+    nextStatus: 'partially_refunded' | 'refunded' | null;
+}>;
+export type SettledOrderRefundLine = Readonly<{
+    orderItemId: OrderItemId;
+    requestedCents: NonNegativeCents;
+    appliedCents: NonNegativeCents;
+}>;
+export type SettledOrderRefundPlan = Readonly<{
+    lines: SettledOrderRefundLine[];
+    refundedTotalCents: NonNegativeCents;
+}>;
+export declare function planOrderRefund(options: {
+    paidCents: NonNegativeCents;
+    currentRefundedCents: NonNegativeCents;
+    lines: ReadonlyArray<OrderRefundLineInput>;
+    requestedLineRefunds: ReadonlyArray<RequestedOrderLineRefund>;
+}): Result<OrderRefundPlan, string>;
+export declare function planOrderRefundSummaryUpdate(options: {
+    paidCents: NonNegativeCents;
+    currentRefundedCents: NonNegativeCents;
+    nextRefundedCents: NonNegativeCents;
+}): Result<Readonly<{
+    refundedCents: NonNegativeCents;
+    nextStatus: 'partially_refunded' | 'refunded' | null;
+}>, string>;
+export declare function settleOrderRefundPlan(options: {
+    planned: OrderRefundPlan;
+    actualRefundedCents: NonNegativeCents;
+}): Result<SettledOrderRefundPlan, string>;

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

@@ -0,0 +1,36 @@
+import { type NonNegativeCents, type Result } from '../../../core/src/index';
+import type { OrderItemKind } from './orderTypes';
+export declare const ORDER_REFUND_MODES: readonly ["refund_only", "refund_and_revoke"];
+export type OrderRefundMode = (typeof ORDER_REFUND_MODES)[number];
+export declare const ORDER_REFUND_ENTITLEMENT_ACTION_STATUSES: readonly ["not_requested", "pending", "succeeded", "reconciliation_needed"];
+export type OrderRefundEntitlementActionStatus = (typeof ORDER_REFUND_ENTITLEMENT_ACTION_STATUSES)[number];
+export type OrderRefundRevocationCandidate = Readonly<{
+    orderItemId: string;
+    kind: OrderItemKind;
+    refundableRemainingCents: NonNegativeCents;
+    plannedAppliedCents: NonNegativeCents;
+}>;
+export type PlannedOrderRefundEntitlementAction = Readonly<{
+    refundMode: 'refund_only';
+    entitlementActionStatus: 'not_requested';
+    revokedOrderItemIds: readonly [];
+}> | Readonly<{
+    refundMode: 'refund_and_revoke';
+    entitlementActionStatus: 'pending';
+    revokedOrderItemIds: readonly string[];
+}>;
+export declare function planOrderRefundEntitlementAction(options: {
+    refundMode: OrderRefundMode;
+    lines: ReadonlyArray<OrderRefundRevocationCandidate>;
+}): Result<PlannedOrderRefundEntitlementAction, string>;
+export declare function settleOrderRefundEntitlementAction(options: {
+    planned: PlannedOrderRefundEntitlementAction;
+    settledLines: ReadonlyArray<{
+        orderItemId: string;
+        appliedCents: NonNegativeCents;
+    }>;
+    plannedLines: ReadonlyArray<{
+        orderItemId: string;
+        refundableRemainingCents: NonNegativeCents;
+    }>;
+}): Result<readonly string[], string>;

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

@@ -0,0 +1,23 @@
+import { type Cents, type NonNegativeCents } from '../../../core/src/index';
+export type OrderGrandTotalSource = Readonly<{
+    subtotalCents: NonNegativeCents;
+    discountCents: NonNegativeCents;
+    taxCents: NonNegativeCents;
+    shippingCents: NonNegativeCents;
+}>;
+export type OrderReceiptTotalSource = OrderGrandTotalSource & Readonly<{
+    creditCents: NonNegativeCents;
+}>;
+export type RawOrderGrandTotalSource = Readonly<{
+    subtotalCents: number;
+    discountCents: number;
+    taxCents: number;
+    shippingCents: number;
+}>;
+export type RawOrderReceiptTotalSource = RawOrderGrandTotalSource & Readonly<{
+    creditCents: number;
+}>;
+export declare function brandOrderGrandTotalSource(source: RawOrderGrandTotalSource): OrderGrandTotalSource;
+export declare function brandOrderReceiptTotalSource(source: RawOrderReceiptTotalSource): OrderReceiptTotalSource;
+export declare function computeOrderGrandTotalCents(order: OrderGrandTotalSource): Cents;
+export declare function computeOrderReceiptTotalCents(order: OrderReceiptTotalSource): NonNegativeCents;

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

@@ -0,0 +1,39 @@
+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;
+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;
+export declare const CHECKOUT_COMMIT_STATES: readonly ["pending", "committing", "committed", "compensated"];
+export type CheckoutCommitState = (typeof CHECKOUT_COMMIT_STATES)[number];
+export declare function isCheckoutCommitState(value: string): value is CheckoutCommitState;
+export declare const ORDER_CHECKOUT_RECONCILIATION_STATES: readonly ["not_needed", "evidence_pending", "needed"];
+export type OrderCheckoutReconciliationState = (typeof ORDER_CHECKOUT_RECONCILIATION_STATES)[number];
+export declare function isOrderCheckoutReconciliationState(value: string): value is OrderCheckoutReconciliationState;
+export declare const ORDER_ITEM_RECONCILIATION_STATES: readonly ["not_needed", "needed"];
+export type OrderItemReconciliationState = (typeof ORDER_ITEM_RECONCILIATION_STATES)[number];
+export declare function isOrderItemReconciliationState(value: string): value is OrderItemReconciliationState;
+export declare const ORDER_ITEM_COMMIT_STATES: readonly ["pending", "committed", "compensated"];
+export type OrderItemCommitState = (typeof ORDER_ITEM_COMMIT_STATES)[number];
+export declare function isOrderItemCommitState(value: string): value is OrderItemCommitState;
+export declare const RESERVATION_FINALIZATION_STATES: readonly ["not_applicable", "reserved", "consumed", "released"];
+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 CheckoutCompensationDecision = Readonly<{
+    kind: 'release_reservations';
+    reason: string;
+}> | Readonly<{
+    kind: 'compensate_order';
+    reason: string;
+}> | Readonly<{
+    kind: 'mark_reconciliation_needed';
+    reason: string;
+}>;
+export declare const DISCOUNT_REDEMPTION_STATUSES: readonly ["pending", "redeemed", "released", "expired"];
+export type DiscountRedemptionStatus = (typeof DISCOUNT_REDEMPTION_STATUSES)[number];
+export declare function isDiscountRedemptionStatus(value: string): value is DiscountRedemptionStatus;
+export declare const ORDER_ITEM_KINDS: readonly ["event_ticket", "product", "pass", "course_enrollment", "appointment", "membership"];
+export type OrderItemKind = (typeof ORDER_ITEM_KINDS)[number];
+export declare function isOrderItemKind(value: string): value is OrderItemKind;

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

@@ -0,0 +1 @@
+export declare function isPendingOrderCheckoutSessionClaim(stripeCheckoutSessionId: string | null): boolean;

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

@@ -0,0 +1,27 @@
+import { type Result, type CheckoutLineId } from '../../../core/src/index';
+import { type RefundableLineSettlement } from './settlement';
+import { type PositiveCheckoutQuantity } from './checkoutQuantity';
+export type PersistedCheckoutLineKind = 'event_ticket' | 'product' | 'pass' | 'course_enrollment' | 'appointment' | 'membership';
+export type PersistedCheckoutLineInput = Readonly<{
+    id: string;
+    kind: PersistedCheckoutLineKind;
+    quantity: number;
+    subtotalCents: number | null;
+    discountCents: number | null;
+    creditCents: number | null;
+    netTotalCents: number | null;
+    totalCents: number | null;
+    metadata: Readonly<{
+        checkoutLineId?: CheckoutLineId;
+        displayName?: string;
+    }>;
+}>;
+export type PersistedCheckoutLine = Readonly<{
+    orderItemId: string;
+    checkoutLineId: CheckoutLineId | null;
+    kind: PersistedCheckoutLineKind;
+    quantity: PositiveCheckoutQuantity;
+    displayName: string;
+    settlement: RefundableLineSettlement;
+}>;
+export declare function projectPersistedCheckoutLines(items: ReadonlyArray<PersistedCheckoutLineInput>): Result<readonly PersistedCheckoutLine[], string>;