@riverbankcms/sdk 0.134.0 → 0.135.1

package/dist/_dts/blocks/src/system/runtime/nodes/event-details/WholeSeriesPricingDisplay.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { ResolvedWholeSeriesPricingState } from '../../../blocks/events/whole-series';
+type WholeSeriesPricingDisplayProps = {
+    pricing: ResolvedWholeSeriesPricingState;
+    acceptedItems: readonly string[];
+};
+export declare function WholeSeriesPricingDisplay({ pricing, acceptedItems, }: WholeSeriesPricingDisplayProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { RegistrationTicketType } from './types';
+export declare function EventRegistrationBookingLayer(props: Readonly<{
+    registrationRootClassName: string;
+    portalRoot: HTMLElement | null;
+    overlayOpen: boolean;
+    isWizardStep: boolean;
+    priceLabel: string | null;
+    availabilityLabel: string | null;
+    ticketTypes: readonly RegistrationTicketType[];
+    ticketCurrency: string | null;
+    buttonClass: string;
+    formatTicketPrice: (ticketType: RegistrationTicketType) => string;
+    onOpen: () => void;
+    onClose: () => void;
+    overlaySurface: React.ReactNode;
+}>): React.JSX.Element;

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

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
+export type EventPortalAuthCopy = Readonly<{
+    title: string;
+    description: string;
+    buttonText: string;
+}>;
+export declare function EventRegistrationSurface(props: Readonly<{
+    variant: 'inline' | 'overlay';
+    wizard: UseEventRegistrationWizardResult;
+    isWizardStep: boolean;
+    currentStepNumber: number;
+    totalSteps: number;
+    stepLabels: string[];
+    showPortalAuthPrompt: boolean;
+    portalAuthCopy: EventPortalAuthCopy;
+    showVenue: boolean;
+    showCapacity: boolean;
+    showSpamProtection: boolean;
+    buttonText: string;
+    buttonClass: string;
+    supportEmail?: string;
+    successMessage: string;
+}>): React.JSX.Element;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { EligibilityData, PaymentStepState } from './types';
+export declare function resolvePaymentStepStatus(input: Readonly<{
+    loading: boolean;
+    error: string | null;
+    eligibility: EligibilityData | null;
+}>): PaymentStepState['status'];
+export declare function shouldPromptForLogin(status: PaymentStepState['status'], isAuthenticated: boolean, eligibility: EligibilityData | null): boolean;
+export declare function PaymentBlockingPanel(props: Readonly<{
+    eligibility: EligibilityData | null;
+    eligibilityLoading: boolean;
+    eligibilityError: string | null;
+    occurrenceId: string;
+    email: string;
+    ticketsCount: number;
+    isAuthenticated: boolean;
+    onRequestLogin?: () => void;
+}>): React.JSX.Element | null;

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

@@ -1,6 +1,10 @@
 import React from 'react';
 import type { EventTicketSelectionLine, OccurrenceContext, RegistrationAttendanceMode, RegistrationEvent } from './types';
 import { getVisibleTicketTypes } from './utils';
+export type TicketSelectionBookingUnit = Readonly<{
+    kind: 'ticket' | 'place';
+    includedSessionCount?: number;
+}>;
 type TicketSelectionStepProps = {
     event: RegistrationEvent | null;
     occurrenceContext?: OccurrenceContext | null;
@@ -20,6 +24,7 @@ type TicketSelectionStepProps = {
     slidingScaleSelectionMessage?: string | null;
     onSlidingAmountChange?: (amount: string) => void;
     onTicketsChange: (count: number) => void;
+    bookingUnit?: TicketSelectionBookingUnit;
 };
 /**
  * Ticket Selection Step

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

@@ -1 +1,2 @@
 export declare const EVENT_REGISTRATION_ANCHOR_ID = "event-registration";
+export declare const EVENT_REGISTRATION_CHECKOUT_ATTEMPT_PARAM = "registration_attempt";

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

@@ -127,7 +127,7 @@ export type EventRegistrationPaymentSelection = Readonly<{
     method: 'free';
 }> | Readonly<{
     method: 'stripe';
-    collectionOptionKind?: DirectCheckoutCollectionOptionKind;
+    collectionOptionKind: DirectCheckoutCollectionOptionKind;
 }> | Readonly<{
     method: 'pass';
     passId: string;
@@ -239,7 +239,6 @@ export type EventRegistrationOverridePropsLike = Readonly<{
         showVenue: boolean | null;
         showCapacity: boolean | null;
         successMessage: string | null;
-        waitlistMessage: string | null;
         buttonVariant: BlockButtonRole | null;
         buttonText: string | null;
         spamProtectionEnabled: boolean | null;
@@ -268,7 +267,6 @@ export type EventRegistrationOverrideInput = Readonly<{
     showVenue?: boolean;
     showCapacity?: boolean;
     successMessage?: string;
-    waitlistMessage?: string;
     buttonText?: string | null;
     buttonVariant?: BlockButtonRole;
     spamProtectionEnabled?: boolean;

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

@@ -1,12 +1,14 @@
 import type { DirectCheckoutCollectionOptionKind } from '../../api/types';
 import type { BlockBookingPaymentCollectionOption, BlockBookingPaymentTerms } from '../../../blocks/shared/bookingPaymentTerms';
+import type { EventRegistrationAvailablePaymentOption } from '../../../blocks/event-registration';
 import { type BookingPaymentOptionViewModel } from '../../shared/bookingPaymentOptions';
 import type { PaymentSelection } from './types';
-type SupportedEventDirectPaymentOption = Extract<BlockBookingPaymentCollectionOption, {
-    kind: 'upfront' | 'flexible_balance';
+type EventDirectPaymentOption = Extract<BlockBookingPaymentCollectionOption, {
+    kind: 'upfront' | 'deferred_manual' | 'instalment_plan' | 'flexible_balance';
 }>;
+export declare function getApprovedDirectPaymentCollectionOptionKinds(paymentOptions: readonly EventRegistrationAvailablePaymentOption[]): readonly DirectCheckoutCollectionOptionKind[];
 export type EventRegistrationDirectPaymentOption = Omit<BookingPaymentOptionViewModel, 'kind' | 'title'> & Readonly<{
-    kind: Extract<DirectCheckoutCollectionOptionKind, SupportedEventDirectPaymentOption['kind']>;
+    kind: Extract<DirectCheckoutCollectionOptionKind, EventDirectPaymentOption['kind']>;
     label: string;
     totalCents: number;
     configuredPaymentDueNowCents: number;
@@ -33,7 +35,8 @@ export type EventRegistrationDirectPaymentSelectionState = Readonly<{
 }>;
 export declare function buildEventRegistrationPaymentOptionsViewModel(input: Readonly<{
     eventTitle: string;
-    paymentTerms?: BlockBookingPaymentTerms | null;
+    approvedPaymentOptions: readonly EventRegistrationAvailablePaymentOption[];
+    paymentTerms: BlockBookingPaymentTerms;
     totalPriceCents: number;
     currency: string;
     startsAt?: string | null;

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

@@ -36,5 +36,4 @@ export declare const eventRegistrationPageSurfaceSubjectSchema: z.ZodType<EventR
 export declare function parseEventRegistrationPageSurfaceSubject(value: unknown): Result<EventPageSurfaceSubject, EventRegistrationPageSurfaceSubjectParseError>;
 export declare function normalizeEventRegistrationPageSurfaceSubject(value: unknown): EventRegistrationPageSurfaceSubject | null;
 export declare function resolveEventRegistrationScope(context: EventRegistrationScopeContext): EventRegistrationScope;
-export declare function applyEventRegistrationScope<TEvent extends EventRegistrationScopeableEvent>(events: readonly TEvent[], scope: EventRegistrationScope): TEvent[];
 export declare function resolveEventRegistrationScopedEvents<TEvent extends EventRegistrationScopeableEvent>(events: readonly TEvent[], context: EventRegistrationScopeContext): TEvent[];

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

@@ -6,7 +6,7 @@
  */
 import { useBlockApi } from '../../api';
 import type { PortalCredit } from '../../api';
-import type { EventTicketSelectionLine } from './types';
+import type { EventTicketSelectionLine, RegistrationSubject } from './types';
 import { type EligibilityLookupState, type ExistingRegistrationLookupState } from './hooks.state';
 export type PortalAuthState = 'checking' | 'authenticated' | 'unauthenticated';
 export type PortalProfile = {
@@ -37,8 +37,6 @@ export type UsePortalAuthResult = {
     isChecking: boolean;
     /** Portal profile data (only available when authenticated) */
     profile: PortalProfile | null;
-    /** Site credit loaded for the same authenticated portal identity. */
-    creditState: PortalCreditState;
     /** Logout function */
     logout: () => void;
 };
@@ -58,22 +56,23 @@ export type UseEligibilityResult = {
     eligibility: EligibilityLookupState['eligibility'];
     isLoading: boolean;
     error: EligibilityLookupState['error'];
+    creditState: PortalCreditState;
 };
 export declare function useEligibility(params: {
     enabled: boolean;
-    occurrenceId: string;
+    subject: RegistrationSubject | null;
     attendanceMode?: 'in_person' | 'online' | null;
     ticketSelections: readonly EventTicketSelectionLine[];
     selectedSlidingAmount?: number | null;
-    email: string;
+    subjectEmail: string | null;
 }): UseEligibilityResult;
 export declare function useEligibilityWithDeps(params: {
     enabled: boolean;
-    occurrenceId: string;
+    subject: RegistrationSubject | null;
     attendanceMode?: 'in_person' | 'online' | null;
     ticketSelections: readonly EventTicketSelectionLine[];
     selectedSlidingAmount?: number | null;
-    email: string;
+    subjectEmail: string | null;
 }, deps: EventRegistrationHooksDeps): UseEligibilityResult;
 export type UseExistingEventRegistrationResult = {
     state: ExistingRegistrationLookupState;
@@ -85,5 +84,5 @@ type UseExistingEventRegistrationParams = {
     occurrenceId: string;
 };
 export declare function useExistingEventRegistration({ isAuthenticated, occurrenceId, }: UseExistingEventRegistrationParams): UseExistingEventRegistrationResult;
-export declare function useExistingEventRegistrationWithDeps({ isAuthenticated, occurrenceId, }: UseExistingEventRegistrationParams, deps: EventRegistrationHooksDeps): UseExistingEventRegistrationResult;
+export declare function useExistingEventRegistrationWithDeps({ isAuthenticated, occurrenceId }: UseExistingEventRegistrationParams, deps: EventRegistrationHooksDeps): UseExistingEventRegistrationResult;
 export {};

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

@@ -9,7 +9,7 @@ export { AttendeeDetailsStep } from './AttendeeDetailsStep';
 export { MembershipHero } from './MembershipHero';
 export { PaymentSelectionStep } from './PaymentSelectionStep';
 export type { PaymentMethod } from './PaymentSelectionStep';
-export type { EligibilityCheckResponse, EligiblePass, EligibleMembership, AvailablePass, AvailableMembership, } from '../../api/types';
+export type { EligiblePass, EligibleMembership, AvailablePass, AvailableMembership, } from '../../api/types';
 export { SuccessStep } from './SuccessStep';
 export { ErrorStep } from './ErrorStep';
 export { VerifyingPaymentStep } from './VerifyingPaymentStep';

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/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 {};