@riverbankcms/sdk 0.130.2 → 0.132.0

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

@@ -0,0 +1,86 @@
+import { type BookingDepositRefundPolicy, type BookingInstalmentPlanConfig, type NonNegativeCents } from '../../../core/src/index';
+import type { OrderPaymentPurpose } from './orderPaymentReceipt';
+export type ProtectedDepositPolicySubject = Readonly<{
+    kind: 'none';
+}> | Readonly<{
+    kind: 'protected_deposit';
+    sourceKind: 'flexible_balance' | 'instalment_plan';
+    protectedDepositAmountCents: NonNegativeCents;
+    depositRefundability: BookingDepositRefundPolicy;
+}>;
+export type ProtectedDepositRefundExposure = Readonly<{
+    subject: ProtectedDepositPolicySubject;
+    totalRemainingRefundableCents: NonNegativeCents;
+    policyRefundableCents: NonNegativeCents;
+    protectedDepositRemainingCents: NonNegativeCents;
+}>;
+export type ProtectedDepositRefundRequest = Readonly<{
+    kind: 'full_remaining';
+}> | Readonly<{
+    kind: 'partial_amount';
+    amountCents: NonNegativeCents;
+}>;
+export type AdminProtectedDepositRefundDecision = Readonly<{
+    kind: 'allowed';
+    requestedAmountCents: NonNegativeCents;
+    canonicalRemainingRefundableCents: NonNegativeCents;
+    touchesProtectedDeposit: boolean;
+    exposure: ProtectedDepositRefundExposure;
+}> | Readonly<{
+    kind: 'blocked';
+    errorCode: 'already_refunded' | 'amount_exceeds_remaining';
+    errorMessage: string;
+    requestedAmountCents: NonNegativeCents;
+    exposure: ProtectedDepositRefundExposure;
+}> | Readonly<{
+    kind: 'admin_override_required';
+    errorCode: 'deposit_refund_override_required';
+    errorMessage: string;
+    requestedAmountCents: NonNegativeCents;
+    exposure: ProtectedDepositRefundExposure;
+}>;
+export type PolicyOnlyProtectedDepositRefundDecision = Readonly<{
+    kind: 'allowed';
+    requestedAmountCents: NonNegativeCents;
+    canonicalRemainingRefundableCents: NonNegativeCents;
+    exposure: ProtectedDepositRefundExposure;
+}> | Readonly<{
+    kind: 'blocked';
+    errorCode: 'already_refunded' | 'amount_exceeds_remaining' | 'non_refundable_deposit_remaining';
+    errorMessage: string;
+    requestedAmountCents: NonNegativeCents;
+    exposure: ProtectedDepositRefundExposure;
+}>;
+export declare function buildProtectedDepositPolicySubjectFromFlexibleBalance(input: Readonly<{
+    upfrontAmountCents: NonNegativeCents;
+    depositRefundability: BookingDepositRefundPolicy;
+}>): ProtectedDepositPolicySubject;
+export declare function buildProtectedDepositPolicySubjectFromInstalmentPlan(plan: BookingInstalmentPlanConfig): ProtectedDepositPolicySubject;
+export declare function calculateProtectedDepositRefundExposure(input: Readonly<{
+    subject: ProtectedDepositPolicySubject;
+    itemTotalCents: NonNegativeCents;
+    itemRefundedCents: NonNegativeCents;
+    collectedRemainingCents: NonNegativeCents;
+}>): ProtectedDepositRefundExposure;
+/**
+ * Calculates policy exposure for one receipt allocation.
+ *
+ * A protected deposit is collected by the initial-checkout receipt. Later
+ * paydowns and instalments therefore remain independently refundable even
+ * while the entity still has a non-refundable deposit balance.
+ */
+export declare function calculateReceiptProtectedDepositRefundExposure(input: Readonly<{
+    subject: ProtectedDepositPolicySubject;
+    receiptPurpose: OrderPaymentPurpose['kind'];
+    allocatedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+}>): ProtectedDepositRefundExposure;
+export declare function planAdminProtectedDepositRefund(input: Readonly<{
+    exposure: ProtectedDepositRefundExposure;
+    request: ProtectedDepositRefundRequest;
+    allowProtectedDepositOverride: boolean;
+}>): AdminProtectedDepositRefundDecision;
+export declare function planPolicyOnlyProtectedDepositRefund(input: Readonly<{
+    exposure: ProtectedDepositRefundExposure;
+    request: ProtectedDepositRefundRequest;
+}>): PolicyOnlyProtectedDepositRefundDecision;

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

