@riverbankcms/sdk 0.139.0 → 0.141.0

package/dist/_dts/blocks/src/system/runtime/nodes/appointment-services.d.ts

@@ -16,6 +16,49 @@ declare const publicLocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>], "mode">;
 type PublicAppointmentLocation = z.infer<typeof publicLocationSchema>;
+declare const publicAppointmentServiceSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    durationMinutes: z.ZodNumber;
+    pricing: z.ZodOptional<z.ZodObject<{
+        pricingStrategy: z.ZodEnum<{
+            free: "free";
+            single: "single";
+            tiered: "tiered";
+            sliding_scale: "sliding_scale";
+        }>;
+        currency: z.ZodString;
+        singlePriceAmount: z.ZodNullable<z.ZodNumber>;
+        slidingMinAmount: z.ZodNullable<z.ZodNumber>;
+        slidingMaxAmount: z.ZodNullable<z.ZodNumber>;
+        options: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            priceAmount: z.ZodNumber;
+            isActive: z.ZodBoolean;
+            saleStartsAt: z.ZodNullable<z.ZodString>;
+            saleEndsAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    priceAmount: z.ZodNullable<z.ZodNumber>;
+    priceCurrency: z.ZodNullable<z.ZodString>;
+    location: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"online">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"in_person">;
+        venue: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            area: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"either">;
+        venue: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            area: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "mode">;
+}, z.core.$strip>;
+type PublicAppointmentService = z.infer<typeof publicAppointmentServiceSchema>;
 export type AppointmentServiceRow = Readonly<{
     id: string;
     title: string;
@@ -24,6 +67,7 @@ export type AppointmentServiceRow = Readonly<{
     locationLabel: string | null;
     priceLabel: string | null;
     href: string;
+    detailsHref: string | null;
 }>;
 export type AppointmentServicesView = Readonly<{
     kind: 'items';
@@ -39,13 +83,16 @@ export type AppointmentServicesNodeProps = Readonly<{
     sectionHeading?: unknown;
     services?: unknown;
     pathname?: unknown;
+    servicePathPrefix?: unknown;
     className?: string | null;
 }>;
 export declare function formatAppointmentDuration(durationMinutes: number): string;
 export declare function formatAppointmentLocation(location: PublicAppointmentLocation): string | null;
+export declare function formatAppointmentPrice(service: PublicAppointmentService): string | null;
 export declare function buildAppointmentServicesView(input: Readonly<{
     services: unknown;
     pathname: string | undefined;
+    servicePathPrefix?: string | null;
 }>): AppointmentServicesView;
-export declare function AppointmentServicesNode({ sectionHeading, services, pathname, className, }: AppointmentServicesNodeProps): React.ReactElement;
+export declare function AppointmentServicesNode({ sectionHeading, services, pathname, servicePathPrefix, className, }: AppointmentServicesNodeProps): React.ReactElement;
 export default AppointmentServicesNode;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/EventRegistrationSurface.d.ts

@@ -1,4 +1,3 @@
-import React from 'react';
 import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
 export type EventPortalAuthCopy = Readonly<{
     title: string;
@@ -21,4 +20,4 @@ export declare function EventRegistrationSurface(props: Readonly<{
     buttonClass: string;
     supportEmail?: string;
     successMessage: string;
-}>): React.JSX.Element;
+}>): import("react").JSX.Element;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/TicketSelectionStep.d.ts

@@ -10,6 +10,8 @@ type TicketSelectionStepProps = {
     occurrenceContext?: OccurrenceContext | null;
     selectedAttendanceMode?: RegistrationAttendanceMode | null;
     onAttendanceModeChange?: (attendanceMode: RegistrationAttendanceMode) => void;
+    checkoutRecovery?: boolean;
+    onCheckoutRecovery?: () => void;
     ticketsCount: number;
     maxTickets: number;
     visibleTicketTypes?: ReturnType<typeof getVisibleTicketTypes>;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/checkoutRecovery.d.ts

@@ -0,0 +1,14 @@
+import type { PublicEventPricingOptionAvailability } from '../../../../../../core/src/index';
+import type { EligibilityData, RegistrationEvent } from './types';
+/** Recovery may select held places; checkout still owns admission and payment validation. */
+export declare function checkoutRecoveryOptionAvailability(availability: PublicEventPricingOptionAvailability): PublicEventPricingOptionAvailability;
+/**
+ * A form-only projection for the explicit existing-checkout path. It permits
+ * collecting the original selection without claiming a new place is available.
+ * The public checkout service identifies the customer and remains the admission
+ * authority; no reservation/customer data is exposed through this projection.
+ */
+export declare function getCheckoutRecoveryFormEligibility(eligibility: EligibilityData | null): EligibilityData | null;
+export declare function isSoldOutEventSelectable(event: RegistrationEvent, waitlistAvailable: boolean): boolean;
+export declare function canJoinWaitlistOutsideRecovery(event: RegistrationEvent | null, attendanceMode: 'in_person' | 'online' | null, checkoutRecovery: boolean): boolean;
+export declare function canRecoverEventCheckout(event: RegistrationEvent | null): boolean;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/eventSourceRecovery.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import type { PublicEvent } from '../../../blocks/events/shared/types';
+import type { PublicEventsRequest } from '../../api/types/events';
+export declare const eventRecoveryRequestSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    eventSurface: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        all: "all";
+        regularClassSchedule: "regularClassSchedule";
+        specialDatedEvents: "specialDatedEvents";
+    }>>;
+    scheduleScope: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        recurring: "recurring";
+        oneOff: "oneOff";
+    }>>;
+    detailLevel: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+        listing: "listing";
+    }>>;
+    stage: z.ZodOptional<z.ZodEnum<{
+        published: "published";
+        preview: "preview";
+    }>>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    afterStartsAt: z.ZodOptional<z.ZodString>;
+    afterId: z.ZodOptional<z.ZodString>;
+    categoryIds: z.ZodOptional<z.ZodString>;
+    venueId: z.ZodOptional<z.ZodString>;
+    staffMemberId: z.ZodOptional<z.ZodString>;
+    eventPresets: z.ZodOptional<z.ZodString>;
+    seriesId: z.ZodOptional<z.ZodString>;
+    seriesIds: z.ZodOptional<z.ZodString>;
+    runSeriesId: z.ZodOptional<z.ZodString>;
+    seriesSlug: z.ZodOptional<z.ZodString>;
+    includeOccurrenceId: z.ZodOptional<z.ZodString>;
+    readIntent: z.ZodOptional<z.ZodString>;
+    readProfile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EventRecoveryRequest = Omit<PublicEventsRequest, 'siteId'>;
+export type EventRegistrationEventSource = Readonly<{
+    kind: 'loaded';
+    events: PublicEvent[];
+}> | Readonly<{
+    kind: 'unresolved';
+    request: EventRecoveryRequest | null;
+}>;
+type EventSourceInput = Readonly<{
+    events?: PublicEvent[] | null;
+    wholeSeriesRunEvents?: PublicEvent[] | null;
+    failures?: Readonly<Record<string, unknown>> | null;
+}>;
+export declare function resolveEventRegistrationEventSource(input: EventSourceInput): EventRegistrationEventSource;
+export declare function parseEventLoaderRecoveryRequest(value: unknown): EventRecoveryRequest | null;
+export {};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/hooks.d.ts

