@riverbankcms/sdk 0.130.0 → 0.132.0

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-editor/src/components/ContentFieldsForm.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from 'react';
 import type { BlockManifest } from '../../../blocks/src/index';
-import { type FieldWidgetComponent } from '../../../block-form/src/client/index';
-import type { ManifestFormSource } from '../../../block-form/src/client/index';
+import { type FieldWidgetComponent } from '../../../block-form/src/index';
+import type { ManifestFormSource } from '../../../block-form/src/index';
 export type { AutosaveHandle } from '../hooks/useSimpleAutosave';
 export type ContentFieldsFormProps<TValues extends Record<string, unknown>> = {
     siteId: string;

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

@@ -57,19 +57,19 @@ export declare const EVENT_CONTENT_TYPE_SCHEMA: {
     readonly fields: [{
         readonly id: "summary";
         readonly type: "textarea";
-        readonly label: "Summary";
-        readonly description: "Short teaser shown in listings.";
+        readonly label: "Short introduction";
+        readonly description: "Write one or two sentences that help people quickly understand what this is. It appears wherever the event is listed and near the top of its page.";
         readonly rows: 3;
     }, {
         readonly id: "image";
         readonly type: "media";
-        readonly label: "Listing image";
-        readonly description: "Optional image used for event cards and previews.";
+        readonly label: "Event image";
+        readonly description: "Choose the main image people will see wherever the event is listed and on its page.";
     }, {
         readonly id: "body";
         readonly type: "richText";
-        readonly label: "Details";
-        readonly description: "Full event details and agenda.";
+        readonly label: "About this event";
+        readonly description: "Add the main information people need before booking—what to expect, who it’s for, what’s included, and anything they should bring or know.";
     }];
     readonly routing: {
         readonly enabled: true;
@@ -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

@@ -162,19 +162,19 @@ export declare const BUILTIN_CONTENT_TYPE_SCHEMAS: {
         readonly fields: [{
             readonly id: "summary";
             readonly type: "textarea";
-            readonly label: "Summary";
-            readonly description: "Short teaser shown in listings.";
+            readonly label: "Short introduction";
+            readonly description: "Write one or two sentences that help people quickly understand what this is. It appears wherever the event is listed and near the top of its page.";
             readonly rows: 3;
         }, {
             readonly id: "image";
             readonly type: "media";
-            readonly label: "Listing image";
-            readonly description: "Optional image used for event cards and previews.";
+            readonly label: "Event image";
+            readonly description: "Choose the main image people will see wherever the event is listed and on its page.";
         }, {
             readonly id: "body";
             readonly type: "richText";
-            readonly label: "Details";
-            readonly description: "Full event details and agenda.";
+            readonly label: "About this event";
+            readonly description: "Add the main information people need before booking—what to expect, who it’s for, what’s included, and anything they should bring or know.";
         }];
         readonly routing: {
             readonly enabled: true;
@@ -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: {