@@ -0,0 +1,8 @@
+export type ShopRefundablePaymentMethod = 'stripe' | 'mixed' | 'store_credit';
+/**
+ * Whether an order's payment method supports refunds through the shop refund flow.
+ *
+ * Pass redemption, membership access, and free orders cannot be refunded
+ * through Stripe or site credit — they need domain-specific handling.
+ */
+export declare function isShopRefundablePaymentMethod(paymentMethod: string): paymentMethod is ShopRefundablePaymentMethod;

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

@@ -0,0 +1,40 @@
+import { type NonNegativeCents, type Result } from '../../../core/src/index';
+/**
+ * Typed result of a rail-aware refund split.
+ * Prevents confusing cash/credit amounts at call sites.
+ */
+export type RefundRailSplit = Readonly<{
+    cashCents: NonNegativeCents;
+    creditCents: NonNegativeCents;
+}>;
+type RefundLineAllocation = Readonly<{
+    orderItemId: string;
+    appliedCents: number;
+}>;
+/** Minimal shape of a refund record for rail-aware splitting. */
+type RefundWithAllocations = Readonly<{
+    refundRail: 'cash' | 'credit' | 'mixed';
+    lineAllocations: ReadonlyArray<RefundLineAllocation>;
+}>;
+/**
+ * For mixed-payment items, compute remaining refundable amount per rail.
+ * Must account for prior refunds that already consumed part of each rail.
+ *
+ * The allocation order (credit before cash) is an accounting convention
+ * that determines *how much* goes to each rail — it does NOT imply
+ * execution order. The caller decides execution order (typically cash
+ * first so Stripe settles before issuing site credit).
+ *
+ * Pure function — no DB calls. Testable with just numbers.
+ */
+export declare function computeRailAwareRefundSplit(originalCashCents: NonNegativeCents, originalCreditCents: NonNegativeCents, priorCashRefunded: NonNegativeCents, priorCreditRefunded: NonNegativeCents, totalRefundCents: NonNegativeCents): RefundRailSplit;
+/**
+ * Summarize prior successful refunds by rail for a specific order item.
+ * Reads from line_allocations in order_refunds records.
+ *
+ * Pure function — just array reduction.
+ */
+export declare function summarizePriorRefundsByRail(refunds: ReadonlyArray<RefundWithAllocations>, orderItemId: string): Result<RefundRailSplit, Readonly<{
+    kind: 'mixed_rail_attribution_missing';
+}>>;
+export {};

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

@@ -0,0 +1,2 @@
+import { type Result } from '../../../core/src/index';
+export declare function traverseResult<TValue, TError>(results: readonly Result<TValue, TError>[]): Result<readonly TValue[], TError>;

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

