@riverbankcms/sdk 0.151.0 → 0.152.0

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

@@ -1,8 +1,9 @@
-import type { EventCheckoutReturnResponse, EventEmbeddedCheckout, EventRegistrationPaymentSubject } from '../../api/types';
+import type { EventBookingOutcome, EventCheckoutReturnResponse, EventEmbeddedCheckout, EventRegistrationPaymentSubject } from '../../api/types';
 import type { PaymentStatusRecoveryState } from './types';
 type PaymentResponseIntent = 'resume' | 'check' | 'abandon';
 export type PaymentResponseTransition = {
     kind: 'confirmed';
+    outcome: EventBookingOutcome;
 } | {
     kind: 'restartBooking';
 } | {

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

@@ -12,9 +12,11 @@ export type RegistrationAdmission = Readonly<{
     kind: 'waitlist';
     detailsCheck: 'byEmail' | 'none';
 }>
-/** Always blocked: a sold-out event offers no way forward. */
+/** Always blocked at this size. `placesLeft` > 0 means fewer places than asked
+ * for are left: choosing that many is the way forward (issue 1581). */
  | Readonly<{
     kind: 'fullyBooked';
+    placesLeft: number;
 }> | Readonly<{
     kind: 'closed';
     reason: 'unavailable' | 'optionsUnavailable' | 'alreadyWaitlisted';
@@ -36,6 +38,28 @@ export declare function resolveRegistrationAdmission(input: Readonly<{
     eligibilityLoading: boolean;
     isAuthenticated: boolean;
 }>): RegistrationAdmission;
+/** "Sold out", or "Only 1 place left" when fewer places are left than asked for. */
+export declare function fullyBookedLabel(admission: Extract<RegistrationAdmission, {
+    kind: 'fullyBooked';
+}>): string;
+/** Why a fully booked admission blocks, and how to move on when it can. */
+export declare function fullyBookedMessage(admission: Extract<RegistrationAdmission, {
+    kind: 'fullyBooked';
+}>): string;
+/**
+ * The most places the counter offers (issue 1581): the block's limit, narrowed
+ * only by availability the server has settled for this selection. A visitor
+ * resuming a held place keeps the block's limit (the server counts the held
+ * places back in), and the page's cached snapshot never narrows it.
+ */
+export declare function placeCountCeiling(input: Readonly<{
+    maxAllowed: number;
+    admission: RegistrationAdmission;
+    /** Places left in the settled registration options, when they say. */
+    settledRemaining: number | null;
+}>): number;
+/** Places left in settled registration options, when they name a count. */
+export declare function settledRemainingPlaces(eligibility: Pick<EligibilityData, 'availability'> | null): number | null;
 export type RegistrationAvailabilityBlocker = Readonly<{
     kind: 'pending';
     message: string;
@@ -43,6 +67,14 @@ export type RegistrationAvailabilityBlocker = Readonly<{
     kind: 'unavailable';
     reason: 'soldOut' | 'alreadyWaitlisted' | 'closed';
     message: string;
+}>
+/** Places remain, just fewer than asked for: choosing fewer moves on (issue 1581). */
+ | Readonly<{
+    kind: 'unavailable';
+    reason: 'fewerPlacesLeft';
+    placesLeft: number;
+    heading: string;
+    message: string;
 }>;
 export declare function resolveRegistrationAvailabilityBlocker(admission: RegistrationAdmission): RegistrationAvailabilityBlocker | null;
 export declare function resolvePricingSelectionBlocker(input: Readonly<{

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

@@ -31,6 +31,17 @@ export declare function resolveEventRequiresPayment(input: Readonly<{
     selectedTicketType: Pick<PublicEventPricingOption, 'priceAmount'> | null;
     event: Pick<RegistrationEvent, 'pricing'> | null;
 }>): boolean;
+/**
+ * Whether the route counts the payment steps. Once an event is chosen that
+ * event decides; before then (a series' date step) the dates on offer do, so
+ * the count is fixed from the first step and doesn't grow on choosing a date
+ * (D2, issue 1581).
+ */
+export declare function resolveRouteRequiresPayment(input: Readonly<{
+    event: Pick<RegistrationEvent, 'pricing'> | null;
+    eventRequiresPayment: boolean;
+    events: readonly Pick<RegistrationEvent, 'pricing'>[];
+}>): boolean;
 export declare function resolveDiscountContext(input: Readonly<{
     paymentSelection: PaymentSelection;
     event: Pick<RegistrationEvent, 'seriesId' | 'eventCategory'> | null;

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import type { HybridEventCapacitySource, RemainingPlacesWording } from '../events/domain/capacity';
+import type { RegistrationEvent } from './types';
+export type RegistrationDisplay = Readonly<{
+    venue: 'shown' | 'hidden';
+    placesLeft: 'shown' | 'hidden';
+}>;
+export declare const registrationDisplaySchema: z.ZodObject<{
+    venue: z.ZodEnum<{
+        shown: "shown";
+        hidden: "hidden";
+    }>;
+    placesLeft: z.ZodEnum<{
+        shown: "shown";
+        hidden: "hidden";
+    }>;
+}, z.core.$strip>;
+export declare function resolveRegistrationDisplay(source: Readonly<{
+    showVenue?: boolean;
+    showCapacity?: boolean;
+}>): RegistrationDisplay;
+/** Venue stays in domain data; views receive only the permitted presentation. */
+export declare function shownVenue(event: RegistrationEvent, display: RegistrationDisplay): string | null;
+/** Full/waitlist explanations remain visible even when optional counts are hidden. */
+export declare function placesLeftLabel(source: HybridEventCapacitySource | Readonly<{
+    kind: 'ticketType';
+    remaining: number | null;
+}>, display: RegistrationDisplay, wording?: RemainingPlacesWording & Readonly<{
+    unlimited?: string;
+    open?: string;
+}>): string | null;

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

@@ -0,0 +1,60 @@
+import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
+import type { WaitlistClaimCredential, WaitlistClaimRequest } from '../../shared/useWaitlistClaim.state';
+import type { ResolveWaitlistClaimResponse } from '../../api/types';
+import type { EventTicketSelectionLine, FormData, Guest, RegistrationEvent } from './types';
+import type { WaitlistClaimRestoration } from './waitlistClaimRestoration';
+export type WaitlistInvitation = Readonly<{
+    kind: 'none';
+}> | Readonly<{
+    kind: 'resolving';
+    request: WaitlistClaimRequest;
+}> | Readonly<{
+    kind: 'portal-login-required';
+    request: WaitlistClaimRequest;
+    message: string;
+}> | Readonly<{
+    kind: 'error';
+    request: WaitlistClaimRequest;
+    message: string;
+    action: EventRegistrationErrorAction;
+}> | Readonly<{
+    kind: 'ready';
+    request: WaitlistClaimRequest;
+    claim: ResolveWaitlistClaimResponse;
+    restoration: Extract<WaitlistClaimRestoration, {
+        kind: 'ready';
+    }>;
+}>;
+export type RegistrationDraftData = Readonly<{
+    selectedEvent: RegistrationEvent | null;
+    formData: FormData;
+    guests: Guest[];
+    selectedAttendanceMode: 'in_person' | 'online' | null;
+    selectedTicketLines: EventTicketSelectionLine[];
+    selectedSlidingAmountInput: string;
+}>;
+export type StateUpdate<T> = T | ((current: T) => T);
+export type RegistrationDraftEdit = {
+    [K in keyof RegistrationDraftData]: Readonly<{
+        field: K;
+        value: StateUpdate<RegistrationDraftData[K]>;
+    }>;
+}[keyof RegistrationDraftData];
+export declare function createRegistrationDraftData(event: RegistrationEvent | null): RegistrationDraftData;
+export declare function editRegistrationDraft(draft: RegistrationDraftData, edit: RegistrationDraftEdit): RegistrationDraftData;
+/** Ready invitations own their reserved selection; identity fields remain editable. */
+export declare function canEditInvitedDraft(invitation: WaitlistInvitation, edit: RegistrationDraftEdit): boolean;
+export declare function beginWaitlistInvitation(credential: WaitlistClaimCredential | null): WaitlistInvitation;
+/** A source notification is not a new attempt when its credential is unchanged. */
+export declare function receiveWaitlistInvitation(invitation: WaitlistInvitation, credential: WaitlistClaimCredential | null): WaitlistInvitation;
+export declare function restoreRegistrationDraft(draft: RegistrationDraftData, claim: ResolveWaitlistClaimResponse, restoration: Extract<WaitlistClaimRestoration, {
+    kind: 'ready';
+}>): RegistrationDraftData;
+export type InvitationSubmission = Readonly<{
+    kind: 'available';
+    credential: WaitlistClaimCredential | null;
+}> | Readonly<{
+    kind: 'blocked';
+    message: string;
+}>;
+export declare function invitationSubmission(invitation: WaitlistInvitation): InvitationSubmission;

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

@@ -17,6 +17,6 @@ export declare function recoverRegistrationError(action: EventRegistrationErrorA
     canJoinWaitlist?: boolean;
     refreshOptions: () => void;
     clearError: () => void;
-    setStep: (step: RegistrationStep) => void;
+    setStep: (step: Exclude<RegistrationStep, 'success'>) => void;
     reset: () => void;
 }>): void;

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

@@ -1,4 +1,5 @@
 import type { PublicEventRunGroup } from '../../../blocks/events/shared/runGrouping';
+import type { ConfirmedBookingIdentity } from '../../api/types';
 import type { PublicEvent, RegistrationEvent } from './types';
 export declare function toRegistrationEvent(event: PublicEvent): RegistrationEvent;
 export declare function toRegistrationEvents(events: readonly PublicEvent[]): RegistrationEvent[];
@@ -15,3 +16,5 @@ export declare function toWholeSeriesRegistrationEvents(events: readonly PublicE
 export declare function getRegistrationStartAt(event: Pick<RegistrationEvent, 'registrationSubject' | 'startsAt'> | null | undefined, occurrenceContext: Readonly<{
     startsAt: string;
 }> | null | undefined): string | undefined;
+/** Confirmation identifies its persisted subject, independently of the current draft. */
+export declare function findBookedEvent(events: readonly RegistrationEvent[], identity: ConfirmedBookingIdentity): RegistrationEvent | null;

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

@@ -1,17 +1,56 @@
-import type { EligibilityData, PaymentSelection, RegistrationStep } from './types';
+import type { WaitlistClaimCredential, WaitlistClaimLookup } from '../../shared/useWaitlistClaim.state';
+import { type RegistrationDraftData, type RegistrationDraftEdit, type WaitlistInvitation } from './registrationDraft.state';
+import type { RegistrationEvent } from './types';
+import type { EventSourceRecovery } from './eventSourceRecovery';
+import type { EligibilityData, PaymentSelection, RegistrationStep, RegistrationResult } from './types';
 export type SelectionSource = 'auto' | 'manual';
-export type RegistrationFlowState = {
-    step: RegistrationStep;
+type RegistrationDraftState = {
+    draft: RegistrationDraftData;
     ticketsCount: number;
-    isAuthenticated: boolean;
     eligibility: EligibilityData | null;
     passOptOut: boolean;
     paymentSelection: PaymentSelection;
     selectionSource: SelectionSource;
 };
+export type RegistrationFlowState = Readonly<{
+    isAuthenticated: boolean;
+}> & RegistrationDraftState & (Readonly<{
+    step: Exclude<RegistrationStep, 'success'>;
+    invitation: WaitlistInvitation;
+}> | Readonly<{
+    step: 'success';
+    result: RegistrationResult;
+    invitation: Readonly<{
+        kind: 'none';
+    }>;
+}>);
+/** Constructors of a fresh draft cannot return invitation authority. */
+type FreshRegistrationFlowState = Exclude<RegistrationFlowState, {
+    step: 'success';
+}> & Readonly<{
+    invitation: Extract<WaitlistInvitation, {
+        kind: 'none';
+    }>;
+}>;
 export type RegistrationFlowAction = {
+    type: 'draft-edited';
+    edit: RegistrationDraftEdit;
+} | {
+    type: 'claim-arrived';
+    credential: WaitlistClaimCredential | null;
+} | {
+    type: 'claim-updated';
+    lookup: WaitlistClaimLookup;
+    events: EventSourceRecovery<RegistrationEvent>;
+    occurrenceContextId: string | undefined;
+} | {
+    type: 'refresh-invitation';
+} | {
     type: 'set-step';
-    step: RegistrationStep;
+    step: Exclude<RegistrationStep, 'success'>;
+} | {
+    type: 'completed';
+    result: RegistrationResult;
 } | {
     type: 'tickets-completed';
 } | {
@@ -30,16 +69,24 @@ export type RegistrationFlowAction = {
     type: 'use-card-instead-of-pass';
 } | {
     type: 'use-pass';
-} | {
-    type: 'event-changed';
-    hasPreSelectedContext: boolean;
-} | {
+} | (EventChoice & Readonly<{
+    navigation: 'choose' | 'advance';
+}>) | {
     type: 'reset';
     hasPreSelectedContext: boolean;
 };
-export declare function createInitialRegistrationFlowState(hasPreSelectedContext: boolean): RegistrationFlowState;
+export type EventChoice = Readonly<{
+    type: 'event-continued';
+}> | Readonly<{
+    type: 'event-replaced';
+    event: RegistrationEvent;
+}>;
+/** Identity, not clicking a row, decides whether this is a new booking. */
+export declare function decideEventChoice(state: Pick<RegistrationFlowState, 'draft' | 'invitation'>, event: RegistrationEvent): EventChoice;
+export declare function createInitialRegistrationFlowState(hasPreSelectedContext: boolean): FreshRegistrationFlowState;
 export declare function areEventRegistrationPaymentSelectionsEqual(a: PaymentSelection, b: PaymentSelection): boolean;
 export declare function registrationFlowReducer(state: RegistrationFlowState, action: RegistrationFlowAction): RegistrationFlowState;
+export declare function isRegistrationLocked(step: RegistrationStep): boolean;
 /**
  * The pass the customer turned down, while it would otherwise cover this booking.
  *
@@ -54,3 +101,4 @@ export declare function requiresPaymentStep(params: {
     eventRequiresPayment: boolean;
     paymentSelection: PaymentSelection;
 }): boolean;
+export {};

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

@@ -1,3 +1,4 @@
+import type { EventRegistrationRecoveryRequest } from './useEventRegistrationRecoveryRequest';
 import type { PublicEvent } from '../../../blocks/events/shared/types';
 import { type PublicEventRunGroup } from '../../../blocks/events/shared/runGrouping';
 import { type EventRegistrationPageSurfaceSubject } from './eventScope';
@@ -12,6 +13,22 @@ export type EventRegistrationSurfacePlan = Readonly<{
 }> | Readonly<{
     kind: 'mixedBookingScopes';
 }>;
+/** Admission only limits fresh bookings; existing purchases always reach recovery. */
+export declare function registrationAdmissionSurface(input: Readonly<{
+    availability: 'open' | 'closed' | 'empty';
+    recoveryRequested: boolean;
+}>): 'registration' | 'closed' | 'empty';
+/** Resolve the host guard once; past-date notices only concern new bookings. */
+export declare function resolveEventRegistrationClientSurface(input: Readonly<{
+    plan: EventRegistrationSurfacePlan;
+    pastStartsAt: string | null;
+    recoveryRequest: EventRegistrationRecoveryRequest;
+}>): Readonly<{
+    kind: 'wizard' | 'unavailable';
+}> | Readonly<{
+    kind: 'past';
+    startsAt: string;
+}>;
 export declare function planEventRegistrationSurface(input: Readonly<{
     events: readonly PublicEvent[];
     occurrenceContext?: Readonly<{

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

@@ -1,3 +1,4 @@
+import type { RegistrationDisplay } from './registrationDisplay';
 import type { BookingMailingListNote as BookingSignupNote } from '../../../../../../core/src/index';
 import type { PublicEventPricing } from '../../../../../../core/src/index';
 import type { MailingListRuntimeContext } from '../../../../../../core/src/index';
@@ -7,7 +8,7 @@ import type { PublicEvent, PublicEventPricingOption, PublicEventPricingOptionAva
 import type { BlockBookingPaymentTerms } from '../../../blocks/shared/bookingPaymentTerms';
 import type { PublicMembershipProductCollection, PublicPassProductCollection } from '../../../blocks/shop.shared';
 import type { BlockButtonRole } from '../../../constants/buttonRoles';
-import type { AvailableMembership, AvailablePass, DirectCheckoutCollectionOptionKind, EventTicketLineSummary } from '../../api/types';
+import type { AvailableMembership, AvailablePass, DirectCheckoutCollectionOptionKind, EventTicketLineSummary, EventBookingOutcome } from '../../api/types';
 import type { EventRegistrationPageSurfaceSubject } from './eventScope';
 export type { OccurrenceContext, PublicEvent };
 export type { FormData } from '../../shared';
@@ -27,8 +28,7 @@ export type GuestErrors = Record<number, {
     name?: string;
 }>;
 export type RegistrationStep = 'select-event' | 'select-tickets' | 'enter-details' | 'select-payment' | 'submitting' | 'payment' | 'verifying-payment' | 'verifying-timeout' | 'payment-status' | 'payment-failed' | 'success' | 'error';
-export type RegistrationResult = {
-    status: 'confirmed' | 'waitlist';
+type RegistrationResultCopy = {
     /**
      * Optional success copy overrides (e.g. idempotent "already registered" responses).
      * When omitted, the block-level `successMessage`/default copy is used.
@@ -39,6 +39,12 @@ export type RegistrationResult = {
     variant?: 'success' | 'info';
     mailingListSignupNote?: BookingSignupNote;
 };
+export type RegistrationResult = RegistrationResultCopy & (Readonly<{
+    status: 'confirmed';
+    outcome: EventBookingOutcome;
+}> | Readonly<{
+    status: 'waitlist';
+}>);
 export type PaymentStatusRecoveryState = Readonly<{
     subject: import('../../api/types').EventRegistrationPaymentSubject;
     mailingListSignupNote?: BookingSignupNote;
@@ -124,7 +130,7 @@ export type RegistrationSubject = Readonly<{
     /** Ordered live booking sessions; cancellation history stays on PublicEvent.run. */
     sessions: readonly PublicRunSession[];
 }>;
-export type RegistrationEvent = Pick<PublicEvent, 'seriesId' | 'title' | 'startsAt' | 'endsAt' | 'bookingAvailability' | 'deliveryMode' | 'attendanceModes' | 'capacity' | 'registeredCount' | 'availableSpots' | 'waitlistEnabled' | 'venue' | 'eventCategory' | 'teamMembers' | 'status' | 'timeZone' | 'paymentTerms' | 'consent' | 'requireGuestDetails' | 'acceptsPasses' | 'acceptsMemberships'> & Readonly<{
+export type RegistrationEvent = Pick<PublicEvent, 'seriesId' | 'scheduleSummary' | 'title' | 'startsAt' | 'endsAt' | 'bookingAvailability' | 'deliveryMode' | 'attendanceModes' | 'capacity' | 'registeredCount' | 'availableSpots' | 'waitlistEnabled' | 'venue' | 'eventCategory' | 'teamMembers' | 'status' | 'timeZone' | 'siteTimeZone' | 'paymentTerms' | 'consent' | 'requireGuestDetails' | 'acceptsPasses' | 'acceptsMemberships' | 'eventPreset'> & Readonly<{
     selectionId: string;
     registrationSubject: RegistrationSubject;
     pricing: PublicEventPricing;
@@ -183,13 +189,18 @@ export type EventRegistrationClientProps = {
     occurrenceContext?: OccurrenceContext | null;
     subject?: EventRegistrationPageSurfaceSubject | null;
     events?: PublicEvent[] | null;
+    /** Client recovery preserves loading/failure instead of presenting an empty loaded list. */
+    eventSourceRecovery?: import('./eventSourceRecovery').EventSourceRecovery;
     maxTickets?: string;
-    showVenue?: boolean;
-    showCapacity?: boolean;
+    display: RegistrationDisplay;
     successMessage?: string;
     buttonText?: string;
     buttonVariant?: BlockButtonRole;
-    overlayEnabled?: boolean;
+    /**
+     * Where the booking panel lives; the server always sets it. Rendered
+     * without the island (tests, stories), the wizard shows in place.
+     */
+    host?: import('./bookingCardDisplay').BookingHost;
     className?: string;
     /** Server-passed spam protection flag. Falls back to NEXT_PUBLIC_SPAM_PROTECTION_ENABLED. */
     spamProtectionEnabled?: boolean;
@@ -201,6 +212,11 @@ export type EventRegistrationClientProps = {
     siteMemberships?: PublicMembershipProductCollection | null;
     mailingList?: MailingListRuntimeContext;
     siteName?: string;
+    /** What the site calls this offering ("class", "course"), resolved on the server. */
+    offeringNoun?: Readonly<{
+        label: string;
+        pluralLabel: string;
+    }> | null;
 };
 export type EventPaymentState = 
 /** `heldPlaceRetry`: this tab is booking again for a booking whose place the

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

@@ -0,0 +1,12 @@
+import { type RefObject } from 'react';
+import { type BookingBarPlacement } from './bookingEntry';
+/** The CSS variable the bar reads its push from (`translateY`). */
+export declare const BOOKING_BAR_PUSH_VAR = "--er-bar-push";
+/**
+ * Keeps the bar placed (issue 1581): shown or hidden in React state, which
+ * changes rarely, and the card's push written straight to the bar element.
+ * The card's position is only read while an IntersectionObserver says it is
+ * on screen; otherwise it can't be pushing, and the bar is simply shown or
+ * hidden. Scroll work is batched to one read per animation frame.
+ */
+export declare function useBookingBarPlacement(cardRef: RefObject<HTMLElement | null>, barRef: RefObject<HTMLElement | null>, panelOpen: boolean): BookingBarPlacement['state'];

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

@@ -0,0 +1,3 @@
+export type EventRegistrationRecoveryRequest = 'none' | 'paymentReturn' | 'waitlistInvitation';
+/** Retain arrival intent while the payment controller cleans up the return URL. */
+export declare function useEventRegistrationRecoveryRequest(): EventRegistrationRecoveryRequest;

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

@@ -1,5 +1,9 @@
 import type { EventCheckoutReturnRequest } from '../../api/types';
 import type { PendingRegistration } from './sessionStorage';
+/** A return URL asks the server to verify; it is never proof of payment. */
+export declare function eventRegistrationCheckoutReturnRequest(params: URLSearchParams): Extract<EventCheckoutReturnRequest, {
+    kind: 'resolveSession';
+}> | null;
 export declare function useEventRegistrationStripeReturn(options: Readonly<{
     siteId: string | undefined;
     restore: (pending: PendingRegistration) => void;

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

@@ -1,3 +1,4 @@
+import type { InvitationSubmission } from './registrationDraft.state';
 import type { BookingMailingListNote as BookingSignupNote } from '../../../../../../core/src/index';
 import { generateUuidV4 } from '../../../../../../core/src/index';
 import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
@@ -45,11 +46,10 @@ export type UseEventRegistrationSubmitInput = {
     requireGuestDetails: boolean;
     guests: Guest[];
     discountCode: string;
-    claimToken: string | null;
-    waitlistEntryId?: string | null;
-    setStep: (step: RegistrationStep) => void;
+    invitation: InvitationSubmission;
+    setStep: (step: Exclude<RegistrationStep, 'success'>) => void;
     setErrorAction?: (action: EventRegistrationErrorAction) => void;
-    setRegistrationResult: (result: RegistrationResult) => void;
+    complete: (result: RegistrationResult) => void;
     setErrorMessage: (message: string) => void;
     setPaymentStatusRecovery: (state: PaymentStatusRecoveryState | null) => void;
 };
@@ -70,13 +70,6 @@ export type EventRegistrationSubmitDeps = Readonly<{
 }>;
 export declare const createClientCommandId: typeof generateUuidV4;
 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;