@riverbankcms/sdk 0.136.0 → 0.138.0

package/dist/_dts/blocks/src/system/runtime/hooks/useCalendarEvents.state.d.ts

@@ -1,29 +1,27 @@
 import type { CalendarDate } from '../../../../../calendar/src/index';
-export type CalendarLoadScope = Readonly<{
-    anchorDate: CalendarDate;
-    filtersKey: string;
-}>;
-export type CalendarEventCacheLoadState = Readonly<{
-    kind: 'idle';
+import type { PublicEvent } from '../../blocks/events/shared/types';
+import { type CalendarWindowPage, type CalendarMonthWindow, type CalendarSourceCursor } from '../../blocks/events/shared/calendarWindow';
+type MonthState = Readonly<{
+    events: readonly PublicEvent[];
+}> & (Readonly<{
+    kind: 'partial';
+    continuation: CalendarRequest;
 }> | Readonly<{
     kind: 'loading';
-    scope: CalendarLoadScope;
-}> | Readonly<{
-    kind: 'error';
-    scope: CalendarLoadScope;
-    error: Error;
-}>;
-export type CalendarEventCacheLoadAction = Readonly<{
-    type: 'started';
-    scope: CalendarLoadScope;
+    request: CalendarRequest;
 }> | Readonly<{
-    type: 'succeeded';
-    scope: CalendarLoadScope;
+    kind: 'ready';
 }> | Readonly<{
-    type: 'failed';
-    scope: CalendarLoadScope;
+    kind: 'failed';
     error: Error;
+    continuation: CalendarRequest;
+}>);
+export type CalendarRequest = Readonly<{
+    months: readonly string[];
+    'window': CalendarMonthWindow;
+    cursor?: CalendarSourceCursor;
 }>;
+export type CalendarCacheState = ReadonlyMap<string, MonthState>;
 export type CalendarViewLoadState = Readonly<{
     kind: 'idle';
 }> | Readonly<{
@@ -32,6 +30,24 @@ export type CalendarViewLoadState = Readonly<{
     kind: 'error';
     error: Error;
 }>;
-export declare function calendarEventCacheLoadReducer(state: CalendarEventCacheLoadState, action: CalendarEventCacheLoadAction): CalendarEventCacheLoadState;
-export declare function projectCalendarLoadState(state: CalendarEventCacheLoadState, scope: CalendarLoadScope): CalendarViewLoadState;
-export declare function toCalendarEventCacheLoadError(error: unknown): Error;
+export type CalendarCacheAction = Readonly<{
+    kind: 'started';
+    request: CalendarRequest;
+}> | Readonly<{
+    kind: 'page';
+    request: CalendarRequest;
+    page: CalendarWindowPage;
+}> | Readonly<{
+    kind: 'failed';
+    request: CalendarRequest;
+    error: Error;
+    cursor?: CalendarSourceCursor;
+}>;
+export declare function calendarMonthKey(date: CalendarDate): string;
+export declare function calendarWindowMonths(date: CalendarDate, radius: number): readonly string[];
+export declare function seedCalendarWindow(page: CalendarWindowPage): CalendarCacheState;
+export declare function planCalendarRequest(state: CalendarCacheState, months: readonly string[], retry: boolean): CalendarRequest | null;
+export declare function calendarCacheReducer(state: CalendarCacheState, action: CalendarCacheAction): CalendarCacheState;
+export declare function selectCalendarEvents(state: CalendarCacheState, months: readonly string[]): PublicEvent[];
+export declare function projectCalendarLoadState(state: CalendarCacheState, months: readonly string[]): CalendarViewLoadState;
+export {};

package/dist/_dts/blocks/src/system/runtime/hooks/useHeadlessEventRegistrationFlow.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { type BlockApiConfig } from '../api';
 import type { EventRegistrationClientProps } from '../nodes/event-registration/types';
 import { useEventRegistrationWizard } from '../nodes/event-registration/useEventRegistrationWizard';
+import type { EventRegistrationPageSurfaceSubject } from '../nodes/event-registration/eventScope';
 import type { HeadlessEventRegistrationFlow } from '../nodes/event-registration/event-registration.headless.state';
 import { createEventRegistrationBlockApiConfig } from '../nodes/event-registration/event-registration.headless.state';
 export type { BlockApiConfig };
@@ -11,6 +12,12 @@ export type { EventRegistrationSubmitOptions, EventRegistrationSubmitResult, } f
 export type HeadlessEventRegistrationFlowOptions = Readonly<{
     anchorId?: string;
     occurrenceContext?: EventRegistrationClientProps['occurrenceContext'];
+    /**
+     * The Event page surface this flow belongs to. A whole-series journey needs
+     * it: the subject names the offering and the runs on offer, which is how the
+     * flow narrows occurrence-grained events down to one run.
+     */
+    subject?: EventRegistrationPageSurfaceSubject | null;
     events?: readonly NonNullable<EventRegistrationClientProps['events']>[number][];
     maxTickets?: string | number;
     spamProtectionEnabled?: boolean;

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

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

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

@@ -1,4 +1,5 @@
-import type { PublicEvent } from '../../../blocks/events/shared/types';
+import { type WholeSeriesBookingPhase } from '../../../../../../core/src/index';
+import type { PublicEvent, PublicRunSession, PublicWholeSeriesRun, PublicWholeSeriesRunLifecycle } from '../../../blocks/events/shared/types';
 import { type EventRegistrationPageSurfaceSubject } from '../event-registration/eventScope';
 export { filterPassesForEvent, filterMembershipsForEvent, } from '../events/shared/eventProductEligibility';
 export type OccurrenceContextLike = {
@@ -28,11 +29,22 @@ export type EventDetailsSelection = Readonly<{
     timeZone: string;
 }> | Readonly<{
     kind: 'wholeSeries';
-    phase: 'upcoming' | 'inProgress' | 'completed';
+    /**
+     * Where the run sits in its own life, and whether it still takes
+     * bookings — both from the run itself, re-read against the render clock.
+     *
+     * The run is the authority for these. Deriving them from whichever
+     * occurrence rows arrived is how this block came to say bookings were
+     * open on a run the page's own booking panel had already called
+     * cancelled.
+     */
+    lifecycle: PublicWholeSeriesRunLifecycle;
+    bookingPhase: WholeSeriesBookingPhase;
     mode: 'selected' | 'next' | 'completed';
     selected: WholeSeriesPublicEvent;
-    otherDates: WholeSeriesPublicEvent[];
-    sessions: readonly [WholeSeriesPublicEvent, ...WholeSeriesPublicEvent[]];
+    run: PublicWholeSeriesRun;
+    /** Every session of the run, in schedule order, cancellations included. */
+    sessions: readonly PublicRunSession[];
     timeZone: string;
 }>;
 export declare function selectEventDetails(args: {

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

@@ -1,12 +1,10 @@
 import React from 'react';
+import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
 type ErrorStepProps = {
     message: string;
     onRetry: () => void;
+    action?: EventRegistrationErrorAction;
+    canJoinWaitlist?: boolean;
 };
-/**
- * Error Step
- *
- * Displays an error message with a retry button when registration fails.
- */
 export declare const ErrorStep: React.FC<ErrorStepProps>;
 export {};

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

@@ -12,8 +12,10 @@ export declare function resolveDetailsButtonText(input: Readonly<{
     hasWaitlistClaim: boolean;
     fallbackText: string;
 }>): string;
-export declare function EventRegistrationWizardActions(props: {
+type WizardActionsProps = Readonly<{
     wizard: UseEventRegistrationWizardResult;
     buttonText: string;
     buttonClass: string;
-}): React.JSX.Element | null;
+}>;
+export declare function EventRegistrationWizardActions(props: WizardActionsProps): React.JSX.Element | null;
+export {};

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

@@ -20,7 +20,7 @@ type PaymentSelectionStepProps = {
     /** Whether the user is authenticated via portal bearer token */
     isAuthenticated?: boolean;
     creditState?: PortalCreditState;
-    directPaymentTotalCents?: number;
+    directPaymentTotalCents: number;
     manualDiscountPending?: boolean;
     /** Current canonical selection from wizard state */
     selectedSelection: PaymentSelection;

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

@@ -1,4 +1,5 @@
 import type { DirectCheckoutCollectionOptionKind, PaymentMethod } from '../../api/types';
+import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
 import type { EventRegistrationDirectPaymentOption, EventRegistrationDirectPaymentSelectionState } from './eventPaymentOptions';
 import type { EventRegistrationPageSurfaceSubject } from './eventScope';
 import type { EligibilityData, EventTicketSelectionLine, FormData, Guest, GuestErrors, OccurrenceContext, PaymentSelection, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult } from './types';
@@ -52,6 +53,7 @@ export type EventRegistrationFlowStatus = Readonly<{
 }> | Readonly<{
     tag: 'error';
     message: string;
+    action?: EventRegistrationErrorAction;
 }>;
 export type EventRegistrationFlowView = Readonly<{
     kind: 'empty';
@@ -102,8 +104,8 @@ export type EventRegistrationTicketsModel = Readonly<{
     max: number;
     selections: readonly EventTicketSelectionLine[];
     summaryLines: UseEventRegistrationWizardResult['ticketSelectionSummaryLines'];
-    subtotalCents: number;
-    selectedTicketTypeId: string | null;
+    subtotalCents: number | null;
+    selectedPricingOptionId: string | null;
     selectedTicketType: SelectableEventTicketType | null;
     visibleTicketTypes: readonly SelectableEventTicketType[];
     selectionRequired: boolean;
@@ -193,7 +195,7 @@ export type EventRegistrationTerminalModel = Readonly<{
 export type EventRegistrationFlowActions = Readonly<{
     selectEvent: (event: RegistrationEvent) => void;
     selectAttendanceMode: (mode: 'in_person' | 'online' | null) => void;
-    selectTicketType: (ticketTypeId: string | null) => void;
+    selectTicketType: (pricingOptionId: string | null) => void;
     setTicketSelections: (lines: readonly EventTicketSelectionLine[]) => void;
     setTicketsCount: (count: number) => void;
     updateAttendee: (values: FormData) => void;

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

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

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

@@ -1,6 +1,6 @@
 import { type EventPageSurfaceSubject, type EventPageSurfaceSubjectParseError, type EventOfferingId, type EventSeriesId, type Result } from '../../../../../../core/src/index';
 import { z } from 'zod';
-export declare const unsupportedEventRegistrationPageSurfaceSubjectReasons: readonly ["unsupportedSubject", "invalidEventSeriesId", "invalidEventSeriesBookingScope", "invalidEventOfferingId"];
+export declare const unsupportedEventRegistrationPageSurfaceSubjectReasons: readonly ["unsupportedSubject", "invalidEventSeriesId", "invalidEventSeriesBookingScope", "invalidEventOfferingId", "invalidEventOfferingBookingScope", "invalidEventOfferingCatalogue"];
 export type UnsupportedEventRegistrationPageSurfaceSubjectReason = (typeof unsupportedEventRegistrationPageSurfaceSubjectReasons)[number];
 export type EventRegistrationPageSurfaceSubject = EventPageSurfaceSubject | Readonly<{
     kind: 'unsupported';

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

@@ -59,6 +59,7 @@ export type UseEligibilityResult = {
     creditState: PortalCreditState;
 };
 export declare function useEligibility(params: {
+    refreshKey?: number;
     enabled: boolean;
     subject: RegistrationSubject | null;
     attendanceMode?: 'in_person' | 'online' | null;
@@ -67,6 +68,7 @@ export declare function useEligibility(params: {
     subjectEmail: string | null;
 }): UseEligibilityResult;
 export declare function useEligibilityWithDeps(params: {
+    refreshKey?: number;
     enabled: boolean;
     subject: RegistrationSubject | null;
     attendanceMode?: 'in_person' | 'online' | null;

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

@@ -0,0 +1,15 @@
+import type { EligibilityData } from './types';
+export declare function resolveRegistrationAvailabilityBlocker(input: Readonly<{
+    hasWaitlistClaim: boolean;
+    eligibility: EligibilityData | null;
+    eligibilityError: string | null;
+}>): string | null;
+export declare function resolvePricingSelectionBlocker(input: Readonly<{
+    selectionRequired: boolean;
+    hasValidSelection: boolean;
+    slidingScaleSelectionMessage: string | null;
+}>): string | null;
+export declare function isSoldOutWithoutWaitlist(input: Readonly<{
+    hasWaitlistClaim: boolean;
+    eligibility: EligibilityData | null;
+}>): boolean;

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

@@ -1,5 +1,5 @@
 import type { DiscountContext } from '../../api/types';
-import type { EligibilityData, EligibilityEventTicketType, OccurrenceContext, PaymentSelection, PublicEventTicketType, RegistrationEvent, RegistrationSubject } from './types';
+import type { EligibilityData, OccurrenceContext, PaymentSelection, PublicEventPricingOption, RegistrationEvent, RegistrationSubject } from './types';
 export type RegistrationTarget = Readonly<{
     subject: RegistrationSubject;
     selectedEventId: string | null;
@@ -16,7 +16,7 @@ export declare function resolveRegistrationTarget(input: Readonly<{
 }>): RegistrationTarget | null;
 export declare function resolveEventRequiresPayment(input: Readonly<{
     eligibility: Pick<EligibilityData, 'requiresPayment'> | null;
-    selectedTicketType: Pick<EligibilityEventTicketType | PublicEventTicketType, 'priceAmount'> | null;
+    selectedTicketType: Pick<PublicEventPricingOption, 'priceAmount'> | null;
     event: Pick<RegistrationEvent, 'pricing'> | null;
 }>): boolean;
 export declare function resolveDiscountContext(input: Readonly<{

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

@@ -0,0 +1,5 @@
+import { type EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
+export declare function registrationErrorPresentation(error: unknown): Readonly<{
+    message: string;
+    action: EventRegistrationErrorAction;
+}>;

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

@@ -0,0 +1,25 @@
+import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
+import type { EligibilityData, 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;
+    preSelectedEvent: RegistrationEvent | null;
+    dispatchFlow: (action: RegistrationFlowAction) => void;
+    setSelectedTicketLines: (lines: EventTicketSelectionLine[]) => void;
+    setSelectedSlidingAmountInput: (value: string) => void;
+    setSelectedAttendanceMode: (mode: 'online' | 'in_person' | null) => void;
+    setErrorMessage: (message: string) => void;
+    setPendingRegistrationReference: (reference: EventRegistrationStatusReference | null) => void;
+}>): void;
+/** Recovery never starts another payment. Unknown payment outcomes go to the portal. */
+export declare function recoverRegistrationError(action: EventRegistrationErrorAction, handlers: Readonly<{
+    canJoinWaitlist?: boolean;
+    refreshOptions: () => void;
+    clearError: () => void;
+    setStep: (step: RegistrationStep) => void;
+    reset: () => void;
+}>): void;

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

@@ -1,6 +1,17 @@
-import type { PublicWholeSeriesOffering } from '../../../blocks/events/whole-series';
+import type { PublicEventRunGroup } from '../../../blocks/events/shared/runGrouping';
 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[];
+/**
+ * Project one whole-series run onto the registration surface.
+ *
+ * Capacity, pricing, payment terms and consent come straight off the canonical
+ * Event record; only the schedule is widened from the single occurrence to the
+ * live run. A run without live sessions has no registration event.
+ */
+export declare function toWholeSeriesRegistrationEvent(group: PublicEventRunGroup): RegistrationEvent | null;
+export declare function toWholeSeriesRegistrationEvents(events: readonly PublicEvent[]): RegistrationEvent[];
+/** An occurrence-page context must not replace a whole run's booking start. */
+export declare function getRegistrationStartAt(event: Pick<RegistrationEvent, 'registrationSubject' | 'startsAt'> | null | undefined, occurrenceContext: Readonly<{
+    startsAt: string;
+}> | null | undefined): string | undefined;

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

@@ -1,36 +1,19 @@
-import type { PublicWholeSeriesOffering } from '../../../blocks/events/whole-series';
 import type { PublicEvent } from '../../../blocks/events/shared/types';
-import { type EventRegistrationScopeContext, type EventRegistrationScopeableEvent, type EventRegistrationPageSurfaceSubject } from './eventScope';
+import { type PublicEventRunGroup } from '../../../blocks/events/shared/runGrouping';
+import { type EventRegistrationPageSurfaceSubject } from './eventScope';
 export type EventRegistrationSurfacePlan = Readonly<{
     kind: 'occurrence';
     events: readonly PublicEvent[];
 }> | Readonly<{
     kind: 'wholeSeries';
-    offerings: readonly PublicWholeSeriesOffering[];
+    runs: readonly PublicEventRunGroup[];
 }> | Readonly<{
     kind: 'unavailableWholeSeries';
 }> | 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;
@@ -40,4 +23,3 @@ 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

@@ -1,5 +1,9 @@
 import type { EligibilityData, PaymentSelection, RegistrationEvent, RegistrationStep, RegistrationSubject } from './types';
 type PortalAuthState = 'checking' | 'authenticated' | 'unauthenticated';
+export declare function getEventSelectionDefaults(event: RegistrationEvent): Readonly<{
+    slidingAmountInput: string;
+    attendanceMode: 'online' | 'in_person' | null;
+}>;
 export declare function parseCurrencyInputToCents(value: string): number | null;
 export declare function formatCentsAsCurrencyInput(amount: number): string;
 export declare function getSlidingScaleForEvent(event: RegistrationEvent | null): Readonly<{

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

@@ -46,6 +46,3 @@ export declare function buildSelectedSiteCreditPreview(input: Readonly<{
     creditState: PortalCreditState;
     manualDiscountPending: boolean;
 }>): EventRegistrationSiteCreditPreview;
-export declare function resolveDirectPaymentTotalCents(explicitTotalCents: number | undefined, eligibility: Readonly<{
-    price: number | null;
-}> | null): number;

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

@@ -1,12 +1,21 @@
 import type { EventTicketSelectionLine } from './types';
-import type { SelectableEventTicketType } from './utils';
 export declare function normalizeTicketSelectionLines(lines: readonly EventTicketSelectionLine[]): EventTicketSelectionLine[];
 export declare function getTicketSelectionTotal(lines: readonly EventTicketSelectionLine[]): number;
-export declare function getTicketLineQuantity(lines: readonly EventTicketSelectionLine[], ticketTypeId: string | null): number;
-export declare function getSingleSelectedTicketTypeId(lines: readonly EventTicketSelectionLine[]): string | null;
+export declare function getTicketLineQuantity(lines: readonly EventTicketSelectionLine[], pricingOptionId: string | null): number;
+export declare function getSingleSelectedPricingOptionId(lines: readonly EventTicketSelectionLine[]): string | null;
+export declare function hasValidPricingOptionSelection(input: Readonly<{
+    selectionRequired: boolean;
+    lines: readonly EventTicketSelectionLine[];
+    visibleOptions: readonly Readonly<{
+        pricingOptionId: string;
+        availability: Readonly<{
+            kind: 'available' | 'unavailable';
+        }>;
+    }>[];
+}>): boolean;
 export declare function setTicketLineQuantity(input: Readonly<{
     lines: readonly EventTicketSelectionLine[];
-    ticketTypeId: string | null;
+    pricingOptionId: string | null;
     quantity: number;
 }>): EventTicketSelectionLine[];
 export declare function getTicketTypeLineMax(input: Readonly<{
@@ -16,21 +25,10 @@ export declare function getTicketTypeLineMax(input: Readonly<{
     availableSpots: number | null | undefined;
     ticketTypeRemainingCapacity: number | null;
 }>): number;
-export declare function calculateTicketSelectionSubtotal(input: Readonly<{
-    lines: readonly EventTicketSelectionLine[];
-    ticketTypes: readonly Pick<SelectableEventTicketType, 'id' | 'priceAmount'>[];
-    fallbackUnitPriceCents: number;
-}>): number;
 export type TicketSelectionSummaryLine = Readonly<{
-    ticketTypeId: string | null;
+    pricingOptionId: string | null;
     label: string;
     quantity: number;
     unitPriceCents: number;
     subtotalCents: number;
 }>;
-export declare function buildTicketSelectionSummaryLines(input: Readonly<{
-    lines: readonly EventTicketSelectionLine[];
-    ticketTypes: readonly Pick<SelectableEventTicketType, 'id' | 'name' | 'priceAmount'>[];
-    fallbackLabel: string;
-    fallbackUnitPriceCents: number;
-}>): TicketSelectionSummaryLine[];

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

@@ -1,9 +1,10 @@
 import type { PublicEventPricing } from '../../../../../../core/src/index';
-import type { PublicEvent, PublicEventTicketType, PublicEventTicketTypeAvailability } from '../../../blocks/events/shared/types';
+import type { EventRegistrationPricingOption } from '../../../blocks/event-registration';
+import type { PublicEvent, PublicEventPricingOption, PublicEventPricingOptionAvailability } 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 { PublicRunSession } from '../../../blocks/events/shared/types';
+import type { AvailablePass, AvailableMembership, DirectCheckoutCollectionOptionKind, EventTicketLineSummary } from '../../api/types';
 import type { BlockBookingPaymentTerms } from '../../../blocks/shared/bookingPaymentTerms';
 import type { EventRegistrationPageSurfaceSubject } from './eventScope';
 import type { BlockButtonRole } from '../../../constants/buttonRoles';
@@ -38,7 +39,7 @@ export type RegistrationResult = {
 };
 export type RegistrationAttendanceMode = 'in_person' | 'online';
 export type EventTicketSelectionLine = Readonly<{
-    ticketTypeId: string | null;
+    pricingOptionId: string | null;
     quantity: number;
 }>;
 /**
@@ -61,15 +62,15 @@ export type EligibilityData = {
     /** 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';
+    pricingStrategy: EventRegistrationOptionsResponse['pricing']['strategy'];
     /** Canonical collection terms for the selected registration. */
     paymentTerms: BlockBookingPaymentTerms;
     /** Selected ticket type echoed back from the eligibility API, if any. */
-    selectedTicketTypeId?: string | null;
+    selectedPricingOptionId?: string | null;
     /** Selected ticket-line pricing echoed back from the eligibility API. */
     ticketLines: EventTicketLineSummary[];
     /** Public ticket types available for selection in ticket-type mode. */
-    ticketTypes?: EligibilityEventTicketType[];
+    ticketTypes: readonly EventRegistrationPricingOption[];
     /** Whether the event is currently full for the requested ticket count */
     isFull: boolean;
     /** Whether waitlists are enabled for this event */
@@ -106,20 +107,21 @@ export type EligibilityData = {
     /** Memberships available for purchase (upsell) */
     availableMemberships: AvailableMembership[];
 };
-export type { EligibilityEventTicketType, PublicEventTicketType, PublicEventTicketTypeAvailability, };
-export type RegistrationTicketType = Pick<PublicEventTicketType, 'id' | 'name' | 'description' | 'priceAmount' | 'isActive' | 'sortOrder' | 'capacityMode' | 'capacityLimit' | 'attendanceScope' | 'saleStartsAt' | 'saleEndsAt' | 'availability'>;
+export type { PublicEventPricingOption, PublicEventPricingOptionAvailability };
+export type RegistrationTicketType = Pick<EventRegistrationPricingOption, 'pricingOptionId' | 'name' | 'description' | 'priceAmount' | 'isActive' | 'sortOrder' | 'attendanceScope' | 'saleStartsAt' | 'saleEndsAt' | 'availability'>;
 export type RegistrationSubject = Readonly<{
     kind: 'occurrence';
     occurrenceId: string;
 }> | Readonly<{
     kind: 'wholeSeries';
     eventSeriesId: string;
-    sessions: PublicWholeSeriesOffering['sessions'];
+    /** 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<{
     selectionId: string;
     registrationSubject: RegistrationSubject;
-    pricing: PublicEventPricing<RegistrationTicketType>;
+    pricing: PublicEventPricing;
 }>;
 /**
  * Payment selection state for the summary bar.
@@ -174,10 +176,6 @@ export type EventRegistrationClientProps = {
     occurrenceContext?: OccurrenceContext | null;
     subject?: EventRegistrationPageSurfaceSubject | null;
     events?: PublicEvent[] | null;
-    /** Canonical whole-series runs used when the scoped Event books the full series. */
-    wholeSeriesOfferings?: PublicWholeSeriesOffering[] | null;
-    /** Targeted whole-series offering loaded for a native Event page surface. */
-    wholeSeriesOffering?: PublicWholeSeriesOffering | null;
     maxTickets?: string;
     showVenue?: boolean;
     showCapacity?: boolean;

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

@@ -23,16 +23,20 @@ type EventRegistrationStripeReturnOptions = {
 };
 export type EventRegistrationStripeReturnDeps = Readonly<{
     usePaymentVerification: typeof usePaymentVerification;
-    consumeReturnParams: () => Readonly<{
+    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 declare function useEventRegistrationStripeReturn(options: EventRegistrationStripeReturnOptions): ReturnType<typeof usePaymentVerification>;
-export declare function useEventRegistrationStripeReturnWithDeps(options: EventRegistrationStripeReturnOptions, deps: EventRegistrationStripeReturnDeps): ReturnType<typeof usePaymentVerification>;
+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 {};

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

@@ -1,4 +1,5 @@
 import type { BlockApiClient } from '../../api';
+import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
 import { savePendingRegistration } from './sessionStorage';
 import type { EventTicketSelectionLine, FormData, Guest, RegistrationResult, RegistrationStep, PaymentSelection } from './types';
 import type { PaymentMethod } from '../../api/types';
@@ -37,18 +38,23 @@ export type UseEventRegistrationSubmitInput = {
     claimToken: string | null;
     setPendingRegistrationReference: (reference: EventRegistrationStatusReference) => void;
     setStep: (step: RegistrationStep) => void;
+    setErrorAction?: (action: EventRegistrationErrorAction) => void;
     setRegistrationResult: (result: RegistrationResult) => void;
     setErrorMessage: (message: string) => void;
 };
 export type EventRegistrationSubmitDeps = Readonly<{
     savePendingRegistration: typeof savePendingRegistration;
-    createCheckoutAttemptId: () => string;
+    /**
+     * Fresh UUID for one client-generated identity — a checkout attempt, or the
+     * registration command (issue 1273) keys the occurrence commit on.
+     */
+    createClientCommandId: () => string;
 }>;
-type CheckoutAttemptCryptoSource = Readonly<{
+type ClientCommandIdCryptoSource = Readonly<{
     randomUUID?: () => string;
     getRandomValues: (bytes: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBuffer>;
 }>;
-export declare function createCheckoutAttemptId(cryptoSource?: CheckoutAttemptCryptoSource): string;
+export declare function createClientCommandId(cryptoSource?: ClientCommandIdCryptoSource): 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 {};