@@ -0,0 +1,97 @@
+import { type Brand, type NonNegativeCents, type Result } from '../../../core/src/index';
+export type CurrencyCode = Brand<string, 'CurrencyCode'>;
+export type SubtotalCents = Brand<number, 'SubtotalCents'>;
+export type DiscountCents = Brand<number, 'DiscountCents'>;
+export type CreditAppliedCents = Brand<number, 'CreditAppliedCents'>;
+export type StripeChargeCents = Brand<number, 'StripeChargeCents'>;
+export type RefundedCents = Brand<number, 'RefundedCents'>;
+export type RefundableTotalCents = Brand<number, 'RefundableTotalCents'>;
+export type Money<C extends CurrencyCode = CurrencyCode> = Readonly<{
+    amountCents: NonNegativeCents;
+    currency: C;
+}>;
+export type CurrencyValidationResult = {
+    ok: true;
+    currency: CurrencyCode;
+} | {
+    ok: false;
+    reason: 'empty_cart' | 'mixed_currency' | 'invalid_currency';
+    currencies: string[];
+};
+export type AllocationInput<TLineId extends string = string> = {
+    lineId: TLineId;
+    basisCents: NonNegativeCents;
+    maxReducibleCents: NonNegativeCents;
+};
+export type LineAllocation<TLineId extends string = string> = {
+    lineId: TLineId;
+    amountCents: NonNegativeCents;
+};
+export type AllocationResult<TLineId extends string = string> = {
+    requestedCents: NonNegativeCents;
+    appliedCents: NonNegativeCents;
+    allocations: LineAllocation<TLineId>[];
+};
+export type SettledOrderLine = {
+    lineId: string;
+    subtotalCents: NonNegativeCents;
+    discountCents: NonNegativeCents;
+    creditCents: NonNegativeCents;
+    netTotalCents: NonNegativeCents;
+};
+export type LineSettlementBreakdown = Readonly<{
+    subtotalCents: SubtotalCents;
+    discountCents: DiscountCents;
+    creditAppliedCents: CreditAppliedCents;
+    stripeChargeCents: StripeChargeCents;
+}>;
+export type LineSettlementMoneyField = 'subtotalCents' | 'discountCents' | 'creditAppliedCents' | 'stripeChargeCents' | 'alreadyRefundedCents';
+export type LineSettlementBreakdownError<TLineId extends string = string> = Readonly<{
+    _tag: 'invalid_line_money';
+    lineId: TLineId;
+    field: LineSettlementMoneyField;
+    message: string;
+}> | Readonly<{
+    _tag: 'inconsistent_line_totals';
+    lineId: TLineId;
+    message: string;
+}>;
+export type RefundableLineSettlementError<TLineId extends string = string> = LineSettlementBreakdownError<TLineId> | Readonly<{
+    _tag: 'refunded_exceeds_refundable_total';
+    lineId: TLineId;
+    message: string;
+}>;
+export type RefundableLineSettlement = Readonly<{
+    line: LineSettlementBreakdown;
+    refundableTotalCents: RefundableTotalCents;
+    alreadyRefundedCents: RefundedCents;
+}>;
+export declare function normalizeCurrencyCode(raw: string): CurrencyCode;
+export declare function toSubtotalCents(raw: number): SubtotalCents;
+export declare function toDiscountCents(raw: number): DiscountCents;
+export declare function toCreditAppliedCents(raw: number): CreditAppliedCents;
+export declare function toStripeChargeCents(raw: number): StripeChargeCents;
+export declare function toRefundedCents(raw: number): RefundedCents;
+export declare function toRefundableTotalCents(raw: number): RefundableTotalCents;
+export declare function money<C extends CurrencyCode>(amountCents: number, currency: C): Money<C>;
+export declare function buildLineSettlementBreakdown<TLineId extends string>(options: Readonly<{
+    lineId: TLineId;
+    subtotalCents: number;
+    discountCents: number;
+    creditAppliedCents: number;
+    stripeChargeCents: number;
+}>): Result<LineSettlementBreakdown, LineSettlementBreakdownError<TLineId>>;
+export declare function buildRefundableLineSettlement<TLineId extends string>(options: Readonly<{
+    lineId: TLineId;
+    subtotalCents: number;
+    discountCents: number;
+    creditAppliedCents: number;
+    stripeChargeCents: number;
+    alreadyRefundedCents: number;
+}>): Result<RefundableLineSettlement, RefundableLineSettlementError<TLineId>>;
+export declare function refundableRemainingCents(settlement: RefundableLineSettlement): NonNegativeCents;
+export declare function ensureSingleCurrency(lines: ReadonlyArray<{
+    currency: string;
+}>): CurrencyValidationResult;
+export declare function allocateReductionCents<TLineId extends string = string>(inputs: ReadonlyArray<AllocationInput<TLineId>>, requestedCents: number): AllocationResult<TLineId>;
+export declare function assertSettledOrderLineInvariants(lines: ReadonlyArray<SettledOrderLine>): void;

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

