@riverbankcms/sdk 0.148.0 → 0.150.0

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

@@ -2,13 +2,13 @@ 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, PaymentStatusRecoveryState, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult } from './types';
+import type { EligibilityData, EventTicketSelectionLine, FormData, Guest, GuestErrors, OccurrenceContext, EventPaymentState, 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';
 import type { UseWaitlistClaimResult } from '../../shared/useWaitlistClaim';
 import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
-import type { EventRegistrationSubmitOptions, EventRegistrationSubmitResult } from './useEventRegistrationSubmit';
+import type { EventRegistrationSubmitResult } from './useEventRegistrationSubmit';
 export declare const DEFAULT_EVENT_REGISTRATION_MAX_TICKETS = 5;
 export type EventRegistrationLoadState<T> = Readonly<{
     tag: 'idle';
@@ -39,7 +39,7 @@ export type EventRegistrationFlowStatus = Readonly<{
 }> | Readonly<{
     tag: 'submitting';
 }> | Readonly<{
-    tag: 'redirecting';
+    tag: 'payment';
 }> | Readonly<{
     tag: 'verifying-payment';
 }> | Readonly<{
@@ -66,6 +66,10 @@ export type EventRegistrationFlowView = Readonly<{
     message: string;
 }> | Readonly<{
     kind: 'form';
+}> | Readonly<{
+    kind: 'fully-booked';
+    recovery: 'byEmail' | 'none';
+    recoveryMessage: string | null;
 }> | Readonly<{
     kind: 'verifying';
     message: string;
@@ -79,7 +83,7 @@ export type EventRegistrationFlowView = Readonly<{
     kind: 'error';
     message: string;
 }>;
-export type EventRegistrationFlowStepId = 'select-event' | 'select-tickets' | 'enter-details' | 'select-payment';
+export type EventRegistrationFlowStepId = 'select-event' | 'select-tickets' | 'enter-details' | 'select-payment' | 'payment';
 export type EventRegistrationFlowStepState = 'complete' | 'active' | 'available' | 'blocked';
 export type EventRegistrationFlowStep = Readonly<{
     id: EventRegistrationFlowStepId;
@@ -161,12 +165,14 @@ export type EventRegistrationPaymentModel = Readonly<{
     selection: EventRegistrationPaymentSelection;
     directPaymentOptions: readonly EventRegistrationDirectPaymentOption[];
     directPaymentSelectionState: EventRegistrationDirectPaymentSelectionState;
+    checkout: EventPaymentState;
     stepState: PaymentStepState;
 }> | Readonly<{
     kind: 'loading' | 'error' | 'not-eligible' | 'ready';
     selection: EventRegistrationPaymentSelection;
     directPaymentOptions: readonly EventRegistrationDirectPaymentOption[];
     directPaymentSelectionState: EventRegistrationDirectPaymentSelectionState;
+    checkout: EventPaymentState;
     stepState: PaymentStepState;
     eligibility: EligibilityData | null;
     eligibilityError: string | null | undefined;
@@ -218,8 +224,12 @@ export type EventRegistrationFlowActions = Readonly<{
     logout: () => void;
     next: () => Promise<EventRegistrationFlowActionResult>;
     back: () => void;
-    submit: (options?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
+    submit: () => Promise<EventRegistrationSubmitResult>;
     retry: () => void;
+    checkPayment: () => void;
+    completePayment: () => void;
+    retryPaymentLoad: () => void;
+    backToBooking: () => Promise<void>;
     checkPaymentStatus: () => void;
     continueExistingPayment: () => void;
     returnToPayment: () => void;

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

@@ -11,12 +11,14 @@ export declare function resolveEventRegistrationSubmitPlan(input: Readonly<{
     canJoinWaitlist?: boolean | null;
 }>): EventRegistrationSubmitPlan;
 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'>> & {
+type RegistrationViewInput = Readonly<Pick<UseEventRegistrationWizardResult, 'step' | 'scopedEvents' | 'occurrenceContext' | 'registrationResult' | 'errorMessage' | 'paymentStatusRecovery' | 'admission' | 'recoveryMessage'> & {
     api: Pick<UseEventRegistrationWizardResult['api'], 'config'>;
-}>): EventRegistrationFlowView;
+}>;
+export declare function resolveHeadlessEventRegistrationView(wizard: RegistrationViewInput): EventRegistrationFlowView;
 export declare function deriveEventRegistrationSteps(input: Readonly<{
     step: RegistrationStep;
     hasPreSelectedContext: boolean;
     eventRequiresPayment: boolean;
     paymentSelection: PaymentSelection;
 }>): readonly EventRegistrationFlowStep[];
+export {};

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

@@ -3,9 +3,7 @@ import type { BlockBookingPaymentCollectionOption, BlockBookingPaymentTerms } fr
 import type { EventRegistrationAvailablePaymentOption } from '../../../blocks/event-registration';
 import { type BookingPaymentOptionViewModel } from '../../shared/bookingPaymentOptions';
 import type { PaymentSelection } from './types';
-type EventDirectPaymentOption = Extract<BlockBookingPaymentCollectionOption, {
-    kind: 'upfront' | 'deferred_manual' | 'instalment_plan' | 'flexible_balance';
-}>;
+type EventDirectPaymentOption = BlockBookingPaymentCollectionOption;
 export declare function getApprovedDirectPaymentCollectionOptionKinds(paymentOptions: readonly EventRegistrationAvailablePaymentOption[]): readonly DirectCheckoutCollectionOptionKind[];
 export type EventRegistrationDirectPaymentOption = Omit<BookingPaymentOptionViewModel, 'kind' | 'title'> & Readonly<{
     kind: Extract<DirectCheckoutCollectionOptionKind, EventDirectPaymentOption['kind']>;
@@ -40,6 +38,8 @@ export declare function buildEventRegistrationPaymentOptionsViewModel(input: Rea
     totalPriceCents: number;
     currency: string;
     startsAt?: string | null;
+    /** When the registration is being made; instalment schedules start here. */
+    nowIso: string;
     locale?: string;
 }>): EventRegistrationPaymentOptionsViewModel;
 export declare function resolveEventRegistrationDirectPaymentSelection(input: Readonly<{

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

@@ -0,0 +1,3 @@
+export declare function eventPaymentReturnUrl(submissionId: string): string;
+export declare function rememberEventPayment(submissionId: string, sessionId: string): void;
+export declare function clearEventPayment(siteId: string | undefined): void;

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

@@ -0,0 +1,72 @@
+import type { EventCheckoutReturnResponse, EventEmbeddedCheckout, EventRegistrationPaymentSubject } from '../../api/types';
+import type { PaymentStatusRecoveryState } from './types';
+type PaymentResponseIntent = 'resume' | 'check' | 'abandon';
+export type PaymentResponseTransition = {
+    kind: 'confirmed';
+} | {
+    kind: 'restartBooking';
+} | {
+    kind: 'unresolved';
+} | {
+    kind: 'payment';
+    checkout: EventEmbeddedCheckout;
+    subject: EventRegistrationPaymentSubject;
+} | {
+    kind: 'recovery';
+    state: PaymentStatusRecoveryState;
+};
+/**
+ * Verified response identity owns every follow-up action, including storage-free returns.
+ * `requested` is the subject the client sent, if any: a subject-bound `notFound`
+ * means the server lost that booking, which no amount of re-checking will fix.
+ */
+export declare function planPaymentResponse(response: EventCheckoutReturnResponse, intent: PaymentResponseIntent, requested: EventRegistrationPaymentSubject | null): PaymentResponseTransition;
+type CheckoutEnvelope = Extract<EventCheckoutReturnResponse, {
+    kind: 'checkout';
+}>;
+/** A mounted-form check that never reached the server. */
+export type PaymentCheckUnreachable = Readonly<{
+    kind: 'unreachable';
+}>;
+export type PaymentCheckResult = EventCheckoutReturnResponse | PaymentCheckUnreachable;
+/**
+ * What a check result proves, before deciding what the customer sees.
+ * `inconclusive` means the server could not look; `bindingLost` means it looked
+ * and the booking association is gone. Confusing the two either strands a
+ * customer mid-authentication or lets them pay for a booking we can't find.
+ */
+export type PaymentCheckEvidence = Readonly<{
+    kind: 'inconclusive';
+}> | Readonly<{
+    kind: 'bindingLost';
+}> | Readonly<{
+    kind: 'paymentUnderway';
+}> | Readonly<{
+    kind: 'payable';
+    checkout: EventEmbeddedCheckout;
+    response: CheckoutEnvelope;
+}> | Readonly<{
+    kind: 'terminal';
+    response: CheckoutEnvelope;
+}>;
+export declare function paymentCheckEvidence(result: PaymentCheckResult): PaymentCheckEvidence;
+/**
+ * What a background check may do to a customer looking at a live Stripe form.
+ * Only conclusive evidence moves them; inconclusive evidence keeps the form,
+ * since unmounting it can interrupt an authentication already in progress.
+ */
+export type MountedPaymentRefresh = Readonly<{
+    kind: 'stay';
+}> | Readonly<{
+    kind: 'poll';
+}> | Readonly<{
+    kind: 'leave';
+    transition: PaymentResponseTransition;
+}>;
+export type MountedPayment = Readonly<{
+    sessionId: string;
+    subject: EventRegistrationPaymentSubject;
+}>;
+export declare function planMountedPaymentRefresh(result: PaymentCheckResult, mounted: MountedPayment): MountedPaymentRefresh;
+export declare function paymentResponseNeedsPolling(response: EventCheckoutReturnResponse): boolean;
+export {};

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

@@ -1,12 +1,73 @@
-import type { EligibilityData } from './types';
-export declare function isSelectionSoldOut(availability: EligibilityData['availability'] | undefined): boolean;
-export declare function resolveRegistrationAvailabilityBlocker(input: Readonly<{
+import type { EventRegistrationNextStepRequest } from '../../api/types';
+import type { EligibilityData, RegistrationStep } from './types';
+export type RegistrationAdmission = Readonly<{
+    kind: 'checking';
+}> | Readonly<{
+    kind: 'open' | 'resume';
+}> | Readonly<{
+    kind: 'waitlist';
+    recovery: 'byEmail' | 'none';
+}> | Readonly<{
+    kind: 'fullyBooked';
+    recovery: 'byEmail' | 'none';
+}> | Readonly<{
+    kind: 'closed';
+    reason: 'unavailable' | 'optionsUnavailable' | 'alreadyWaitlisted';
+    message: string;
+}>;
+/** One admission decision for navigation, labels and completion. Email recovery
+ * permits navigation only; submission remains the owner of payment recovery. */
+export declare function resolveRegistrationAdmission(input: Readonly<{
     hasWaitlistClaim: boolean;
-    eligibility: EligibilityData | null;
+    eligibility: Pick<EligibilityData, 'registration' | 'availability'> | null;
     eligibilityError: string | null;
-}>): string | null;
+    eligibilityLoading: boolean;
+    isAuthenticated: boolean;
+}>): RegistrationAdmission;
+export declare function stepAfterTickets(admission: RegistrationAdmission): RegistrationStep;
+export type RegistrationAvailabilityBlocker = Readonly<{
+    kind: 'pending';
+    message: string;
+}> | Readonly<{
+    kind: 'unavailable';
+    message: string;
+}>;
+export declare function resolveRegistrationAvailabilityBlocker(admission: RegistrationAdmission): RegistrationAvailabilityBlocker | null;
 export declare function resolvePricingSelectionBlocker(input: Readonly<{
     selectionRequired: boolean;
     hasValidSelection: boolean;
     slidingScaleSelectionMessage: string | null;
 }>): string | null;
+export type GuestNextStepCheck = Readonly<{
+    kind: 'skip';
+    outcome: Readonly<{
+        kind: 'continue' | 'waitlist';
+    }>;
+}> | Readonly<{
+    kind: 'blocked';
+    message: string;
+}> | Readonly<{
+    kind: 'check';
+    request: EventRegistrationNextStepRequest;
+}>;
+/** Submit owns fresh admission. Open quotes do not depend on an email lookup. */
+export declare function resolveGuestNextStepCheck(admission: RegistrationAdmission, request: EventRegistrationNextStepRequest | null): GuestNextStepCheck;
+export type RegistrationTicketContinuation = Readonly<{
+    kind: 'advance';
+    admission: Exclude<RegistrationAdmission, {
+        kind: 'closed' | 'checking';
+    }>;
+    label: string;
+    pending: false;
+}> | Readonly<{
+    kind: 'blocked';
+    message: string;
+    label: string;
+    pending: boolean;
+}>;
+export declare function resolveRegistrationTicketContinuation(input: Readonly<{
+    admission: RegistrationAdmission;
+    ticketSelectionRequired: boolean;
+    hasValidTicketSelection: boolean;
+    isCheckingExistingRegistration: boolean;
+}>): RegistrationTicketContinuation;

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

@@ -1,9 +1,7 @@
 import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
-import type { EligibilityData, EventTicketSelectionLine, RegistrationEvent, RegistrationStep } from './types';
+import type { EventTicketSelectionLine, RegistrationEvent, RegistrationStep } from './types';
 import type { RegistrationFlowAction } from './registrationStateMachine';
-import type { EventRegistrationStatusReference } from '../../api/types';
 export declare function resolveRegistrationRecoveryAction(step: RegistrationStep, action: EventRegistrationErrorAction): EventRegistrationErrorAction;
-export declare function canRecoverToWaitlist(eligibility: EligibilityData | null): boolean;
 export declare function shouldRefreshAfterRegistrationError(step: RegistrationStep, action: EventRegistrationErrorAction, enabled: boolean): boolean;
 export declare function resetRegistrationAfterExpiry(input: Readonly<{
     hasPreSelectedContext: boolean;
@@ -13,7 +11,6 @@ export declare function resetRegistrationAfterExpiry(input: Readonly<{
     setSelectedSlidingAmountInput: (value: string) => void;
     setSelectedAttendanceMode: (mode: 'online' | 'in_person' | null) => void;
     setErrorMessage: (message: string) => void;
-    setPendingRegistrationReference: (reference: EventRegistrationStatusReference | null) => void;
 }>): void;
 /** Retry the retained submission in place; explicit payment uncertainty stays status-only. */
 export declare function recoverRegistrationError(action: EventRegistrationErrorAction, handlers: Readonly<{

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

@@ -1,4 +1,6 @@
 import type { EligibilityData, PaymentSelection, RegistrationStep } from './types';
+import { type RegistrationAdmission } from './registrationCompletion';
+import type { EventRegistrationNextStepResponse } from '../../api/types';
 export type SelectionSource = 'auto' | 'manual';
 export type RegistrationFlowState = {
     step: RegistrationStep;
@@ -12,6 +14,17 @@ export type RegistrationFlowState = {
 export type RegistrationFlowAction = {
     type: 'set-step';
     step: RegistrationStep;
+} | {
+    type: 'admission-updated';
+    admission: RegistrationAdmission;
+} | {
+    type: 'tickets-completed';
+    admission: Exclude<RegistrationAdmission, {
+        kind: 'closed' | 'checking';
+    }>;
+} | {
+    type: 'recovery-checked';
+    outcome: EventRegistrationNextStepResponse;
 } | {
     type: 'set-tickets-count';
     ticketsCount: number;
@@ -33,11 +46,6 @@ export type RegistrationFlowAction = {
     type: 'reset';
     hasPreSelectedContext: boolean;
 };
-export declare function hasBlockingExistingRegistration(input: Readonly<{
-    isAuthenticated: boolean;
-    registration: EligibilityData['registration'];
-    hasWaitlistClaim: boolean;
-}>): boolean;
 export declare function createInitialRegistrationFlowState(hasPreSelectedContext: boolean): RegistrationFlowState;
 export declare function registrationFlowReducer(state: RegistrationFlowState, action: RegistrationFlowAction): RegistrationFlowState;
 export declare function isEntitlementSelection(selection: PaymentSelection): boolean;

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

@@ -1,64 +1,23 @@
-import type { BookingMailingListNote as BookingSignupNote } from '../../../../../../core/src/index';
-/**
- * SessionStorage utilities for preserving form state across Stripe redirects.
- *
- * Saves form data before redirecting to Stripe, restores on return.
- * Handles graceful degradation when sessionStorage is unavailable.
- */
-import type { FormData } from './types';
-import type { EventTicketSelectionLine, PaymentSelection } from './types';
+import type { BookingMailingListNote } from '../../../../../../core/src/index';
 import type { EventRegistrationStatusReference } from '../../api/types';
-/**
- * Schema for pending registration data stored in sessionStorage.
- * Version field allows future migrations if schema changes.
- */
-type PendingRegistrationV5 = {
-    version: 5;
+import type { FormData, Guest, EventTicketSelectionLine, PaymentSelection } from './types';
+export type PendingRegistration = {
+    version: 6;
     reference: EventRegistrationStatusReference;
     formData: FormData;
     ticketSelections: EventTicketSelectionLine[];
     selectedEventId: string | null;
-    eventSeriesId?: string | null;
     selectedAttendanceMode?: 'in_person' | 'online' | null;
     paymentSelection: PaymentSelection & {
         method: Exclude<PaymentSelection['method'], null>;
     };
-    mailingListSignupNote?: BookingSignupNote;
+    guests: Guest[];
+    selectedSlidingAmount: number | null;
+    discountCode: string;
+    mailingListSignupNote?: BookingMailingListNote;
     timestamp: number;
 };
-export type PendingRegistration = PendingRegistrationV5;
-/**
- * Save pending registration data before Stripe redirect.
- *
- * @param siteId - Site ID
- * @param checkoutAttemptId - Correlation ID included in the checkout return URL
- * @param data - Registration data to save (excluding version and timestamp)
- */
-export declare function savePendingRegistration(siteId: string, checkoutAttemptId: string, data: Omit<PendingRegistration, 'version' | 'timestamp'>): void;
-/**
- * Get pending registration data after returning from Stripe.
- *
- * Returns null if:
- * - No entry exists for this checkout attempt
- * - Entry is stale (> 24 hours old)
- * - Entry is corrupt or wrong version
- * - Storage is unavailable
- *
- * @param siteId - Site ID
- * @param checkoutAttemptId - Correlation ID returned from checkout.
- * @returns Pending registration data or null
- */
-export declare function getPendingRegistration(siteId: string, checkoutAttemptId: string): PendingRegistration | null;
-/**
- * Clear pending registration data after successful verification.
- *
- * @param siteId - Site ID
- * @param checkoutAttemptId - Checkout return correlation ID
- */
-export declare function clearPendingRegistration(siteId: string, checkoutAttemptId: string): void;
-/**
- * Clean up all stale registration entries from sessionStorage.
- * Should be called on component mount to prevent accumulation.
- */
+export declare function savePendingRegistration(siteId: string, submissionId: string, data: Omit<PendingRegistration, 'version' | 'timestamp'>): void;
+export declare function getPendingRegistration(siteId: string, submissionId: string): PendingRegistration | null;
+export declare function clearPendingRegistration(siteId: string, submissionId: string): void;
 export declare function cleanupStaleRegistrations(): void;
-export {};

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

@@ -26,7 +26,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-status' | 'payment-failed' | 'success' | 'error';
+export type RegistrationStep = 'select-event' | 'select-tickets' | 'fully-booked' | 'enter-details' | 'select-payment' | 'submitting' | 'payment' | 'verifying-payment' | 'verifying-timeout' | 'payment-status' | 'payment-failed' | 'success' | 'error';
 export type RegistrationResult = {
     status: 'confirmed' | 'waitlist';
     /**
@@ -46,7 +46,7 @@ export type PaymentStatusRecoveryState = Readonly<{
     kind: 'ready' | 'checking' | 'processing' | 'temporarilyUnavailable' | 'retryAvailable' | 'assistanceRequired';
 }> | Readonly<{
     kind: 'paymentAvailable';
-    checkoutUrl: string;
+    checkout: import('../../api/types').EventEmbeddedCheckout;
 }>);
 export type RegistrationAttendanceMode = 'in_person' | 'online';
 export type EventTicketSelectionLine = Readonly<{
@@ -197,3 +197,20 @@ export type EventRegistrationClientProps = {
     mailingList?: MailingListRuntimeContext;
     siteName?: string;
 };
+export type EventPaymentState = Readonly<{
+    kind: 'idle';
+}> | Readonly<{
+    kind: 'payment';
+    checkout: import('../../api/types').EventEmbeddedCheckout;
+    subject: import('../../api/types').EventRegistrationPaymentSubject;
+}> | Readonly<{
+    kind: 'verifying';
+    request: import('../../api/types').EventCheckoutReturnRequest;
+    resumePayment: boolean;
+}> | Readonly<{
+    kind: 'abandoning';
+    subject: import('../../api/types').EventRegistrationPaymentSubject;
+}> | Readonly<{
+    kind: 'recovery';
+    state: PaymentStatusRecoveryState;
+}>;

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

@@ -1,42 +1,7 @@
-import { usePaymentVerification } from '../../hooks/usePaymentVerification';
-import type { BlockApiClient } from '../../api';
-import type { EventRegistrationStatusReference } from '../../api/types';
-import { scrollToBlock } from '../../shared';
-import { cleanupStaleRegistrations, clearPendingRegistration, getPendingRegistration } from './sessionStorage';
-import type { EventTicketSelectionLine, FormData, PaymentSelection, RegistrationEvent, RegistrationResult, RegistrationStep, RegistrationSubject } from './types';
-type EventRegistrationStripeReturnOptions = {
-    api: BlockApiClient;
-    events: RegistrationEvent[];
-    registrationSubject: RegistrationSubject | null;
-    step: RegistrationStep;
-    pendingRegistrationReference: EventRegistrationStatusReference | null;
-    setFormData: (data: FormData) => void;
-    setTicketsCount: (count: number) => void;
-    setTicketSelections: (lines: readonly EventTicketSelectionLine[]) => void;
-    setSelectedEvent: (event: RegistrationEvent | null) => void;
-    setSelectedAttendanceMode: (attendanceMode: 'in_person' | 'online' | null) => void;
-    setPaymentSelection: (selection: PaymentSelection) => void;
-    setPendingRegistrationReference: (reference: EventRegistrationStatusReference | null) => void;
-    setStep: (step: RegistrationStep) => void;
-    setRegistrationResult: (result: RegistrationResult) => void;
-    setErrorMessage: (message: string) => void;
-};
-export type EventRegistrationStripeReturnDeps = Readonly<{
-    usePaymentVerification: typeof usePaymentVerification;
-    readReturnParams: () => Readonly<{
-        registration: string | null;
-        registration_attempt: string | null;
-        session_id: string | null;
-    }>;
-    clearReturnParams: () => void;
-    scrollToBlock: typeof scrollToBlock;
-    cleanupStaleRegistrations: typeof cleanupStaleRegistrations;
-    clearPendingRegistration: typeof clearPendingRegistration;
-    getPendingRegistration: typeof getPendingRegistration;
-}>;
-export type EventRegistrationStripeReturnResult = ReturnType<typeof usePaymentVerification> & Readonly<{
-    retryReturn?: () => void;
-}>;
-export declare function useEventRegistrationStripeReturn(options: EventRegistrationStripeReturnOptions): EventRegistrationStripeReturnResult;
-export declare function useEventRegistrationStripeReturnWithDeps(options: EventRegistrationStripeReturnOptions, deps: EventRegistrationStripeReturnDeps): EventRegistrationStripeReturnResult;
-export {};
+import type { EventCheckoutReturnRequest } from '../../api/types';
+import type { PendingRegistration } from './sessionStorage';
+export declare function useEventRegistrationStripeReturn(options: Readonly<{
+    siteId: string | undefined;
+    restore: (pending: PendingRegistration) => void;
+    verify: (request: EventCheckoutReturnRequest) => void;
+}>): void;

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

@@ -1,13 +1,11 @@
+import type { BookingMailingListNote as BookingSignupNote } from '../../../../../../core/src/index';
 import { generateUuidV4 } from '../../../../../../core/src/index';
 import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
 import type { BlockApiClient } from '../../api';
-import type { EventRegistrationStatusReference, PaymentMethod } from '../../api/types';
+import type { EventEmbeddedCheckout, EventRegistrationPaymentSubject, PaymentMethod } from '../../api/types';
 import { type RegistrationTarget } from './registrationDerivations';
 import { savePendingRegistration } from './sessionStorage';
 import type { EventTicketSelectionLine, FormData, Guest, PaymentSelection, PaymentStatusRecoveryState, RegistrationResult, RegistrationStep } from './types';
-export type EventRegistrationSubmitOptions = Readonly<{
-    redirect?: 'auto' | 'manual';
-}>;
 export type EventRegistrationSubmitResult = Readonly<{
     ok: true;
     outcome: {
@@ -21,16 +19,18 @@ export type EventRegistrationSubmitResult = Readonly<{
 }> | Readonly<{
     ok: true;
     outcome: {
-        kind: 'checkout_redirect';
-        checkoutUrl: string;
+        kind: 'checkout_ready';
+        checkout: EventEmbeddedCheckout;
+        subject: EventRegistrationPaymentSubject;
     };
 }> | Readonly<{
     ok: false;
     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 EventRegistrationSubmit = (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection) => Promise<EventRegistrationSubmitResult>;
 export type UseEventRegistrationSubmitInput = {
+    openPayment: (checkout: EventEmbeddedCheckout, subject: EventRegistrationPaymentSubject, note?: BookingSignupNote) => void;
     commandRef: EventRegistrationCommandRef;
     api: BlockApiClient;
     registrationTarget: RegistrationTarget | null;
@@ -47,7 +47,6 @@ export type UseEventRegistrationSubmitInput = {
     discountCode: string;
     claimToken: string | null;
     waitlistEntryId?: string | null;
-    setPendingRegistrationReference: (reference: EventRegistrationStatusReference) => void;
     setStep: (step: RegistrationStep) => void;
     setErrorAction?: (action: EventRegistrationErrorAction) => void;
     setRegistrationResult: (result: RegistrationResult) => void;