@riverbankcms/sdk 0.132.0 → 0.135.0

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

@@ -1,10 +1,10 @@
 import type { DiscountContext } from '../../api/types';
-import type { EligibilityData, EligibilityEventTicketType, OccurrenceContext, PaymentSelection, PublicEventTicketType, RegistrationEvent } from './types';
+import type { EligibilityData, EligibilityEventTicketType, OccurrenceContext, PaymentSelection, PublicEventTicketType, RegistrationEvent, RegistrationSubject } from './types';
 export type RegistrationTarget = Readonly<{
-    occurrenceId: string;
+    subject: RegistrationSubject;
     selectedEventId: string | null;
 }>;
-export declare function eventMatchesOccurrenceId(event: Pick<RegistrationEvent, 'publicEventId' | 'registrationOccurrenceId'>, occurrenceId: string): boolean;
+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<{
     scopedEvents: readonly RegistrationEvent[];
@@ -12,7 +12,7 @@ export declare function findPreSelectedEvent(input: Readonly<{
 }>): RegistrationEvent | null;
 export declare function resolveRegistrationTarget(input: Readonly<{
     occurrenceContext: Pick<NonNullable<OccurrenceContext>, 'id'> | null | undefined;
-    selectedEvent: Pick<RegistrationEvent, 'publicEventId' | 'registrationOccurrenceId'> | null;
+    selectedEvent: Pick<RegistrationEvent, 'selectionId' | 'registrationSubject'> | null;
 }>): RegistrationTarget | null;
 export declare function resolveEventRequiresPayment(input: Readonly<{
     eligibility: Pick<EligibilityData, 'requiresPayment'> | null;

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

@@ -1,3 +1,6 @@
+import type { PublicWholeSeriesOffering } from '../../../blocks/events/whole-series';
 import type { PublicEvent, RegistrationEvent } from './types';
 export declare function toRegistrationEvent(event: PublicEvent): RegistrationEvent;
 export declare function toRegistrationEvents(events: readonly PublicEvent[]): RegistrationEvent[];
+export declare function toWholeSeriesRegistrationEvent(offering: PublicWholeSeriesOffering): RegistrationEvent;
+export declare function toWholeSeriesRegistrationEvents(offerings: readonly PublicWholeSeriesOffering[]): RegistrationEvent[];

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

@@ -33,6 +33,11 @@ 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/registrationSurface.d.ts

@@ -1,6 +1,6 @@
 import type { PublicWholeSeriesOffering } from '../../../blocks/events/whole-series';
 import type { PublicEvent } from '../../../blocks/events/shared/types';
-import { type EventRegistrationPageSurfaceSubject } from './eventScope';
+import { type EventRegistrationScopeContext, type EventRegistrationScopeableEvent, type EventRegistrationPageSurfaceSubject } from './eventScope';
 export type EventRegistrationSurfacePlan = Readonly<{
     kind: 'occurrence';
     events: readonly PublicEvent[];
@@ -12,9 +12,25 @@ export type EventRegistrationSurfacePlan = Readonly<{
 }> | Readonly<{
     kind: 'mixedBookingScopes';
 }>;
+type EventRegistrationSurfaceScopeInput<TEvent extends EventRegistrationScopeableEvent> = EventRegistrationScopeContext & Readonly<{
+    events: readonly TEvent[];
+    wholeSeriesOffering?: PublicWholeSeriesOffering | null;
+}>;
+export type EventRegistrationSurfaceScopePlan<TEvent extends EventRegistrationScopeableEvent> = Readonly<{
+    kind: 'selectedRun';
+    events: readonly TEvent[];
+    offering: PublicWholeSeriesOffering;
+}> | Readonly<{
+    kind: 'context';
+    events: readonly TEvent[];
+}> | Readonly<{
+    kind: 'invalidSelectedRun';
+}>;
+export declare function planEventRegistrationScope<TEvent extends EventRegistrationScopeableEvent>(input: EventRegistrationSurfaceScopeInput<TEvent>): EventRegistrationSurfaceScopePlan<TEvent>;
 export declare function planEventRegistrationSurface(input: Readonly<{
     events: readonly PublicEvent[];
     wholeSeriesOfferings: readonly PublicWholeSeriesOffering[];
+    wholeSeriesOffering?: PublicWholeSeriesOffering | null;
     occurrenceContext?: Readonly<{
         id: string;
         seriesId: string;
@@ -24,3 +40,4 @@ export declare function planEventRegistrationSurface(input: Readonly<{
     }> | null;
     subject?: EventRegistrationPageSurfaceSubject | null;
 }>): EventRegistrationSurfacePlan;
+export {};

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

@@ -0,0 +1,28 @@
+import type { EligibilityData, PaymentSelection, RegistrationEvent, RegistrationStep, RegistrationSubject } from './types';
+type PortalAuthState = 'checking' | 'authenticated' | 'unauthenticated';
+export declare function parseCurrencyInputToCents(value: string): number | null;
+export declare function formatCentsAsCurrencyInput(amount: number): string;
+export declare function getSlidingScaleForEvent(event: RegistrationEvent | null): Readonly<{
+    minAmount: number;
+    maxAmount: number;
+    suggestedAmount: number | null;
+}> | null;
+export declare function getSlidingScaleSelectionMessage(input: Readonly<{
+    slidingScale: ReturnType<typeof getSlidingScaleForEvent>;
+    selectedAmount: number | null;
+}>): string | null;
+export declare function getRegistrationOccurrenceId(target: Readonly<{
+    subject: RegistrationSubject;
+}> | null): string;
+export declare function shouldLoadRegistrationOptions(authState: PortalAuthState, step: RegistrationStep): boolean;
+export declare function getEligibilityFlowFlags(input: Readonly<{
+    eligibility: EligibilityData | null;
+    portalAuthState: PortalAuthState;
+    ticketsCount: number;
+    paymentMethod: PaymentSelection['method'];
+}>): {
+    hasEligibility: boolean;
+    hasMembershipEligibility: boolean;
+    isMembershipFastTrack: boolean;
+};
+export {};

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

@@ -6,13 +6,14 @@
  */
 import type { FormData } from './types';
 import type { EventTicketSelectionLine, PaymentSelection } from './types';
+import type { EventRegistrationStatusReference } from '../../api/types';
 /**
  * Schema for pending registration data stored in sessionStorage.
  * Version field allows future migrations if schema changes.
  */
-type PendingRegistrationV4 = {
-    version: 4;
-    attendeeId: string;
+type PendingRegistrationV5 = {
+    version: 5;
+    reference: EventRegistrationStatusReference;
     formData: FormData;
     ticketSelections: EventTicketSelectionLine[];
     selectedEventId: string | null;
@@ -22,36 +23,36 @@ type PendingRegistrationV4 = {
     };
     timestamp: number;
 };
-export type PendingRegistration = PendingRegistrationV4;
+export type PendingRegistration = PendingRegistrationV5;
 /**
  * Save pending registration data before Stripe redirect.
  *
  * @param siteId - Site ID
- * @param occurrenceId - Event occurrence 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, occurrenceId: string, data: Omit<PendingRegistration, 'version' | 'timestamp'>): void;
+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 site/occurrence
+ * - 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 occurrenceId - Optional event occurrence ID. If missing, scans for any entry for this site.
+ * @param checkoutAttemptId - Correlation ID returned from checkout.
  * @returns Pending registration data or null
  */
-export declare function getPendingRegistration(siteId: string, occurrenceId?: string): PendingRegistration | null;
+export declare function getPendingRegistration(siteId: string, checkoutAttemptId: string): PendingRegistration | null;
 /**
  * Clear pending registration data after successful verification.
  *
  * @param siteId - Site ID
- * @param occurrenceId - Event occurrence ID
+ * @param checkoutAttemptId - Checkout return correlation ID
  */
-export declare function clearPendingRegistration(siteId: string, occurrenceId: string): void;
+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.

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

@@ -1,10 +1,13 @@
+import type { PublicEventPricing } from '../../../../../../core/src/index';
 import type { PublicEvent, PublicEventTicketType, PublicEventTicketTypeAvailability } from '../../../blocks/events/shared/types';
 import type { OccurrenceContext } from '../../../blocks/event-registration.shared';
 import type { PublicMembershipProductCollection, PublicPassProductCollection } from '../../../blocks/shop.shared';
 import type { PublicWholeSeriesOffering } from '../../../blocks/events/whole-series';
 import type { AvailablePass, AvailableMembership, DirectCheckoutCollectionOptionKind, EventTicketLineSummary, EligibilityEventTicketType } from '../../api/types';
+import type { BlockBookingPaymentTerms } from '../../../blocks/shared/bookingPaymentTerms';
 import type { EventRegistrationPageSurfaceSubject } from './eventScope';
 import type { BlockButtonRole } from '../../../constants/buttonRoles';
+import type { EventRegistrationAvailablePaymentOption, EventRegistrationOptionsResponse } from '../../../blocks/event-registration';
 export type { PublicEvent, OccurrenceContext };
 export type { FormData } from '../../shared';
 /**
@@ -43,14 +46,24 @@ export type EventTicketSelectionLine = Readonly<{
  * Transformed from API response for component use.
  */
 export type EligibilityData = {
+    /** Canonical server-owned availability for this exact selection. */
+    availability: EventRegistrationOptionsResponse['availability'];
+    /** Existing registration state for the authenticated customer. */
+    registration: EventRegistrationOptionsResponse['registration'];
+    /** Payment choices approved by the canonical server planner. */
+    paymentOptions: readonly EventRegistrationAvailablePaymentOption[];
     /** Whether the event is free (no payment required) */
     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. */
     pricingMode?: 'single' | 'ticket_types' | 'sliding_scale';
+    /** Canonical collection terms for the selected registration. */
+    paymentTerms: BlockBookingPaymentTerms;
     /** Selected ticket type echoed back from the eligibility API, if any. */
     selectedTicketTypeId?: string | null;
     /** Selected ticket-line pricing echoed back from the eligibility API. */
@@ -94,39 +107,56 @@ export type EligibilityData = {
     availableMemberships: AvailableMembership[];
 };
 export type { EligibilityEventTicketType, PublicEventTicketType, PublicEventTicketTypeAvailability, };
-export type RegistrationEvent = Omit<PublicEvent, 'id' | 'occurrenceId'> & {
-    publicEventId: string;
-    registrationOccurrenceId: string;
-};
+export type RegistrationTicketType = Pick<PublicEventTicketType, 'id' | 'name' | 'description' | 'priceAmount' | 'isActive' | 'sortOrder' | 'capacityMode' | 'capacityLimit' | 'attendanceScope' | 'saleStartsAt' | 'saleEndsAt' | 'availability'>;
+export type RegistrationSubject = Readonly<{
+    kind: 'occurrence';
+    occurrenceId: string;
+}> | Readonly<{
+    kind: 'wholeSeries';
+    eventSeriesId: string;
+    sessions: PublicWholeSeriesOffering['sessions'];
+}>;
+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<{
+    selectionId: string;
+    registrationSubject: RegistrationSubject;
+    pricing: PublicEventPricing<RegistrationTicketType>;
+}>;
 /**
  * Payment selection state for the summary bar.
  * Used to show product info (pass/membership) in the summary.
  * Set by the registration flow state machine and updated by PaymentSelectionStep.
  */
-export type PaymentSelection = {
-    /** Selected payment method (null if not yet selected) */
-    method: 'free' | 'pass' | 'membership' | 'stripe' | 'pass_bundle' | 'membership_bundle' | null;
-    /** Pass ID if method is 'pass' */
-    passId?: string;
-    /** Membership ID if method is 'membership' */
-    membershipId?: string;
-    /** Bundle pass ID if method is 'pass_bundle' */
-    bundlePassId?: string;
-    /** Bundle membership ID if method is 'membership_bundle' */
-    bundleMembershipId?: string;
-    /** Product name for summary bar display */
+export type PaymentSelection = Readonly<{
+    method: null;
+}> | Readonly<{
+    method: 'free';
+}> | Readonly<{
+    method: 'stripe';
+    collectionOptionKind: DirectCheckoutCollectionOptionKind;
+}> | Readonly<{
+    method: 'pass';
+    passId: string;
+    productName?: string;
+}> | Readonly<{
+    method: 'membership';
+    membershipId: string;
+    productName?: string;
+}> | Readonly<{
+    method: 'pass_bundle';
+    bundlePassId: string;
+    productName?: string;
+    productDescription?: string;
+    productPrice?: number;
+    productCurrency?: string;
+}> | Readonly<{
+    method: 'membership_bundle';
+    bundleMembershipId: string;
     productName?: string;
-    /** Product description for summary bar display */
     productDescription?: string;
-    /** Product price in cents (for bundles) */
     productPrice?: number;
-    /** Product currency code */
     productCurrency?: string;
-    /** Payment interval for memberships (e.g., 'month', 'year') */
     productInterval?: string;
-    /** Direct-payment collection option chosen for this registration. */
-    collectionOptionKind?: DirectCheckoutCollectionOptionKind;
-};
+}>;
 /**
  * State reported by PaymentSelectionStep for parent to render footer actions.
  */
@@ -141,8 +171,6 @@ export type PaymentStepState = {
     showLoginPrompt: boolean;
 };
 export type EventRegistrationClientProps = {
-    /** @deprecated Site ID is now provided by BlockApiProvider context */
-    siteId?: string;
     occurrenceContext?: OccurrenceContext | null;
     subject?: EventRegistrationPageSurfaceSubject | null;
     events?: PublicEvent[] | null;
@@ -153,33 +181,13 @@ export type EventRegistrationClientProps = {
     maxTickets?: string;
     showVenue?: boolean;
     showCapacity?: boolean;
-    showSessions?: boolean;
-    showPrice?: boolean;
     successMessage?: string;
-    waitlistMessage?: string;
-    membershipMessage?: string;
     buttonText?: string;
     buttonVariant?: BlockButtonRole;
     overlayEnabled?: boolean;
     className?: string;
-    /**
-     * @deprecated Custom endpoints no longer supported - API client handles routing
-     */
-    registrationEndpoint?: string;
-    /**
-     * @deprecated Custom endpoints no longer supported - API client handles routing
-     */
-    eligibilityEndpoint?: string;
-    /**
-     * @deprecated Custom endpoints no longer supported - API client handles routing
-     */
-    checkoutEndpoint?: string;
     /** Server-passed spam protection flag. Falls back to NEXT_PUBLIC_SPAM_PROTECTION_ENABLED. */
     spamProtectionEnabled?: boolean;
-    /**
-     * @deprecated Stage is now controlled by BlockApiProvider's isPreview config
-     */
-    stage?: 'preview' | 'published';
     /** Support email to display on timeout step */
     supportEmail?: string;
     /** Site-wide public pass products; filtered against the selected event before prompting. */

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

@@ -1,28 +1,32 @@
 import { usePaymentVerification } from '../../hooks/usePaymentVerification';
 import type { BlockApiClient } from '../../api';
-import { consumeSearchParam, scrollToBlock } from '../../shared';
+import type { EventRegistrationStatusReference } from '../../api/types';
+import { scrollToBlock } from '../../shared';
 import { cleanupStaleRegistrations, clearPendingRegistration, getPendingRegistration } from './sessionStorage';
-import type { EventTicketSelectionLine, FormData, PaymentSelection, RegistrationEvent, RegistrationResult, RegistrationStep } from './types';
+import type { EventTicketSelectionLine, FormData, PaymentSelection, RegistrationEvent, RegistrationResult, RegistrationStep, RegistrationSubject } from './types';
 type EventRegistrationStripeReturnOptions = {
     api: BlockApiClient;
     events: RegistrationEvent[];
-    occurrenceId: string;
+    registrationSubject: RegistrationSubject | null;
     step: RegistrationStep;
-    pendingAttendeeId: string | null;
+    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;
-    setPendingAttendeeId: (id: string | null) => 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;
-    consumeSearchParam: typeof consumeSearchParam;
+    consumeReturnParams: () => Readonly<{
+        registration: string | null;
+        registration_attempt: string | null;
+    }>;
     scrollToBlock: typeof scrollToBlock;
     cleanupStaleRegistrations: typeof cleanupStaleRegistrations;
     clearPendingRegistration: typeof clearPendingRegistration;

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

@@ -2,6 +2,7 @@ import type { BlockApiClient } from '../../api';
 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 { RegistrationTarget } from './registrationDerivations';
 export type EventRegistrationSubmitOptions = Readonly<{
     redirect?: 'auto' | 'manual';
@@ -34,13 +35,20 @@ export type UseEventRegistrationSubmitInput = {
     guests: Guest[];
     discountCode: string;
     claimToken: string | null;
-    setPendingAttendeeId: (id: string) => void;
+    setPendingRegistrationReference: (reference: EventRegistrationStatusReference) => void;
     setStep: (step: RegistrationStep) => void;
     setRegistrationResult: (result: RegistrationResult) => void;
     setErrorMessage: (message: string) => void;
 };
 export type EventRegistrationSubmitDeps = Readonly<{
     savePendingRegistration: typeof savePendingRegistration;
+    createCheckoutAttemptId: () => string;
 }>;
+type CheckoutAttemptCryptoSource = Readonly<{
+    randomUUID?: () => string;
+    getRandomValues: (bytes: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBuffer>;
+}>;
+export declare function createCheckoutAttemptId(cryptoSource?: CheckoutAttemptCryptoSource): 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 {};

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

@@ -1,5 +1,5 @@
 import type { DiscountContext } from '../../api/types';
-import type { EventTicketSelectionLine, EventRegistrationClientProps, FormData, Guest, GuestErrors, PaymentSelection, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult, RegistrationStep } from './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';
 import { useEventRegistrationStripeReturn } from './useEventRegistrationStripeReturn';
@@ -18,6 +18,7 @@ export type UseEventRegistrationWizardOptions = Readonly<{
     occurrenceContext: EventRegistrationClientProps['occurrenceContext'];
     subject?: EventRegistrationClientProps['subject'];
     events: PublicEvent[];
+    wholeSeriesOfferings?: EventRegistrationClientProps['wholeSeriesOfferings'];
     maxTicketsNum: number;
 }>;
 export type EventRegistrationWizardDeps = Readonly<{
@@ -42,7 +43,7 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
         overrides?: Record<string, unknown> | null | undefined;
     } | null | undefined;
     registrationTarget: Readonly<{
-        occurrenceId: string;
+        subject: import("./types").RegistrationSubject;
         selectedEventId: string | null;
     }> | null;
     subject: import("./eventScope").EventRegistrationPageSurfaceSubject | null | undefined;
@@ -57,8 +58,8 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     setSelectedEvent: import("react").Dispatch<import("react").SetStateAction<RegistrationEvent | null>>;
     ticketsCount: number;
     setTicketsCount: (nextTicketsCount: number) => void;
-    selectedAttendanceMode: "in_person" | "online" | null;
-    setSelectedAttendanceMode: import("react").Dispatch<import("react").SetStateAction<"in_person" | "online" | null>>;
+    selectedAttendanceMode: "online" | "in_person" | null;
+    setSelectedAttendanceMode: import("react").Dispatch<import("react").SetStateAction<"online" | "in_person" | null>>;
     ticketSelections: Readonly<{
         ticketTypeId: string | null;
         quantity: number;
@@ -114,12 +115,19 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     paymentSelection: PaymentSelection;
     isMembershipFastTrack: boolean;
     waitlistClaim: import("../../shared/useWaitlistClaim").UseWaitlistClaimResult;
-    eligibility: import("./types").EligibilityData | null;
+    eligibility: EligibilityData | null;
     eligibilityLoading: boolean;
     eligibilityError: string | null;
     existingRegistration: import("../../api").CustomerEventRegistration | null;
     existingRegistrationLoading: boolean;
     existingRegistrationState: import("./hooks.state").ExistingRegistrationLookupState;
+    registrationState: Readonly<{
+        kind: "none";
+    }> | Readonly<{
+        kind: "booked";
+    }> | Readonly<{
+        kind: "waitlisted";
+    }>;
     hasEligibility: boolean;
     hasMembershipEligibility: boolean;
     requireGuestDetails: boolean;
@@ -155,7 +163,7 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
         overrides?: Record<string, unknown> | null | undefined;
     } | null | undefined;
     registrationTarget: Readonly<{
-        occurrenceId: string;
+        subject: import("./types").RegistrationSubject;
         selectedEventId: string | null;
     }> | null;
     subject: import("./eventScope").EventRegistrationPageSurfaceSubject | null | undefined;
@@ -170,8 +178,8 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     setSelectedEvent: import("react").Dispatch<import("react").SetStateAction<RegistrationEvent | null>>;
     ticketsCount: number;
     setTicketsCount: (nextTicketsCount: number) => void;
-    selectedAttendanceMode: "in_person" | "online" | null;
-    setSelectedAttendanceMode: import("react").Dispatch<import("react").SetStateAction<"in_person" | "online" | null>>;
+    selectedAttendanceMode: "online" | "in_person" | null;
+    setSelectedAttendanceMode: import("react").Dispatch<import("react").SetStateAction<"online" | "in_person" | null>>;
     ticketSelections: Readonly<{
         ticketTypeId: string | null;
         quantity: number;
@@ -227,12 +235,19 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     paymentSelection: PaymentSelection;
     isMembershipFastTrack: boolean;
     waitlistClaim: import("../../shared/useWaitlistClaim").UseWaitlistClaimResult;
-    eligibility: import("./types").EligibilityData | null;
+    eligibility: EligibilityData | null;
     eligibilityLoading: boolean;
     eligibilityError: string | null;
     existingRegistration: import("../../api").CustomerEventRegistration | null;
     existingRegistrationLoading: boolean;
     existingRegistrationState: import("./hooks.state").ExistingRegistrationLookupState;
+    registrationState: Readonly<{
+        kind: "none";
+    }> | Readonly<{
+        kind: "booked";
+    }> | Readonly<{
+        kind: "waitlisted";
+    }>;
     hasEligibility: boolean;
     hasMembershipEligibility: boolean;
     requireGuestDetails: boolean;

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

@@ -0,0 +1,20 @@
+import { type Dispatch, type SetStateAction } from 'react';
+import type { ResolveWaitlistClaimResponse } from '../../api/types';
+import type { EventTicketSelectionLine, FormData, Guest, RegistrationEvent, RegistrationStep } from './types';
+export type WaitlistClaimRestorationSetters = Readonly<{
+    setErrorMessage: Dispatch<SetStateAction<string>>;
+    setStep: (step: RegistrationStep) => void;
+    setSelectedEvent: Dispatch<SetStateAction<RegistrationEvent | null>>;
+    setAttendanceMode: Dispatch<SetStateAction<'in_person' | 'online' | null>>;
+    setTicketSelections: Dispatch<SetStateAction<EventTicketSelectionLine[]>>;
+    setSlidingAmountInput: Dispatch<SetStateAction<string>>;
+    setTicketsCount: (count: number) => void;
+    setFormData: Dispatch<SetStateAction<FormData>>;
+    setGuests: Dispatch<SetStateAction<Guest[]>>;
+}>;
+export declare function useWaitlistClaimRestoration(input: Readonly<{
+    claim: ResolveWaitlistClaimResponse | null;
+    scopedEvents: readonly RegistrationEvent[];
+    occurrenceContextId?: string;
+    setters: WaitlistClaimRestorationSetters;
+}>): void;

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

@@ -1,6 +1,9 @@
-import type { EligibilityCheckResponse } from '../../api/types';
+import type { RegistrationOptionsResponse } from '../../api/types';
 import type { EligibilityData, EligibilityEventTicketType, PublicEvent, PublicEventTicketType, RegistrationEvent } from './types';
 export declare const DEFAULT_EVENT_CURRENCY = "usd";
+export declare function getPortalSubjectEmail(profile: Readonly<{
+    email: string;
+}> | null): string | null;
 export type SelectableEventTicketType = EligibilityEventTicketType | PublicEventTicketType;
 type TicketTypeSourceEvent = PublicEvent | RegistrationEvent;
 /**
@@ -24,15 +27,6 @@ export declare function formatEventDateTime(isoTimestamp: string, options?: {
     timeZone?: string | null;
     locale?: string;
 }): string;
-/**
- * Build the registration API endpoint URL
- *
- * @param apiBaseUrl - The dashboard API base URL (e.g., "http://localhost:4000/api")
- * @param siteId - The site ID
- * @param customEndpoint - Optional custom endpoint override
- * @returns The full API endpoint URL
- */
-export declare function buildRegistrationEndpoint(apiBaseUrl: string, siteId: string, customEndpoint?: string): string;
 export { formatPrice } from '../../shared';
 /** Tooltip text shown when pass/membership redemptions are unavailable for multi-ticket bookings. */
 export declare const ENTITLEMENT_SINGLE_TICKET_TOOLTIP = "Only available for single-ticket bookings";
@@ -51,31 +45,7 @@ export declare function areEntitlementsDisabledForTicketCount(ticketsCount: numb
  * @param creditsRemaining - Credits on the pass before this booking, if known
  */
 export declare function formatPassCreditUsageLabel(creditsRemaining: number | null | undefined): string;
-/**
- * Build the eligibility check endpoint URL
- *
- * @param apiBaseUrl - The dashboard API base URL (e.g., "http://localhost:4000/api")
- * @param siteId - The site ID
- * @param customEndpoint - Optional custom endpoint override
- * @returns The full API endpoint URL
- */
-export declare function buildEligibilityEndpoint(apiBaseUrl: string, siteId: string, customEndpoint?: string): string;
-/**
- * Build the checkout endpoint URL
- *
- * @param apiBaseUrl - The dashboard API base URL (e.g., "http://localhost:4000/api")
- * @param siteId - The site ID
- * @param customEndpoint - Optional custom endpoint override
- * @returns The full API endpoint URL
- */
-export declare function buildCheckoutEndpoint(apiBaseUrl: string, siteId: string, customEndpoint?: string): string;
-/**
- * Transform API eligibility response to internal eligibility data.
- *
- * @param response - The raw API response from checkEligibility
- * @returns Transformed eligibility data for component use
- */
-export declare function transformEligibilityResponse(response: EligibilityCheckResponse): EligibilityData;
+export declare function transformRegistrationOptionsResponse(response: RegistrationOptionsResponse): EligibilityData;
 export declare function getTicketTypeAvailabilityLabel(ticketType: Pick<SelectableEventTicketType, 'availability'>): string | null;
 export declare function getVisibleTicketTypes(input: {
     event: TicketTypeSourceEvent | null;
@@ -89,24 +59,3 @@ export declare function findSelectedTicketType(input: {
     selectedTicketTypeId: string | null;
     selectedAttendanceMode?: 'in_person' | 'online' | null;
 }): SelectableEventTicketType | null;
-/**
- * Check if card payment is the only available option.
- *
- * Returns true when:
- * - Event requires payment (not free)
- * - User can pay directly (card payment enabled)
- * - User has no eligible passes
- * - User has no eligible memberships
- * - No passes are available for purchase (upsells)
- * - No memberships are available for purchase (upsells)
- *
- * Used to pre-select stripe in PaymentSelectionStep when there's only one option.
- */
-export declare function isOnlyCardPaymentAvailable(eligibility: EligibilityData | null): boolean;
-/**
- * Like `isOnlyCardPaymentAvailable`, but accounts for ticket-count rules.
- *
- * Passes/memberships (and pass/membership bundles) are disabled for multi-ticket bookings,
- * so they shouldn't prevent us auto-selecting card when they're visible-but-disabled.
- */
-export declare function isOnlyCardPaymentAvailableForTicketCount(eligibility: EligibilityData | null, ticketsCount: number): boolean;

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

@@ -1,2 +1,3 @@
 import type { FormData } from './types';
-export declare function validateFormData(formData: FormData): Partial<Record<keyof FormData, string>>;
+export declare function createInitialRegistrationFormData(): FormData;
+export declare function validateFormData(formData: FormData, requiresConsent?: boolean): Partial<Record<keyof FormData, string>>;

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

@@ -0,0 +1,20 @@
+import type { ResolveWaitlistClaimResponse } from '../../api/types';
+import type { EventTicketSelectionLine, RegistrationEvent } from './types';
+export type WaitlistClaimRestoration = Readonly<{
+    ok: false;
+    message: string;
+}> | Readonly<{
+    ok: true;
+    event: RegistrationEvent | null;
+    attendanceMode: 'in_person' | 'online';
+    ticketSelections: readonly EventTicketSelectionLine[];
+    ticketsCount: number;
+    slidingAmountInput: string | null;
+}>;
+export declare function resolveWaitlistClaimRestoration(input: Readonly<{
+    claim: ResolveWaitlistClaimResponse;
+    scopedEvents: readonly RegistrationEvent[];
+    occurrenceContextId?: string;
+}>): WaitlistClaimRestoration;
+export declare function resolveClaimedTicketSelections(claim: ResolveWaitlistClaimResponse | null): readonly EventTicketSelectionLine[] | null;
+export declare function resolveClaimTicketCount(claim: ResolveWaitlistClaimResponse | null, fallback: number): number;