@@ -0,0 +1,43 @@
+import { type ShopRefundableOrderItem } from './orderItemSupport';
+import type { OrderPaymentMethod } from './orderTypes';
+import { type ShopRefundablePaymentMethod } from './refundPolicy';
+export type ShopRefundPlanningError = Readonly<{
+    tag: 'ORDER_NOT_REFUNDABLE';
+    message: string;
+}> | Readonly<{
+    tag: 'NO_REFUNDABLE_ITEMS';
+    message: string;
+}>;
+type ShopRefundPlanningOrder = Readonly<{
+    orderNumber: string;
+    paymentMethod: OrderPaymentMethod;
+}>;
+export type RefundableShopOrder<TOrder extends ShopRefundPlanningOrder> = TOrder & Readonly<{
+    paymentMethod: ShopRefundablePaymentMethod;
+}>;
+export type ShopRefundPlanItem<TItem extends ShopRefundableOrderItem> = Readonly<{
+    item: TItem;
+    displayName: string;
+    refundMode: 'refund_and_revoke';
+    sourceType: 'product_order_refund' | 'pass_order_refund';
+}>;
+export type ShopRefundPlan<TOrder extends ShopRefundPlanningOrder, TItem extends ShopRefundableOrderItem> = Readonly<{
+    order: RefundableShopOrder<TOrder>;
+    items: readonly ShopRefundPlanItem<TItem>[];
+}>;
+export type ShopRefundPlanningResult<TOrder extends ShopRefundPlanningOrder, TItem extends ShopRefundableOrderItem> = Readonly<{
+    ok: true;
+    value: ShopRefundPlan<TOrder, TItem>;
+}> | Readonly<{
+    ok: false;
+    error: ShopRefundPlanningError;
+}>;
+export type ShopRefundItemStatusInput = Readonly<{
+    status: 'succeeded' | 'partially_succeeded' | 'failed';
+}>;
+export declare function refundMethodForShopOrder(order: Readonly<{
+    paymentMethod: ShopRefundablePaymentMethod;
+}>): 'cash' | 'credit';
+export declare function computeShopRefundStatus(itemResults: readonly ShopRefundItemStatusInput[]): 'succeeded' | 'partially_succeeded' | 'failed';
+export declare function planShopRefund<TOrder extends ShopRefundPlanningOrder, TItem extends ShopRefundableOrderItem>(order: TOrder, shopItems: readonly TItem[]): ShopRefundPlanningResult<TOrder, TItem>;
+export {};

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

@@ -0,0 +1,31 @@
+import { type Result } from '../../../core/src/index';
+import type { CheckoutCommitFailureStep, CheckoutCommitState, CheckoutCompensationDecision, CheckoutPaymentRail, OrderCheckoutReconciliationState, OrderItemReconciliationState, DiscountRedemptionStatus, OrderItemCommitState, OrderStatus } from './orderTypes';
+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 type CheckoutCommitEvent = 'start' | 'complete' | 'compensate' | 'release';
+export declare function advanceCheckoutCommitState(from: CheckoutCommitState, event: CheckoutCommitEvent): Result<CheckoutCommitState, string>;
+export declare function transitionCheckoutCommitStateTo(from: CheckoutCommitState, to: CheckoutCommitState): Result<CheckoutCommitState, string>;
+export type OrderItemCommitEvent = 'commit' | 'compensate';
+export declare function advanceOrderItemCommitState(from: OrderItemCommitState, event: OrderItemCommitEvent): Result<OrderItemCommitState, string>;
+export declare function transitionOrderItemCommitStateTo(from: OrderItemCommitState, to: OrderItemCommitState): Result<OrderItemCommitState, string>;
+export type OrderCheckoutReconciliationEvent = 'defer_settlement_evidence' | 'commit_verified_settlement' | 'mark_needed';
+export declare function advanceOrderCheckoutReconciliationState(from: OrderCheckoutReconciliationState, event: OrderCheckoutReconciliationEvent): Result<OrderCheckoutReconciliationState, string>;
+export declare function transitionOrderCheckoutReconciliationStateTo(from: OrderCheckoutReconciliationState, to: OrderCheckoutReconciliationState): Result<OrderCheckoutReconciliationState, string>;
+export declare function transitionOrderItemReconciliationStateTo(from: OrderItemReconciliationState, to: OrderItemReconciliationState): Result<OrderItemReconciliationState, string>;
+export declare function classifyCheckoutCompensationDecision(input: {
+    paymentRail: CheckoutPaymentRail;
+    failedStep: CheckoutCommitFailureStep;
+    reservationsConsumed: boolean;
+    fulfillmentCommitted: boolean;
+}): CheckoutCompensationDecision;
+export type DiscountRedemptionEvent = 'redeem' | 'release' | 'expire';
+export declare function advanceDiscountRedemptionStatus(from: DiscountRedemptionStatus, event: DiscountRedemptionEvent): Result<DiscountRedemptionStatus, string>;
+export declare function transitionDiscountRedemptionStatusTo(from: DiscountRedemptionStatus, to: DiscountRedemptionStatus): Result<DiscountRedemptionStatus, string>;
+export type FulfillmentClaimState = 'unclaimed' | 'claimed' | 'claimed_stale' | 'fulfilled' | 'missing';
+export type FulfillmentClaimEvent = 'claim' | 'reclaim' | 'complete' | 'release';
+export declare function advanceFulfillmentClaimState(from: FulfillmentClaimState, event: FulfillmentClaimEvent): Result<FulfillmentClaimState, string>;
+export type OrderRefundStatus = 'pending' | 'succeeded' | 'failed' | 'reconciliation_needed';
+export type OrderRefundEvent = 'succeed' | 'fail' | 'mark_reconciliation_needed';
+export declare function advanceOrderRefundStatus(from: OrderRefundStatus, event: OrderRefundEvent): Result<OrderRefundStatus, string>;
+export declare function transitionOrderRefundStatusTo(from: OrderRefundStatus, to: OrderRefundStatus): Result<OrderRefundStatus, string>;

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

