@riverbankcms/sdk 0.141.0 → 0.143.0

package/dist/_dts/blocks/src/system/runtime/api/types/events.d.ts

@@ -101,6 +101,12 @@ export interface EventRegisterRequest {
      * server can replay a lost response instead of registering twice.
      */
     registrationCommandId: string;
+    checkout?: {
+        successUrl: string;
+        cancelUrl: string;
+        discountCode?: string;
+        collectionOptionKind?: DirectCheckoutCollectionOptionKind;
+    };
     subject: {
         kind: 'occurrence';
         occurrenceId: string;
@@ -129,44 +135,54 @@ export interface EventRegisterRequest {
     /** Guest details when "collect all attendee details" is enabled */
     guests?: EventRegisterGuest[];
 }
-export type EventRegisterResponse = {
-    success: boolean;
+export type EventRegistrationPaymentSubject = {
     scope: 'occurrence';
+    submissionId: string;
     attendeeId: string;
-    status: 'confirmed';
+} | {
+    scope: 'wholeSeries';
+    submissionId: string;
+};
+export type EventRegistrationSummary = {
     paymentMethod: PaymentMethod;
-    pendingPayment: boolean;
+    ticketLines?: readonly EventTicketLineSummary[];
+    message: string;
     passCreditsUsed?: number;
     passCreditsRemaining?: number;
-    alreadyRegistered?: boolean;
-    ticketLines: EventTicketLineSummary[];
-    message?: string;
+};
+export type EventRegisterResponse = {
+    kind: 'bookingComplete';
+    reference: EventRegistrationStatusReference;
+    summary: EventRegistrationSummary;
 } | {
-    success: boolean;
-    scope: 'occurrence';
-    attendeeId: string;
-    status: 'waitlist';
-    waitlistPosition: number | null;
-    alreadyRegistered?: boolean;
-    message?: string;
+    kind: 'paymentDeferred';
+    reference: EventRegistrationStatusReference;
+    summary: EventRegistrationSummary;
+    balance: {
+        amountCents: number;
+        currency: string;
+    };
 } | {
-    success: boolean;
-    scope: 'wholeSeries';
-    registrationId: string;
-    status: 'confirmed';
-    paymentMethod: 'free' | 'membership';
-    pendingPayment: false;
-    alreadyRegistered?: boolean;
-    ticketLines: EventTicketLineSummary[];
-    message?: string;
+    kind: 'checkoutRequired';
+    reference: EventRegistrationStatusReference;
+    checkoutUrl: string;
+    submissionId: string;
 } | {
-    success: boolean;
-    scope: 'wholeSeries';
-    waitlistEntryId: string;
-    status: 'waitlist';
-    waitlistPosition: number | null;
-    alreadyRegistered?: boolean;
-    message?: string;
+    kind: 'paymentStatusRequired';
+    subject: EventRegistrationPaymentSubject;
+} | {
+    kind: 'waitlisted';
+    waitlist: {
+        reference: {
+            scope: 'occurrence';
+            attendeeId: string;
+        } | {
+            scope: 'occurrence' | 'wholeSeries';
+            waitlistEntryId: string;
+        };
+        position: number | null;
+        message: string;
+    };
 };
 /** Type of checkout for event payment */
 export type EventCheckoutType = 'event' | 'pass_bundle' | 'membership_bundle';
@@ -182,7 +198,7 @@ export type EventCheckoutRequest = EventCheckoutRequestCommon & ({
         kind: 'occurrence';
         attendeeId: string;
     };
-    registrationCommandId?: string;
+    registrationCommandId: string;
     checkoutType?: EventCheckoutType;
     productId?: string;
 } | {
@@ -204,26 +220,36 @@ export type EventCheckoutRequest = EventCheckoutRequestCommon & ({
     waitlistEntryId?: string;
     checkoutAttemptId: string;
 });
-export type EventCheckoutResponse = {
+type OccurrenceCheckoutResponse = Readonly<{
     scope: 'occurrence';
     attendeeId: string;
     checkoutUrl: string | null;
     sessionId: string | null;
     bypassed: boolean;
-} | {
+}>;
+type WholeSeriesCheckoutResponse = Readonly<{
     scope: 'wholeSeries';
     registrationId: string;
     checkoutAttemptId: string;
+    recoverableUntil?: string;
     checkoutUrl: string | null;
     sessionId: string | null;
     bypassed: boolean;
-} | {
+}>;
+type WholeSeriesPaymentStatusRequired = Readonly<{
+    scope: 'wholeSeries';
+    status: 'paymentStatusRequired';
+    checkoutAttemptId: string;
+    recoverableUntil: string;
+}>;
+type WholeSeriesWaitlistResponse = Readonly<{
     scope: 'wholeSeries';
     status: 'waitlist';
     waitlistEntryId: string;
     waitlistPosition: number | null;
     alreadyRegistered?: boolean;
-};
+}>;
+export type EventCheckoutResponse = OccurrenceCheckoutResponse | WholeSeriesCheckoutResponse | WholeSeriesPaymentStatusRequired | WholeSeriesWaitlistResponse;
 export interface EligiblePass {
     customerPassId: string;
     passName: string;
@@ -255,6 +281,19 @@ export type RegistrationOptionsRequest = EventRegistrationOptionsRequest & {
     siteId: string;
 };
 export type RegistrationOptionsResponse = EventRegistrationOptionsResponse;
+export type EventRegistrationNextStepRequest = EventRegistrationOptionsRequest & {
+    email: string;
+    altchaSolution?: string | null;
+};
+/** Navigation only; the booking submission remains authoritative for admission. */
+export type EventRegistrationNextStepResponse = {
+    kind: 'continue';
+} | {
+    kind: 'waitlist';
+} | {
+    kind: 'unavailable';
+    message: string;
+};
 /** Payment status values returned by the backend */
 export type PaymentStatus = 'pending' | 'completed' | 'failed' | 'not_required' | 'refunded';
 /** Attendee status values returned by the backend */
@@ -282,15 +321,36 @@ export type EventCheckoutReturnRequest = {
 } | {
     kind: 'abandon';
     checkoutAttemptId: string;
+} | {
+    kind: 'checkStatus';
+    subject: EventRegistrationPaymentSubject;
 };
 export type EventCheckoutReturnResponse = {
     kind: 'resolved';
     reference: EventRegistrationStatusReference;
+    deferredBalance?: {
+        amountCents: number;
+        currency: string;
+    };
 } | {
     kind: 'abandoned';
 } | {
     kind: 'notFound';
 } | {
     kind: 'reconciliationRequired';
+} | {
+    kind: 'paymentProcessing';
+    recoverableUntil?: string;
+} | {
+    kind: 'paymentAvailable';
+    checkoutUrl: string;
+    recoverableUntil?: string;
+} | {
+    kind: 'paymentRetryAvailable';
+} | {
+    kind: 'paymentCheckUnavailable';
+    recoverableUntil?: string;
+} | {
+    kind: 'paymentAssistanceRequired';
 };
 export {};

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

@@ -0,0 +1,10 @@
+import type { PaymentStatusRecoveryState } from './types';
+type PaymentStatusStepProps = Readonly<{
+    state: PaymentStatusRecoveryState;
+    onCheck: () => void;
+    onContinuePayment: () => void;
+    onReturnToPayment: () => void;
+    onReturnToBooking: () => void;
+}>;
+export declare function PaymentStatusStep(props: PaymentStatusStepProps): import("react").JSX.Element;
+export {};

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

@@ -10,8 +10,6 @@ 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/event-registration.headless.contract.d.ts

@@ -2,7 +2,7 @@ import type { DirectCheckoutCollectionOptionKind, PaymentMethod } from '../../ap
 import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
 import type { EventRegistrationDirectPaymentOption, EventRegistrationDirectPaymentSelectionState } from './eventPaymentOptions';
 import type { EventRegistrationPageSurfaceSubject } from './eventScope';
-import type { EligibilityData, EventTicketSelectionLine, FormData, Guest, GuestErrors, OccurrenceContext, PaymentSelection, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult } from './types';
+import type { EligibilityData, EventTicketSelectionLine, FormData, Guest, GuestErrors, OccurrenceContext, PaymentSelection, PaymentStatusRecoveryState, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult } from './types';
 import type { SelectableEventTicketType } from './utils';
 import type { BlockButtonRole } from '../../../constants/buttonRoles';
 import type { PortalAuthState, PortalProfile } from './hooks';
@@ -44,6 +44,9 @@ export type EventRegistrationFlowStatus = Readonly<{
     tag: 'verifying-payment';
 }> | Readonly<{
     tag: 'verifying-timeout';
+}> | Readonly<{
+    tag: 'payment-status';
+    state: PaymentStatusRecoveryState;
 }> | Readonly<{
     tag: 'payment-failed';
     message: string;
@@ -66,6 +69,9 @@ export type EventRegistrationFlowView = Readonly<{
 }> | Readonly<{
     kind: 'verifying';
     message: string;
+}> | Readonly<{
+    kind: 'payment-status';
+    state: PaymentStatusRecoveryState;
 }> | Readonly<{
     kind: 'success';
     result: RegistrationResult;
@@ -191,6 +197,7 @@ export type EventRegistrationTerminalModel = Readonly<{
     result: RegistrationResult | null;
     errorMessage: string;
     verification: UseEventRegistrationWizardResult['verification'];
+    paymentStatusRecovery: PaymentStatusRecoveryState | null;
 }>;
 export type EventRegistrationFlowActions = Readonly<{
     selectEvent: (event: RegistrationEvent) => void;
@@ -210,6 +217,10 @@ export type EventRegistrationFlowActions = Readonly<{
     back: () => void;
     submit: (options?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
     retry: () => void;
+    checkPaymentStatus: () => void;
+    continueExistingPayment: () => void;
+    returnToPayment: () => void;
+    returnToBooking: () => void;
 }>;
 export type HeadlessEventRegistrationFlow = Readonly<{
     status: EventRegistrationFlowStatus;

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

@@ -10,8 +10,8 @@ export declare function resolveEventRegistrationSubmitPlan(input: Readonly<{
     eventRequiresPayment: boolean;
     canJoinWaitlist?: boolean | null;
 }>): EventRegistrationSubmitPlan;
-export declare function resolveHeadlessEventRegistrationStatus(wizard: Pick<UseEventRegistrationWizardResult, 'step' | 'registrationResult' | 'errorMessage'> & Partial<Pick<UseEventRegistrationWizardResult, 'errorAction'>>): EventRegistrationFlowStatus;
-export declare function resolveHeadlessEventRegistrationView(wizard: Readonly<Pick<UseEventRegistrationWizardResult, 'step' | 'scopedEvents' | 'occurrenceContext' | 'registrationResult' | 'errorMessage'> & {
+export declare function resolveHeadlessEventRegistrationStatus(wizard: Pick<UseEventRegistrationWizardResult, 'step' | 'registrationResult' | 'errorMessage'> & Partial<Pick<UseEventRegistrationWizardResult, 'errorAction' | 'paymentStatusRecovery'>>): EventRegistrationFlowStatus;
+export declare function resolveHeadlessEventRegistrationView(wizard: Readonly<Pick<UseEventRegistrationWizardResult, 'step' | 'scopedEvents' | 'occurrenceContext' | 'registrationResult' | 'errorMessage'> & Partial<Pick<UseEventRegistrationWizardResult, 'paymentStatusRecovery'>> & {
     api: Pick<UseEventRegistrationWizardResult['api'], 'config'>;
 }>): EventRegistrationFlowView;
 export declare function deriveEventRegistrationSteps(input: Readonly<{

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

@@ -1,4 +1,5 @@
 import type { EligibilityData } from './types';
+export declare function isSelectionSoldOut(availability: EligibilityData['availability'] | undefined): boolean;
 export declare function resolveRegistrationAvailabilityBlocker(input: Readonly<{
     hasWaitlistClaim: boolean;
     eligibility: EligibilityData | null;
@@ -9,7 +10,3 @@ export declare function resolvePricingSelectionBlocker(input: Readonly<{
     hasValidSelection: boolean;
     slidingScaleSelectionMessage: string | null;
 }>): string | null;
-export declare function isSoldOutWithoutWaitlist(input: Readonly<{
-    hasWaitlistClaim: boolean;
-    eligibility: EligibilityData | null;
-}>): boolean;

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

@@ -4,6 +4,18 @@ export type RegistrationTarget = Readonly<{
     subject: RegistrationSubject;
     selectedEventId: string | null;
 }>;
+/** Public requests share subject identity without copying the run's display sessions. */
+export declare function toRegistrationRequestSubject(subject: RegistrationSubject, attendanceMode: 'in_person' | 'online' | null | undefined): {
+    kind: "occurrence";
+    occurrenceId: string;
+    attendanceMode: "in_person" | "online" | undefined;
+    eventSeriesId?: undefined;
+} | {
+    kind: "wholeSeries";
+    eventSeriesId: string;
+    attendanceMode: "in_person" | "online" | undefined;
+    occurrenceId?: undefined;
+};
 export declare function eventMatchesOccurrenceId(event: Pick<RegistrationEvent, 'selectionId' | 'registrationSubject'>, occurrenceId: string): boolean;
 export declare function findEventByOccurrenceId(events: readonly RegistrationEvent[], occurrenceId: string): RegistrationEvent | null;
 export declare function findPreSelectedEvent(input: Readonly<{

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

@@ -15,7 +15,7 @@ export declare function resetRegistrationAfterExpiry(input: Readonly<{
     setErrorMessage: (message: string) => void;
     setPendingRegistrationReference: (reference: EventRegistrationStatusReference | null) => void;
 }>): void;
-/** Recovery never starts another payment. Unknown payment outcomes go to the portal. */
+/** Retry the retained submission in place; explicit payment uncertainty stays status-only. */
 export declare function recoverRegistrationError(action: EventRegistrationErrorAction, handlers: Readonly<{
     canJoinWaitlist?: boolean;
     refreshOptions: () => void;

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

@@ -17,6 +17,7 @@ type PendingRegistrationV5 = {
     formData: FormData;
     ticketSelections: EventTicketSelectionLine[];
     selectedEventId: string | null;
+    eventSeriesId?: string | null;
     selectedAttendanceMode?: 'in_person' | 'online' | null;
     paymentSelection: PaymentSelection & {
         method: Exclude<PaymentSelection['method'], null>;

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

@@ -1,4 +1,7 @@
 import type { EventTicketSelectionLine } from './types';
+import type { PublicEventPricingOptionAvailability } from '../../../../../../core/src/index';
+/** Ticket selection requests a quote; only the server admits a booking. */
+export declare function canRequestTicketOption(availability: PublicEventPricingOptionAvailability): boolean;
 export declare function normalizeTicketSelectionLines(lines: readonly EventTicketSelectionLine[]): EventTicketSelectionLine[];
 export declare function getTicketSelectionTotal(lines: readonly EventTicketSelectionLine[]): number;
 export declare function getTicketLineQuantity(lines: readonly EventTicketSelectionLine[], pricingOptionId: string | null): number;
@@ -8,9 +11,7 @@ export declare function hasValidPricingOptionSelection(input: Readonly<{
     lines: readonly EventTicketSelectionLine[];
     visibleOptions: readonly Readonly<{
         pricingOptionId: string;
-        availability: Readonly<{
-            kind: 'available' | 'unavailable';
-        }>;
+        availability: PublicEventPricingOptionAvailability;
     }>[];
 }>): boolean;
 export declare function setTicketLineQuantity(input: Readonly<{
@@ -22,8 +23,6 @@ export declare function getTicketTypeLineMax(input: Readonly<{
     currentQuantity: number;
     totalSelectedQuantity: number;
     maxTickets: number;
-    availableSpots: number | null | undefined;
-    ticketTypeRemainingCapacity: number | null;
 }>): number;
 export type TicketSelectionSummaryLine = Readonly<{
     pricingOptionId: string | null;

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

@@ -24,7 +24,7 @@ export type GuestErrors = Record<number, {
     /** Error message for name field */
     name?: string;
 }>;
-export type RegistrationStep = 'select-event' | 'select-tickets' | 'enter-details' | 'select-payment' | 'submitting' | 'redirecting' | 'verifying-payment' | 'verifying-timeout' | 'payment-failed' | 'success' | 'error';
+export type RegistrationStep = 'select-event' | 'select-tickets' | 'enter-details' | 'select-payment' | 'submitting' | 'redirecting' | 'verifying-payment' | 'verifying-timeout' | 'payment-status' | 'payment-failed' | 'success' | 'error';
 export type RegistrationResult = {
     status: 'confirmed' | 'waitlist';
     /**
@@ -35,6 +35,14 @@ export type RegistrationResult = {
     message?: string;
     variant?: 'success' | 'info';
 };
+export type PaymentStatusRecoveryState = Readonly<{
+    subject: import('../../api/types').EventRegistrationPaymentSubject;
+}> & (Readonly<{
+    kind: 'ready' | 'checking' | 'processing' | 'temporarilyUnavailable' | 'retryAvailable' | 'assistanceRequired';
+}> | Readonly<{
+    kind: 'paymentAvailable';
+    checkoutUrl: string;
+}>);
 export type RegistrationAttendanceMode = 'in_person' | 'online';
 export type EventTicketSelectionLine = Readonly<{
     pricingOptionId: string | null;
@@ -55,8 +63,6 @@ export type EligibilityData = {
     isFree: boolean;
     /** Site credit for the authenticated registration subject, if available. */
     credit?: import('../../api').PortalCredit | null;
-    /** Whether the user has any payment/registration options available */
-    eligible: boolean;
     /** Whether the selected event/ticket type currently requires payment. */
     requiresPayment: boolean;
     /** Persisted pricing mode for the underlying event series. */
@@ -69,12 +75,6 @@ export type EligibilityData = {
     ticketLines: EventTicketLineSummary[];
     /** Public ticket types available for selection in ticket-type mode. */
     ticketTypes: readonly EventRegistrationPricingOption[];
-    /** Whether the event is currently full for the requested ticket count */
-    isFull: boolean;
-    /** Whether waitlists are enabled for this event */
-    waitlistEnabled: boolean;
-    /** Whether this registration can join the waitlist instead of paying */
-    canJoinWaitlist: boolean;
     /** Event price in cents (null if free) */
     price: number | null;
     /** Price currency code */
@@ -94,8 +94,6 @@ export type EligibilityData = {
         id: string;
         membershipName: string;
     }>;
-    /** Whether the event accepts direct payment */
-    canPayDirectly: boolean;
     /** Whether the event accepts passes */
     eventAcceptsPasses: boolean;
     /** Whether the event accepts memberships */

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

@@ -1,9 +1,9 @@
 import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
 import type { BlockApiClient } from '../../api';
 import type { EventRegistrationStatusReference, PaymentMethod } from '../../api/types';
-import type { RegistrationTarget } from './registrationDerivations';
+import { type RegistrationTarget } from './registrationDerivations';
 import { savePendingRegistration } from './sessionStorage';
-import type { EventTicketSelectionLine, FormData, Guest, PaymentSelection, RegistrationResult, RegistrationStep } from './types';
+import type { EventTicketSelectionLine, FormData, Guest, PaymentSelection, PaymentStatusRecoveryState, RegistrationResult, RegistrationStep } from './types';
 export type EventRegistrationSubmitOptions = Readonly<{
     redirect?: 'auto' | 'manual';
 }>;
@@ -12,6 +12,11 @@ export type EventRegistrationSubmitResult = Readonly<{
     outcome: {
         kind: 'completed';
     };
+}> | Readonly<{
+    ok: true;
+    outcome: {
+        kind: 'payment_status';
+    };
 }> | Readonly<{
     ok: true;
     outcome: {
@@ -25,6 +30,7 @@ export type EventRegistrationSubmitResult = Readonly<{
 }>;
 export type EventRegistrationSubmit = (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
 export type UseEventRegistrationSubmitInput = {
+    commandRef: EventRegistrationCommandRef;
     api: BlockApiClient;
     registrationTarget: RegistrationTarget | null;
     selectedAttendanceMode: 'in_person' | 'online' | null;
@@ -42,6 +48,14 @@ export type UseEventRegistrationSubmitInput = {
     setErrorAction?: (action: EventRegistrationErrorAction) => void;
     setRegistrationResult: (result: RegistrationResult) => void;
     setErrorMessage: (message: string) => void;
+    setPaymentStatusRecovery: (state: PaymentStatusRecoveryState | null) => void;
+};
+/** Shared only with explicit start-again actions; uncertainty alone retains identity. */
+export type EventRegistrationCommandRef = {
+    current: Readonly<{
+        id: string;
+        intentKey: string;
+    }> | null;
 };
 export type EventRegistrationSubmitDeps = Readonly<{
     savePendingRegistration: typeof savePendingRegistration;
@@ -57,5 +71,45 @@ type ClientCommandIdCryptoSource = Readonly<{
 }>;
 export declare function createClientCommandId(cryptoSource?: ClientCommandIdCryptoSource): string;
 export declare function useEventRegistrationSubmit(options: UseEventRegistrationSubmitInput): EventRegistrationSubmit;
+/**
+ * Describe a completed registration to the success step.
+ *
+ * Only pass redemptions adopt the server's message: it names the credits spent
+ * and the balance left, which the block's copy cannot. Every other method keeps
+ * whatever success message the site configured.
+ */
 export declare function useEventRegistrationSubmitWithDeps(options: UseEventRegistrationSubmitInput, deps: EventRegistrationSubmitDeps): EventRegistrationSubmit;
+type SelectionSnapshot = Exclude<PaymentSelection, Readonly<{
+    method: null;
+}>>;
+/**
+ * Freeze everything this submission is about to send, including the command
+ * identity the server keys the commit on.
+ */
+declare function prepareSubmitContext(options: UseEventRegistrationSubmitInput, registrationCommandId: string, target: RegistrationTarget, method: PaymentMethod, passId: string | undefined, membershipId: string | undefined, selection: PaymentSelection | undefined): {
+    registrationCommandId: string;
+    ticketSelections: Readonly<{
+        pricingOptionId: string | null;
+        quantity: number;
+    }>[];
+    bundleProductId: string | undefined;
+    selectionSnapshot: SelectionSnapshot;
+    guestsPayload: {
+        name: string;
+        email: string | undefined;
+        phone: string | undefined;
+    }[] | undefined;
+    subject: {
+        kind: "occurrence";
+        occurrenceId: string;
+        attendanceMode: "in_person" | "online" | undefined;
+        eventSeriesId?: undefined;
+    } | {
+        kind: "wholeSeries";
+        eventSeriesId: string;
+        attendanceMode: "in_person" | "online" | undefined;
+        occurrenceId?: undefined;
+    };
+};
+export type PreparedSubmit = ReturnType<typeof prepareSubmitContext>;
 export {};

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

@@ -51,8 +51,6 @@ 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;
@@ -147,6 +145,11 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     discountContext: import("../../api").DiscountContext | null;
     shouldShowDiscountToggle: boolean;
     verification: import("./useEventRegistrationStripeReturn").EventRegistrationStripeReturnResult;
+    paymentStatusRecovery: import("./types").PaymentStatusRecoveryState | null;
+    handleCheckPaymentStatus: () => void;
+    handleContinueExistingPayment: () => void;
+    handleReturnToPayment: () => void;
+    handleReturnToBooking: () => void;
     handleDetailsComplete: () => Promise<EventRegistrationDetailsCompleteResult>;
     handlePaymentSelect: () => Promise<void>;
     handleUseCardInsteadOfPass: () => void;
@@ -177,8 +180,6 @@ 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;
@@ -273,6 +274,11 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     discountContext: import("../../api").DiscountContext | null;
     shouldShowDiscountToggle: boolean;
     verification: import("./useEventRegistrationStripeReturn").EventRegistrationStripeReturnResult;
+    paymentStatusRecovery: import("./types").PaymentStatusRecoveryState | null;
+    handleCheckPaymentStatus: () => void;
+    handleContinueExistingPayment: () => void;
+    handleReturnToPayment: () => void;
+    handleReturnToBooking: () => void;
     handleDetailsComplete: () => Promise<EventRegistrationDetailsCompleteResult>;
     handlePaymentSelect: () => Promise<void>;
     handleUseCardInsteadOfPass: () => void;

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

@@ -0,0 +1,23 @@
+import { type Dispatch, type SetStateAction } from 'react';
+import type { BlockApiClient } from '../../api/client';
+import type { EventRegistrationStatusReference } from '../../api/types';
+import type { PaymentStatusRecoveryState, RegistrationResult, RegistrationStep } from './types';
+type PaymentStatusSetters = Readonly<{
+    setPendingRegistrationReference: Dispatch<SetStateAction<EventRegistrationStatusReference | null>>;
+    setRegistrationResult: Dispatch<SetStateAction<RegistrationResult | null>>;
+    setOptionsRefreshKey: Dispatch<SetStateAction<number>>;
+    setStep: (step: RegistrationStep) => void;
+}>;
+type UsePaymentStatusRecoveryOptions = PaymentStatusSetters & Readonly<{
+    api: BlockApiClient;
+    beginNewSubmission: () => void;
+}>;
+export declare function usePaymentStatusRecovery(options: UsePaymentStatusRecoveryOptions): {
+    recovery: PaymentStatusRecoveryState | null;
+    showRecovery: (next: PaymentStatusRecoveryState | null) => void;
+    check: () => void;
+    continuePayment: () => void;
+    returnToPayment: () => void;
+    returnToBooking: () => void;
+};
+export {};

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

@@ -59,7 +59,7 @@ export declare function getVisibleTicketTypes(input: {
     eligibility: EligibilityData | null;
     selectedAttendanceMode?: 'in_person' | 'online' | null;
 }): SelectableEventTicketType[];
-export declare function getImplicitSingleAvailableTicketType(ticketTypes: readonly SelectableEventTicketType[]): SelectableEventTicketType | null;
+export declare function getImplicitSingleTicketType(ticketTypes: readonly SelectableEventTicketType[]): SelectableEventTicketType | null;
 export declare function findSelectedTicketType(input: {
     event: TicketTypeSourceEvent | null;
     eligibility: EligibilityData | null;