@@ -54,6 +54,10 @@ export declare function usePortalAuthWithDeps(deps: EventRegistrationHooksDeps):
 export type UseEligibilityResult = {
     state: EligibilityLookupState;
     eligibility: EligibilityLookupState['eligibility'];
+    /** Identity of the inputs that produced `eligibility`, retained while refreshing. */
+    settledRequestKey: string | null;
+    /** Identity of the inputs currently requested by the wizard. */
+    requestKey: string;
     isLoading: boolean;
     error: EligibilityLookupState['error'];
     creditState: PortalCreditState;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/hooks.state.d.ts

@@ -3,18 +3,22 @@ import type { EligibilityData } from './types';
 export type EligibilityLookupState = {
     tag: 'idle';
     eligibility: null;
+    settledRequestKey: null;
     error: null;
 } | {
     tag: 'loading';
     eligibility: EligibilityData | null;
+    settledRequestKey: string | null;
     error: null;
 } | {
     tag: 'resolved';
     eligibility: EligibilityData;
+    settledRequestKey: string;
     error: null;
 } | {
     tag: 'failed';
     eligibility: null;
+    settledRequestKey: null;
     error: string;
 };
 export type EligibilityLookupAction = {
@@ -24,6 +28,7 @@ export type EligibilityLookupAction = {
 } | {
     type: 'resolved';
     eligibility: EligibilityData;
+    requestKey: string;
 } | {
     type: 'failed';
     message: string;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/types.d.ts

@@ -1,15 +1,13 @@
 import type { PublicEventPricing } from '../../../../../../core/src/index';
-import type { EventRegistrationPricingOption } from '../../../blocks/event-registration';
-import type { PublicEvent, PublicEventPricingOption, PublicEventPricingOptionAvailability } from '../../../blocks/events/shared/types';
+import type { EventRegistrationAvailablePaymentOption, EventRegistrationOptionsResponse, EventRegistrationPricingOption } from '../../../blocks/event-registration';
 import type { OccurrenceContext } from '../../../blocks/event-registration.shared';
-import type { PublicMembershipProductCollection, PublicPassProductCollection } from '../../../blocks/shop.shared';
-import type { PublicRunSession } from '../../../blocks/events/shared/types';
-import type { AvailablePass, AvailableMembership, DirectCheckoutCollectionOptionKind, EventTicketLineSummary } from '../../api/types';
+import type { PublicEvent, PublicEventPricingOption, PublicEventPricingOptionAvailability, PublicRunSession } from '../../../blocks/events/shared/types';
 import type { BlockBookingPaymentTerms } from '../../../blocks/shared/bookingPaymentTerms';
-import type { EventRegistrationPageSurfaceSubject } from './eventScope';
+import type { PublicMembershipProductCollection, PublicPassProductCollection } from '../../../blocks/shop.shared';
 import type { BlockButtonRole } from '../../../constants/buttonRoles';
-import type { EventRegistrationAvailablePaymentOption, EventRegistrationOptionsResponse } from '../../../blocks/event-registration';
-export type { PublicEvent, OccurrenceContext };
+import type { AvailableMembership, AvailablePass, DirectCheckoutCollectionOptionKind, EventTicketLineSummary } from '../../api/types';
+import type { EventRegistrationPageSurfaceSubject } from './eventScope';
+export type { OccurrenceContext, PublicEvent };
 export type { FormData } from '../../shared';
 /**
  * Guest details for additional attendees (when "collect all attendee details" is enabled)

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useCheckoutRecovery.d.ts

@@ -0,0 +1,8 @@
+import type { EligibilityData, RegistrationEvent, RegistrationStep } from './types';
+/** Recovery belongs to the selected booking subject; changing events resets its scope. */
+export declare function useCheckoutRecovery(event: RegistrationEvent | null, setStep: (step: RegistrationStep) => void): {
+    checkoutRecovery: boolean;
+    startCheckoutRecovery: () => void;
+};
+/** Authenticated pending bookings enter the same form-only recovery path as guests. */
+export declare function useCheckoutRecoveryEligibility(eligibility: EligibilityData | null, step: RegistrationStep, checkoutRecovery: boolean, startCheckoutRecovery: () => void): EligibilityData | null;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useDiscountCodeUi.d.ts

@@ -13,4 +13,7 @@ export declare function useDiscountCodeUi(options: {
     manualCodeEntryAllowed: boolean;
     autoAppliedDiscount: import("../../api/types").AutoAppliedDiscountPreview | null;
     discountsAvailableLoading: boolean;
+    discountAvailabilityRequestKey: string;
+    settledDiscountAvailabilityRequestKey: string | null;
 };
+export type UseDiscountCodeUiResult = ReturnType<typeof useDiscountCodeUi>;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useDiscountCodeUi.state.d.ts

@@ -11,14 +11,19 @@ type DiscountAvailabilityState = Readonly<{
     tag: 'disabled';
 }> | Readonly<{
     tag: 'loading';
-}> | Readonly<{
+    previous: SettledDiscountAvailabilityState | null;
+}> | SettledDiscountAvailabilityState | Readonly<{
+    tag: 'error';
+    requestKey: string;
+}>;
+type SettledDiscountAvailabilityState = Readonly<{
     tag: 'unavailable';
+    requestKey: string;
 }> | Readonly<{
     tag: 'available';
+    requestKey: string;
     manualCodeEntryAllowed: boolean;
     autoAppliedDiscount: AutoAppliedDiscountPreview | null;
-}> | Readonly<{
-    tag: 'error';
 }>;
 export type DiscountCodeUiState = Readonly<{
     discountUiOpen: boolean;
@@ -31,9 +36,11 @@ export type DiscountCodeUiEvent = Readonly<{
     type: 'availability-loading';
 }> | Readonly<{
     type: 'availability-loaded';
+    requestKey: string;
     response: DiscountsAvailableResponse;
 }> | Readonly<{
     type: 'availability-failed';
+    requestKey: string;
 }> | Readonly<{
     type: 'discount-code-changed';
     code: string;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useEventCheckoutHandoffRestore.d.ts

@@ -0,0 +1,9 @@
+type CheckoutHandoffRestoreDeps = Readonly<{
+    addPageShowListener: (listener: (event: PageTransitionEvent) => void) => void;
+    removePageShowListener: (listener: (event: PageTransitionEvent) => void) => void;
+    reloadAtRegistration: () => void;
+}>;
+export declare function eventRegistrationReloadTarget(location: Pick<Location, 'pathname' | 'search'>): string;
+export declare function useEventCheckoutHandoffRestore(active: boolean): void;
+export declare function useEventCheckoutHandoffRestoreWithDeps(active: boolean, deps: CheckoutHandoffRestoreDeps): void;
+export {};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useEventRegistrationSubmit.d.ts

@@ -1,10 +1,9 @@
-import type { BlockApiClient } from '../../api';
 import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
-import { savePendingRegistration } from './sessionStorage';
-import type { EventTicketSelectionLine, FormData, Guest, RegistrationResult, RegistrationStep, PaymentSelection } from './types';
-import type { PaymentMethod } from '../../api/types';
-import type { EventRegistrationStatusReference } from '../../api/types';
+import type { BlockApiClient } from '../../api';
+import type { EventRegistrationStatusReference, PaymentMethod } from '../../api/types';
 import type { RegistrationTarget } from './registrationDerivations';
+import { savePendingRegistration } from './sessionStorage';
+import type { EventTicketSelectionLine, FormData, Guest, PaymentSelection, RegistrationResult, RegistrationStep } from './types';
 export type EventRegistrationSubmitOptions = Readonly<{
     redirect?: 'auto' | 'manual';
 }>;
@@ -24,6 +23,7 @@ export type EventRegistrationSubmitResult = Readonly<{
     reason: 'blocked' | 'missing-target' | 'submission-failed';
     message: string;
 }>;
+export type EventRegistrationSubmit = (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
 export type UseEventRegistrationSubmitInput = {
     api: BlockApiClient;
     registrationTarget: RegistrationTarget | null;
@@ -36,6 +36,7 @@ export type UseEventRegistrationSubmitInput = {
     guests: Guest[];
     discountCode: string;
     claimToken: string | null;
+    waitlistEntryId?: string | null;
     setPendingRegistrationReference: (reference: EventRegistrationStatusReference) => void;
     setStep: (step: RegistrationStep) => void;
     setErrorAction?: (action: EventRegistrationErrorAction) => void;
@@ -55,6 +56,6 @@ type ClientCommandIdCryptoSource = Readonly<{
     getRandomValues: (bytes: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBuffer>;
 }>;
 export declare function createClientCommandId(cryptoSource?: ClientCommandIdCryptoSource): string;
-export declare function useEventRegistrationSubmit(options: UseEventRegistrationSubmitInput): (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
-export declare function useEventRegistrationSubmitWithDeps(options: UseEventRegistrationSubmitInput, deps: EventRegistrationSubmitDeps): (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
+export declare function useEventRegistrationSubmit(options: UseEventRegistrationSubmitInput): EventRegistrationSubmit;
+export declare function useEventRegistrationSubmitWithDeps(options: UseEventRegistrationSubmitInput, deps: EventRegistrationSubmitDeps): EventRegistrationSubmit;
 export {};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useEventRegistrationWizard.d.ts

@@ -1,5 +1,4 @@
 import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
-import type { DiscountContext } from '../../api/types';
 import type { EventTicketSelectionLine, EventRegistrationClientProps, EligibilityData, FormData, Guest, GuestErrors, PaymentSelection, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult, RegistrationStep } from './types';
 import { usePortalAuth, useEligibility, useExistingEventRegistration } from './hooks';
 import { useWaitlistClaim } from '../../shared/useWaitlistClaim';
@@ -52,6 +51,8 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     scopedEvents: RegistrationEvent[];
     preSelectedEvent: RegistrationEvent | null;
     hasPreSelectedContext: boolean;
+    checkoutRecovery: boolean;
+    startCheckoutRecovery: () => void;
     step: RegistrationStep;
     setStep: (nextStep: RegistrationStep) => void;
     selectedEvent: RegistrationEvent | null;
@@ -79,7 +80,7 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     }> | null;
     slidingScaleSelectionMessage: string | null;
     selectedTicketType: import("../../..").EventRegistrationPricingOption | null;
-    ticketSelectionSummaryLines: {
+    ticketSelectionSummaryLines: readonly {
         pricingOptionId: string | null;
         label: string;
         quantity: number;
@@ -127,6 +128,8 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
         kind: "none";
     }> | Readonly<{
         kind: "booked";
+    }> | Readonly<{
+        kind: "pending_payment";
     }> | Readonly<{
         kind: "waitlisted";
     }>;
@@ -141,14 +144,14 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     manualCodeEntryAllowed: boolean;
     autoAppliedDiscount: import("../../api/types").AutoAppliedDiscountPreview | null;
     discountsAvailableLoading: boolean;
-    discountContext: DiscountContext | null;
+    discountContext: import("../../api").DiscountContext | null;
     shouldShowDiscountToggle: boolean;
     verification: import("./useEventRegistrationStripeReturn").EventRegistrationStripeReturnResult;
     handleDetailsComplete: () => Promise<EventRegistrationDetailsCompleteResult>;
     handlePaymentSelect: () => Promise<void>;
     handleUseCardInsteadOfPass: () => void;
     handleBookForSomeoneElse: () => void;
-    handleSubmit: (method: import("./PaymentSelectionStep").PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: import("./useEventRegistrationSubmit").EventRegistrationSubmitOptions) => Promise<import("./useEventRegistrationSubmit").EventRegistrationSubmitResult>;
+    handleSubmit: import("./useEventRegistrationSubmit").EventRegistrationSubmit;
     handleEventSelect: (event: RegistrationEvent) => void;
     handleRetry: () => void;
 };
@@ -174,6 +177,8 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     scopedEvents: RegistrationEvent[];
     preSelectedEvent: RegistrationEvent | null;
     hasPreSelectedContext: boolean;
+    checkoutRecovery: boolean;
+    startCheckoutRecovery: () => void;
     step: RegistrationStep;
     setStep: (nextStep: RegistrationStep) => void;
     selectedEvent: RegistrationEvent | null;
@@ -201,7 +206,7 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     }> | null;
     slidingScaleSelectionMessage: string | null;
     selectedTicketType: import("../../..").EventRegistrationPricingOption | null;
-    ticketSelectionSummaryLines: {
+    ticketSelectionSummaryLines: readonly {
         pricingOptionId: string | null;
         label: string;
         quantity: number;
@@ -249,6 +254,8 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
         kind: "none";
     }> | Readonly<{
         kind: "booked";
+    }> | Readonly<{
+        kind: "pending_payment";
     }> | Readonly<{
         kind: "waitlisted";
     }>;
@@ -263,14 +270,14 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     manualCodeEntryAllowed: boolean;
     autoAppliedDiscount: import("../../api/types").AutoAppliedDiscountPreview | null;
     discountsAvailableLoading: boolean;
-    discountContext: DiscountContext | null;
+    discountContext: import("../../api").DiscountContext | null;
     shouldShowDiscountToggle: boolean;
     verification: import("./useEventRegistrationStripeReturn").EventRegistrationStripeReturnResult;
     handleDetailsComplete: () => Promise<EventRegistrationDetailsCompleteResult>;
     handlePaymentSelect: () => Promise<void>;
     handleUseCardInsteadOfPass: () => void;
     handleBookForSomeoneElse: () => void;
-    handleSubmit: (method: import("./PaymentSelectionStep").PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: import("./useEventRegistrationSubmit").EventRegistrationSubmitOptions) => Promise<import("./useEventRegistrationSubmit").EventRegistrationSubmitResult>;
+    handleSubmit: import("./useEventRegistrationSubmit").EventRegistrationSubmit;
     handleEventSelect: (event: RegistrationEvent) => void;
     handleRetry: () => void;
 };

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useEventSourceRecovery.d.ts

@@ -0,0 +1,18 @@
+import { useBlockApi } from '../../api';
+import type { PublicEvent } from '../../../blocks/events/shared/types';
+import type { EventRegistrationEventSource } from './eventSourceRecovery';
+export type EventSourceRecovery = Readonly<{
+    kind: 'ready';
+    events: PublicEvent[];
+}> | Readonly<{
+    kind: 'loading';
+}> | Readonly<{
+    kind: 'exhausted';
+    retry: () => void;
+}>;
+type RecoveryDeps = Readonly<{
+    useApi: typeof useBlockApi;
+    wait: (milliseconds: number, signal: AbortSignal) => Promise<void>;
+}>;
+export declare function useEventSourceRecovery(source: EventRegistrationEventSource, deps?: RecoveryDeps): EventSourceRecovery;
+export {};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useSettledCommerceView.d.ts

@@ -0,0 +1,37 @@
+import type { BlockApiClient } from '../../api';
+import type { DiscountContext } from '../../api/types';
+import type { UseEligibilityResult } from './hooks';
+import type { EligibilityData, PaymentSelection, RegistrationEvent } from './types';
+import type { useDiscountCodeUi } from './useDiscountCodeUi';
+export declare function useSettledCommerceView(input: Readonly<{
+    api: BlockApiClient;
+    useDiscountCodeUi: typeof useDiscountCodeUi;
+    eligibilityResult: UseEligibilityResult;
+    eligibility: EligibilityData | null;
+    currentEvent: RegistrationEvent | null;
+    paymentSelection: PaymentSelection;
+    eventRequiresPayment: boolean;
+    ticketsCount: number;
+}>): {
+    discountUi: {
+        discountUiOpen: boolean;
+        setDiscountUiOpen: (isOpen: boolean) => void;
+        discountCode: string;
+        setDiscountCode: (code: string) => void;
+        discountsAvailable: boolean;
+        manualCodeEntryAllowed: boolean;
+        autoAppliedDiscount: import("../../api/types").AutoAppliedDiscountPreview | null;
+        discountsAvailableLoading: boolean;
+        discountAvailabilityRequestKey: string;
+        settledDiscountAvailabilityRequestKey: string | null;
+    };
+    discountContext: DiscountContext | null;
+    ticketSelectionSubtotalCents: number | null;
+    ticketSelectionSummaryLines: readonly {
+        pricingOptionId: string | null;
+        label: string;
+        quantity: number;
+        unitPriceCents: number;
+        subtotalCents: number;
+    }[];
+};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration.client.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import type { EventRegistrationClientProps as InternalEventRegistrationClientProps } from './event-registration/types';
-import type { EventRegistrationInteractiveIslandProps } from './event-registration.interactive';
+import { type EventRegistrationInteractiveIslandProps } from './event-registration.interactive';
 export type { PublicEvent, OccurrenceContext } from './event-registration/types';
 export type EventRegistrationClientProps = InternalEventRegistrationClientProps;
 export type EventRegistrationIslandClientProps = EventRegistrationInteractiveIslandProps;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration.interactive.d.ts

@@ -5,6 +5,7 @@ import type { OccurrenceContext } from '../../blocks/event-registration.shared';
 import type { EventRegistrationClientProps as InternalEventRegistrationClientProps } from './event-registration/types';
 import { type EventRegistrationPageSurfaceSubject } from './event-registration/eventScope';
 import { type InteractiveIslandProps } from '../../../contracts/islands';
+import { type EventRegistrationEventSource } from './event-registration/eventSourceRecovery';
 export declare const EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS: readonly ["Date", "Tickets", "Details"];
 declare const EVENT_REGISTRATION_SHELL_STEP_LABELS: readonly ["Event", "Date", "Tickets", "Details", "Payment"];
 export type EventRegistrationGenericShellStepLabels = typeof EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
@@ -19,6 +20,7 @@ export type EventRegistrationSourceProps = Readonly<{
     events?: PublicEvent[] | null;
     /** Runs for a whole-series page, loaded independently of the date page. */
     wholeSeriesRunEvents?: PublicEvent[] | null;
+    eventLoaderFailures?: Readonly<Record<string, unknown>> | null;
     className?: string | null;
     buttonText?: string | null;
     maxTickets?: string | null;
@@ -48,7 +50,9 @@ export type EventRegistrationDisplay = Readonly<{
     titleText: string;
     bodyText: string;
 }>;
-export type EventRegistrationHydration = Readonly<Omit<InternalEventRegistrationClientProps, 'siteId' | 'stage' | 'buttonText' | 'className'>>;
+export type EventRegistrationHydration = Readonly<Omit<InternalEventRegistrationClientProps, 'siteId' | 'stage' | 'buttonText' | 'className' | 'events'> & {
+    eventSource: EventRegistrationEventSource;
+}>;
 type EventRegistrationIslandMeta = Readonly<{
     siteId?: string;
     apiBaseUrl?: string;
@@ -56,6 +60,7 @@ type EventRegistrationIslandMeta = Readonly<{
     previewToken?: string | null;
     stage?: 'preview' | 'published';
 }>;
+export declare function buildEventRegistrationDisplayFromScopedEvents(source: EventRegistrationSourceProps, scopedSourceEvents: readonly PublicEvent[]): EventRegistrationDisplay;
 export type EventRegistrationInteractiveIslandProps = InteractiveIslandProps<EventRegistrationIslandMeta, 'event-registration', typeof eventRegistrationBlockRuntime>;
 export declare const eventRegistrationBlockRuntime: Readonly<{
     kind: "client-owned";
@@ -69,6 +74,7 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
         events?: PublicEvent[] | null;
         /** Runs for a whole-series page, loaded independently of the date page. */
         wholeSeriesRunEvents?: PublicEvent[] | null;
+        eventLoaderFailures?: Readonly<Record<string, unknown>> | null;
         className?: string | null;
         buttonText?: string | null;
         maxTickets?: string | null;
@@ -88,7 +94,9 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
         }> | null;
     }>) => Readonly<{
         display: EventRegistrationDisplay;
-        hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
+        hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "events" | "buttonText"> & {
+            eventSource: EventRegistrationEventSource;
+        }>;
     }>;
     contracts: Readonly<{
         source: Readonly<{
@@ -102,6 +110,7 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
                 events?: PublicEvent[] | null;
                 /** Runs for a whole-series page, loaded independently of the date page. */
                 wholeSeriesRunEvents?: PublicEvent[] | null;
+                eventLoaderFailures?: Readonly<Record<string, unknown>> | null;
                 className?: string | null;
                 buttonText?: string | null;
                 maxTickets?: string | null;
@@ -130,6 +139,7 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
                 events?: PublicEvent[] | null;
                 /** Runs for a whole-series page, loaded independently of the date page. */
                 wholeSeriesRunEvents?: PublicEvent[] | null;
+                eventLoaderFailures?: Readonly<Record<string, unknown>> | null;
                 className?: string | null;
                 buttonText?: string | null;
                 maxTickets?: string | null;
@@ -152,11 +162,15 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
         render: Readonly<{
             encode: (value: Readonly<{
                 display: EventRegistrationDisplay;
-                hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
+                hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "events" | "buttonText"> & {
+                    eventSource: EventRegistrationEventSource;
+                }>;
             }>) => unknown;
             decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                 display: EventRegistrationDisplay;
-                hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
+                hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "events" | "buttonText"> & {
+                    eventSource: EventRegistrationEventSource;
+                }>;
             }>>;
         }>;
     }>;
@@ -174,7 +188,9 @@ export declare const eventRegistrationInteractiveIslandPropsCodec: Readonly<{
             mode: "event-registration";
         } & Readonly<{
             display: EventRegistrationDisplay;
-            hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
+            hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "events" | "buttonText"> & {
+                eventSource: EventRegistrationEventSource;
+            }>;
         }>>;
     }>) => unknown;
     decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<Readonly<{
@@ -189,7 +205,9 @@ export declare const eventRegistrationInteractiveIslandPropsCodec: Readonly<{
             mode: "event-registration";
         } & Readonly<{
             display: EventRegistrationDisplay;
-            hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
+            hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "events" | "buttonText"> & {
+                eventSource: EventRegistrationEventSource;
+            }>;
         }>>;
     }>>;
 }>;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration.server.d.ts

@@ -1,13 +1,15 @@
 import React from 'react';
 import { type EventRegistrationSourceProps } from './event-registration.interactive';
-type EventRegistrationProps = Omit<EventRegistrationSourceProps, 'subject'> & Readonly<{
+import type { BlockLoaderFailures } from '../../data/types';
+type EventRegistrationProps = Omit<EventRegistrationSourceProps, 'subject' | 'eventLoaderFailures'> & Readonly<{
     blockId?: string | null;
     children?: React.ReactNode;
     subject?: unknown;
+    loaderFailures?: BlockLoaderFailures | null;
 }>;
 /**
  * Server-safe placeholder for event registration.
  * Provides a static container for island hydration without importing client hooks.
  */
-export declare function EventRegistrationSSR({ blockId, subject, children, ...sourceProps }: EventRegistrationProps): React.JSX.Element;
+export declare function EventRegistrationSSR({ blockId, subject, loaderFailures, children, ...sourceProps }: EventRegistrationProps): React.JSX.Element;
 export default EventRegistrationSSR;