@@ -0,0 +1,10 @@
+import { type CurrencyCode } from './settlement';
+export type StripeMinimumChargeRequirement = Readonly<{
+    currency: CurrencyCode;
+    minimumAmountCents: number;
+}>;
+export declare function getStripeMinimumChargeRequirement(rawCurrency: string): StripeMinimumChargeRequirement | null;
+export declare function isStripeChargeBelowMinimum(options: Readonly<{
+    amountCents: number;
+    currency: string;
+}>): boolean;

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

@@ -0,0 +1,168 @@
+/**
+ * Purchase domain types — the unified model for all customer acquisitions.
+ *
+ * Every time a customer acquires something (event ticket, product, pass,
+ * course, membership), it's a Purchase. Payment method is an attribute
+ * of the purchase, not a separate concept (Model B: unified).
+ */
+import type { OccurrenceId, TicketTypeId, PricingOptionId, ProductId, ProductVariantId, PassId, MembershipId, CustomerId, OrderId, AttendeeId, CustomerPassId, CustomerMembershipId, EnrollmentId, AppointmentId, NonEmptyArray, SiteId, EventSeriesId } from '../../../core/src/index';
+import type { PositiveCheckoutQuantity } from './checkoutQuantity';
+export type CheckoutItem = EventTicketItem | ProductItem | PassItem | CourseEnrollmentItem | AppointmentItem;
+export type EventTicketItem = {
+    type: 'event_ticket';
+    occurrenceId: OccurrenceId;
+    ticketTypeId?: TicketTypeId;
+    selectedSlidingAmount?: number;
+    ticketCount: PositiveCheckoutQuantity;
+    attendeeInfo: AttendeeInfo;
+};
+export type ProductItem = {
+    type: 'product';
+    productId: ProductId;
+    variantId?: ProductVariantId;
+    quantity: PositiveCheckoutQuantity;
+};
+export type PassItem = {
+    type: 'pass';
+    passId: PassId;
+};
+export type CourseEnrollmentItem = {
+    type: 'course_enrollment';
+    eventSeriesId: EventSeriesId;
+    pricingOptionId?: PricingOptionId;
+    selectedSlidingAmount?: number;
+    attendeeInfo: AttendeeInfo;
+};
+export type AppointmentItem = {
+    type: 'appointment';
+    formId: string;
+    serviceId: string;
+    resourceId: string;
+    startAt: string;
+    endAt: string;
+    timezone: string;
+    selectedSlidingAmount?: number;
+    customerInfo: AttendeeInfo;
+};
+export type MembershipItem = {
+    type: 'membership';
+    membershipId: MembershipId;
+};
+export type AttendeeFormData = Readonly<Record<string, unknown>>;
+export type AttendeeInfo = Readonly<{
+    email: string;
+    name: string;
+    formData?: AttendeeFormData;
+}>;
+export type AttendeeBearingCheckoutItem = EventTicketItem | CourseEnrollmentItem;
+export type Checkout = CartCheckout | MembershipCheckout;
+export type CartCheckout = {
+    mode: 'one_time';
+    siteId: SiteId;
+    items: NonEmptyArray<CheckoutItem>;
+    customer: CustomerInfo;
+    discountCode?: string;
+    collectionOptionKind?: 'upfront' | 'deferred_manual' | 'instalment_plan' | 'flexible_balance';
+    successUrl: string;
+    cancelUrl: string;
+};
+export type MembershipCheckout = {
+    mode: 'subscription';
+    siteId: SiteId;
+    membership: MembershipItem;
+    customer: CustomerInfo;
+    discountCode?: string;
+    successUrl: string;
+    cancelUrl: string;
+};
+export type CustomerInfo = {
+    email: string;
+    name: string;
+    existingCustomerId?: CustomerId;
+};
+export type PurchasePaymentMethod = {
+    type: 'stripe';
+    sessionId: string;
+    paymentIntentId: string;
+    accountId: string;
+} | {
+    type: 'store_credit';
+    amountCents: number;
+} | {
+    type: 'mixed';
+    creditAmountCents: number;
+    stripeSessionId: string;
+    stripePaymentIntentId: string;
+    stripeAccountId: string;
+} | {
+    type: 'pass_redemption';
+    customerPassId: CustomerPassId;
+    creditsUsed: number;
+} | {
+    type: 'membership_access';
+    customerMembershipId: CustomerMembershipId;
+} | {
+    type: 'free';
+};
+export type Purchase = {
+    id: OrderId;
+    orderNumber: string;
+    siteId: string;
+    customerId: CustomerId;
+    items: PurchaseLineItem[];
+    totals: PurchaseTotals;
+    payment: PurchasePaymentMethod;
+    createdAt: string;
+};
+export type PurchaseLineItem = {
+    type: 'event_ticket';
+    attendeeId: AttendeeId;
+    occurrenceId: OccurrenceId;
+    unitPriceCents: number;
+    quantity: number;
+} | {
+    type: 'product';
+    productId: ProductId;
+    variantId?: ProductVariantId;
+    unitPriceCents: number;
+    quantity: number;
+    shippingAddress?: ShippingAddress;
+} | {
+    type: 'pass';
+    customerPassId: CustomerPassId;
+    passId: PassId;
+    unitPriceCents: number;
+} | {
+    type: 'course_enrollment';
+    enrollmentId: EnrollmentId;
+    eventSeriesId: EventSeriesId;
+    pricingOptionId?: PricingOptionId;
+    unitPriceCents: number;
+} | {
+    type: 'appointment';
+    appointmentId: AppointmentId;
+    serviceId: string;
+    resourceId: string;
+    unitPriceCents: number;
+} | {
+    type: 'membership';
+    customerMembershipId: CustomerMembershipId;
+    membershipId: MembershipId;
+    unitPriceCents: number;
+};
+export type PurchaseTotals = {
+    subtotalCents: number;
+    discountCents: number;
+    creditCents: number;
+    paidCents: number;
+    currency: string;
+};
+export type ShippingAddress = {
+    name: string;
+    line1: string;
+    line2?: string;
+    city: string;
+    state?: string;
+    postalCode: string;
+    country: string;
+};

package/dist/_dts/commerce/src/shop/shipmentEligibility.d.ts

@@ -0,0 +1,14 @@
+import type { OrderItemKind } from '../purchase/orderTypes';
+export type ShipmentEligibilityInput = Readonly<{
+    kind: OrderItemKind;
+    requiresShipping: boolean;
+    cancelledAt: string | null;
+}>;
+/**
+ * Whether an order item is eligible for physical shipment.
+ *
+ * Only product items with `requires_shipping = true` that have not been cancelled
+ * are shippable. Digital products, passes, event tickets, course enrollments,
+ * and memberships are never shippable.
+ */
+export declare function isShippableItem(item: ShipmentEligibilityInput): boolean;

package/dist/_dts/commerce/src/utils/assertNever.d.ts

@@ -0,0 +1 @@
+export declare function assertNever(value: never, message?: string): never;

package/dist/_dts/content-model/src/content-types/builtin-schemas.d.ts

@@ -80,6 +80,10 @@ export declare const EVENT_CONTENT_TYPE_SCHEMA: {
             readonly kind: "event-occurrence";
             readonly segmentType: "uuid-or-date";
             readonly precedence: "subroute-first";
+        }, {
+            readonly kind: "event-run";
+            readonly segmentType: "slug";
+            readonly precedence: "content-first";
         }];
     };
     readonly labels: {

package/dist/_dts/content-model/src/content-types/builtins.d.ts

@@ -185,6 +185,10 @@ export declare const BUILTIN_CONTENT_TYPE_SCHEMAS: {
                 readonly kind: "event-occurrence";
                 readonly segmentType: "uuid-or-date";
                 readonly precedence: "subroute-first";
+            }, {
+                readonly kind: "event-run";
+                readonly segmentType: "slug";
+                readonly precedence: "content-first";
             }];
         };
         readonly labels: {