@riverbankcms/sdk 0.151.0 → 0.153.0

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

@@ -1,25 +1,40 @@
+import type { RegistrationDisplay } from './registrationDisplay';
+import type { ResolvedRegistrationPresentation } from './finishedBooking';
 import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
 import type { ThemeButtonVariantId } from '../../../../../../theme-core/src/buttons/index';
+import { type RegistrationProgress, type RegistrationStepLabelContext } from './wizardSteps';
 export type EventPortalAuthCopy = Readonly<{
     title: string;
-    description: string;
+    description?: string;
     buttonText: string;
+    /** Words after the link, so it reads as one sentence. */
+    afterButton?: string;
+    /** Before the step's content when it blocks the booking; after it when it's an option. */
+    placement: 'before' | 'after';
 }>;
-export declare function EventRegistrationSurface(props: Readonly<{
-    variant: 'inline' | 'overlay';
+type EventRegistrationSurfaceProps = Readonly<{
+    variant: 'inPlace' | 'overlay';
     wizard: UseEventRegistrationWizardResult;
-    isWizardStep: boolean;
-    currentStepNumber: number;
-    totalSteps: number;
-    stepLabels: string[];
+    /** The wizard's presentation with any finished booking resolved. */
+    presentation: ResolvedRegistrationPresentation;
+    stepLabelContext: RegistrationStepLabelContext;
     showPortalAuthPrompt: boolean;
     portalAuthCopy: EventPortalAuthCopy;
-    showVenue: boolean;
-    showCapacity: boolean;
+    display: RegistrationDisplay;
     showSpamProtection: boolean;
     buttonText: string;
     buttonVariant: ThemeButtonVariantId;
     supportEmail?: string;
     successMessage?: string;
     demoEmailSuppressed?: boolean;
+    /** The panel's Done: closes it. Absent where the surface has nothing to close. */
+    onDone?: () => void;
+}>;
+/** The compact progress: in the step column in place, in the panel's pinned header on overlays. */
+export declare function EventRegistrationProgress(props: Readonly<{
+    progress: RegistrationProgress;
+    stepLabelContext: RegistrationStepLabelContext;
 }>): import("react").JSX.Element;
+/** Renders either the step layout or one whole-panel screen, never both. */
+export declare function EventRegistrationSurface(props: EventRegistrationSurfaceProps): import("react").JSX.Element;
+export {};

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

@@ -1,8 +1,10 @@
+import type { RegistrationDisplay } from './registrationDisplay';
 import React from 'react';
+import type { ThemeButtonVariantId } from '../../../../../../theme-core/src/buttons/index';
 import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
 export declare function EventRegistrationWizardContent(props: {
     wizard: UseEventRegistrationWizardResult;
-    showVenue: boolean;
-    showCapacity: boolean;
+    display: RegistrationDisplay;
     showSpamProtection?: boolean;
+    buttonVariant: ThemeButtonVariantId;
 }): React.JSX.Element | null;

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

@@ -1,14 +1,15 @@
+import type { RegistrationDisplay } from './registrationDisplay';
 import React from 'react';
 import type { RegistrationEvent } from './types';
 type EventSelectionStepProps = {
     events: RegistrationEvent[];
     selectedEvent: RegistrationEvent | null;
+    /** Chooses an event and moves on (unrelated events). */
     onSelect: (event: RegistrationEvent) => void;
-    showVenue?: boolean;
-    showCapacity?: boolean;
+    /** Marks a date as chosen without moving on; Continue moves on (dates). */
+    onChoose: (event: RegistrationEvent) => void;
+    display: RegistrationDisplay;
 };
-type EventSelectionMode = 'event' | 'date';
-export declare function getEventSelectionMode(events: readonly RegistrationEvent[]): EventSelectionMode;
 /**
  * Event Selection Step
  *

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

@@ -15,7 +15,7 @@ type GuestDetailsSectionProps = {
  * Guest Details Section
  *
  * Card-based layout for collecting additional attendee details.
- * Uses the same visual patterns as the main form (er-input, er-field, er-label, er-error).
+ * Uses the same fields as the main form: the theme's form-label and form-input.
  */
 export declare const GuestDetailsSection: React.FC<GuestDetailsSectionProps>;
 export {};

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

@@ -1,3 +1,4 @@
+import type { ThemeButtonVariantId } from '../../../../../../theme-core/src/buttons/index';
 import type { PaymentStatusRecoveryState } from './types';
 type PaymentStatusStepProps = Readonly<{
     state: PaymentStatusRecoveryState;
@@ -5,6 +6,7 @@ type PaymentStatusStepProps = Readonly<{
     onContinuePayment: () => void;
     onReturnToPayment: () => void;
     onReturnToBooking: () => void;
+    buttonVariant: ThemeButtonVariantId;
 }>;
 export declare function PaymentStatusStep(props: PaymentStatusStepProps): import("react").JSX.Element;
 export {};

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { EligibilityData } from './types';
+/**
+ * Passes and memberships cover one person, so with more than one place they
+ * are greyed out; this says why, in the open rather than in a hover tooltip.
+ */
+export declare function SingleTicketEntitlementNote(props: Readonly<{
+    ticketsCount: number;
+    eligibility: EligibilityData | null;
+    onBookOnePlace: () => void;
+}>): React.JSX.Element | null;

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

@@ -1,6 +1,7 @@
 import type { BookingMailingListNote as BookingSignupNote } from '../../../../../../core/src/index';
 import React from 'react';
 import type { BookingSuccessCopy } from '../booking-form.state';
+import { type ConfirmationPaymentPresentation, type ConfirmationSummaryRow } from './finishedBooking';
 type SuccessStepProps = {
     title?: string;
     copy: BookingSuccessCopy;
@@ -9,6 +10,9 @@ type SuccessStepProps = {
     context?: 'booking' | 'waitlist';
     demoEmailSuppressed?: boolean;
     customerEmail: string | null;
+    /** When, where, places and payment: only facts from the booking outcome. */
+    summary?: readonly ConfirmationSummaryRow[];
+    payment: ConfirmationPaymentPresentation;
 };
 /**
  * Success Step

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

@@ -1,3 +1,4 @@
+import { type RegistrationDisplay } from './registrationDisplay';
 import React from 'react';
 import type { EventTicketSelectionLine, OccurrenceContext, RegistrationAttendanceMode, RegistrationEvent } from './types';
 import { getVisibleTicketTypes } from './utils';
@@ -6,12 +7,16 @@ export type TicketSelectionBookingUnit = Readonly<{
     includedSessionCount?: number;
 }>;
 type TicketSelectionStepProps = {
+    display: RegistrationDisplay;
     event: RegistrationEvent | null;
     occurrenceContext?: OccurrenceContext | null;
     selectedAttendanceMode?: RegistrationAttendanceMode | null;
     onAttendanceModeChange?: (attendanceMode: RegistrationAttendanceMode) => void;
     ticketsCount: number;
     maxTickets: number;
+    /** The most places a single-price booking can ask for: `maxTickets`
+     * narrowed by settled availability (`placeCountCeiling`). Defaults to it. */
+    placesCeiling?: number;
     visibleTicketTypes?: ReturnType<typeof getVisibleTicketTypes>;
     ticketSelections?: readonly EventTicketSelectionLine[];
     onTicketSelectionsChange?: (lines: readonly EventTicketSelectionLine[]) => void;

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

@@ -1,9 +1,11 @@
 import React from 'react';
+import type { ThemeButtonVariantId } from '../../../../../../theme-core/src/buttons/index';
 type VerifyingTimeoutStepProps = {
     onCheckAgain?: () => void;
     supportEmail?: string;
     title?: string;
     message?: string;
+    buttonVariant?: ThemeButtonVariantId;
 };
 /**
  * Verifying Timeout Step

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

@@ -0,0 +1,31 @@
+import type { RegistrationDisplay } from './registrationDisplay';
+/**
+ * The booking card the server renders on CMS pages (issue 1581), and the
+ * offering noun it resolves for the wizard. Kept beside the island contract
+ * so the server and the client agree on one card.
+ */
+import { z } from 'zod';
+import type { PublicEvent } from '../../../blocks/events/shared/types';
+import type { EventRegistrationDisplay, EventRegistrationSourceProps } from '../event-registration.interactive';
+import { type IdleBookingEntry } from './bookingEntry';
+import { type OfferingNoun } from './offeringNoun';
+/**
+ * Where the booking panel lives. Pages built around booking (the system
+ * event page's sticky column, the hosted booking page) show it in place;
+ * a block an editor placed on a page shows the card, the bar and the
+ * overlay panel.
+ */
+export type BookingHost = 'overlay' | 'inPlace';
+export declare const bookingHostSchema: z.ZodEnum<{
+    overlay: "overlay";
+    inPlace: "inPlace";
+}>;
+export type { IdleBookingEntry };
+export declare const idleBookingEntrySchema: z.ZodType<IdleBookingEntry>;
+export declare function toScopedEventRegistrationEvents(scopedSourceEvents: readonly PublicEvent[]): import("./types").RegistrationEvent[];
+/** What the site calls the offering this block books, from its preset rows. */
+export declare function resolveOfferingNoun(source: EventRegistrationSourceProps, scopedSourceEvents: readonly PublicEvent[]): OfferingNoun;
+/** The server's card on CMS pages, or null where the shell still applies. */
+export declare function bookingCardDisplay(source: EventRegistrationSourceProps, scopedSourceEvents: readonly PublicEvent[], display: RegistrationDisplay): Extract<EventRegistrationDisplay, {
+    state: 'booking-card';
+}> | null;

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

@@ -0,0 +1,154 @@
+/**
+ * What the in-page booking card and the fixed booking bar say (issue 1581).
+ *
+ * One pure decision for both, so they never disagree. It is computed on the
+ * server from the public events (idle states only) and on the client from the
+ * wizard, and it never reads scroll or viewport facts: those decide only
+ * whether the bar is visible ({@link bookingBarVisible}).
+ */
+import type { PublicEventAttendanceMode } from '../../../blocks/events/shared/types';
+import { type RegistrationDisplay } from './registrationDisplay';
+import type { OfferingNoun } from './offeringNoun';
+import type { FinishedBooking, FinishedBookingEntry, ResolvedRegistrationPresentation } from './finishedBooking';
+import type { RegistrationEvent, RegistrationStep } from './types';
+import { type RegistrationRouteStep } from './wizardSteps';
+/** How many dates the card and bar show before "+ N more". */
+export declare const BOOKING_ENTRY_DATE_LIMIT = 4;
+export type BookingEntryDateTile = Readonly<{
+    month: string;
+    day: string;
+}>;
+export type BookingEntryDate = Readonly<{
+    selectionId: string;
+    label: string;
+    /** "3 left" or "Full"; null when capacity is hidden or plentiful. */
+    places: string | null;
+    full: boolean;
+}>;
+export type BookingEntryProgress = Readonly<{
+    label: string;
+    current: number;
+    total: number;
+}>;
+export type BookingEntry = Readonly<{
+    kind: 'single';
+    title: string;
+    /** Long form for the card and panel header: "Mon 5 Oct · 7:00pm – 8:15pm". */
+    when: string | null;
+    /** Short form for the bar: "Mon 5 Oct, 7:00pm". */
+    shortWhen: string | null;
+    venue: string | null;
+    price: string | null;
+    places: string | null;
+    tile: BookingEntryDateTile | null;
+    action: string;
+}> | Readonly<{
+    kind: 'chooseDate';
+    title: string;
+    schedule: string;
+    venue: string | null;
+    price: string | null;
+    nextDate: string | null;
+    dateCount: number;
+    dates: readonly BookingEntryDate[];
+    moreCount: number;
+    action: string;
+}> | Readonly<{
+    kind: 'chooseEvent';
+    title: string;
+    count: number;
+    noun: string;
+    action: string;
+}> | Readonly<{
+    kind: 'inProgress';
+    title: string;
+    progress: BookingEntryProgress | null;
+    action: string;
+}> | FinishedBookingEntry & Readonly<{
+    action: string;
+}>;
+/** The card's idle content: what can be said before a booking starts. */
+export type IdleBookingEntry = Extract<BookingEntry, {
+    kind: 'single' | 'chooseDate' | 'chooseEvent';
+}>;
+export type BookingEntryInput = Readonly<{
+    /** The events this block books, already scoped and adapted. */
+    events: readonly RegistrationEvent[];
+    /** The event the page or the visitor has chosen, if any. */
+    event: RegistrationEvent | null;
+    display: RegistrationDisplay;
+    /** The block's button text; falls back to "Book your place". */
+    buttonText: string | null | undefined;
+    noun: OfferingNoun;
+    attendanceMode: PublicEventAttendanceMode | null;
+    /** True once the visitor has moved past the first step, until it finishes. */
+    underway: boolean;
+    /** Where they are, when the panel is on a numbered step. */
+    progress: BookingEntryProgress | null;
+    /** Present once the booking finished, resolved once by resolveFinishedPresentation. */
+    finished: FinishedBooking | null;
+}>;
+export declare const DEFAULT_BOOKING_BUTTON_TEXT = "Book your place";
+/** Browse the page's dates on close while keeping the draft's resume action. */
+export declare function bookingCardEntry(input: BookingEntryInput & Readonly<{
+    pageEvent: RegistrationEvent | null;
+    panelOpen: boolean;
+    step: RegistrationStep;
+}>): BookingEntry;
+/** "Mon 5 Oct": the compact date the chips and the bar share. */
+export declare function formatBookingShortDate(event: RegistrationEvent): string;
+export type IdleBookingEntryInput = Pick<BookingEntryInput, 'events' | 'event' | 'display' | 'buttonText' | 'noun' | 'attendanceMode'>;
+/** The card before a booking starts; the server renders this too. */
+export declare function idleBookingEntry(input: IdleBookingEntryInput): IdleBookingEntry;
+/** The card and bar's content for the visitor's current position. */
+export declare function bookingEntry(input: BookingEntryInput): BookingEntry;
+/**
+ * Where the booking has got to, for the card and bar: underway once the
+ * visitor is past the first step or the panel shows a recovery screen, and
+ * finished once it is confirmed or waitlisted.
+ */
+export declare function bookingEntryProgress(input: Readonly<{
+    presentation: ResolvedRegistrationPresentation;
+    stepLabel: (step: RegistrationRouteStep) => string;
+}>): Pick<BookingEntryInput, 'underway' | 'progress' | 'finished'>;
+export type BookingPanelHeading = Readonly<{
+    title: string;
+    subtitle: string | null;
+}>;
+/** The panel header: the event's name, and when and where in one line. */
+export declare function bookingPanelHeading(entry: BookingEntry, display: RegistrationDisplay): BookingPanelHeading;
+export type BookingBarFacts = Readonly<{
+    panelOpen: boolean;
+    /** The card's edges relative to the viewport; null while it is known to be off screen. */
+    card: Readonly<{
+        top: number;
+        bottom: number;
+    }> | null;
+    viewportHeight: number;
+    barHeight: number;
+    /** With reduced motion the bar fades out as soon as the card arrives, without the push. */
+    reducedMotion: boolean;
+}>;
+export type BookingBarPlacement = Readonly<{
+    state: 'shown' | 'hidden';
+    /** How far the card has pushed the bar down, in px (0 when it isn't pushing). */
+    push: number;
+}>;
+/**
+ * How far a card rising from the bottom of the viewport has pushed the bar
+ * off: none until its top edge reaches the bottom, then in step with it,
+ * until the bar has gone entirely.
+ */
+export declare function barPush(input: Readonly<{
+    cardTop: number;
+    viewportHeight: number;
+    barHeight: number;
+}>): number;
+/**
+ * Where the bar sits (issue 1581). It shows whenever the card is off screen,
+ * from the first screen on, and stays out of the way while the panel is open.
+ * As the card comes up from the bottom of the screen it pushes the bar down
+ * in step, as if handing over to it, and the bar stays away while the card is
+ * on screen.
+ */
+export declare function bookingBarPlacement(facts: BookingBarFacts): BookingBarPlacement;

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

@@ -0,0 +1,12 @@
+/**
+ * Keyboard focus for the booking card, bar and panel (issue 1581). The bar
+ * turns inert while it is out of the way, so focus that would land on it, or
+ * is on it when it goes, needs somewhere reachable to go instead.
+ */
+/** Whether focus can land on the element now: in the page, outside any inert or hidden subtree. */
+export declare function isReachable(element: HTMLElement | null): element is HTMLElement;
+/**
+ * Focuses the preferred destination once it is reachable, waiting a few frames
+ * for it; if it never becomes reachable, the fallback takes focus instead.
+ */
+export declare function focusWhenReachable(preferred: () => HTMLElement | null, fallback: () => HTMLElement | null, frame?: number): void;

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

@@ -6,7 +6,7 @@ import type { EligibilityData, EventTicketSelectionLine, FormData, Guest, GuestE
 import type { SelectableEventTicketType } from './utils';
 import type { BlockButtonRole } from '../../../constants/buttonRoles';
 import type { PortalAuthState, PortalProfile } from './hooks';
-import type { UseWaitlistClaimResult } from '../../shared/useWaitlistClaim';
+import type { WaitlistInvitation } from './registrationDraft.state';
 import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
 import type { EventRegistrationSubmitResult } from './useEventRegistrationSubmit';
 export declare const DEFAULT_EVENT_REGISTRATION_MAX_TICKETS = 5;
@@ -247,7 +247,7 @@ export type HeadlessEventRegistrationFlow = Readonly<{
         state: EventRegistrationLoadState<UseEventRegistrationWizardResult['existingRegistration']>;
         registration: UseEventRegistrationWizardResult['existingRegistration'];
     }>;
-    waitlistClaim: UseWaitlistClaimResult;
+    waitlistClaim: WaitlistInvitation;
     spamProtection: EventRegistrationSpamProtectionModel;
     terminal: EventRegistrationTerminalModel;
     actions: EventRegistrationFlowActions;

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

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

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

@@ -40,6 +40,15 @@ export declare const eventRecoveryRequestSchema: z.ZodObject<{
     readProfile: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type EventRecoveryRequest = Omit<PublicEventsRequest, 'siteId'>;
+export type EventSourceRecovery<Event = PublicEvent> = Readonly<{
+    kind: 'ready';
+    events: readonly Event[];
+}> | Readonly<{
+    kind: 'loading';
+}> | Readonly<{
+    kind: 'exhausted';
+    retry: () => void;
+}>;
 export type EventRegistrationEventSource = Readonly<{
     kind: 'loaded';
     events: PublicEvent[];

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

@@ -0,0 +1,77 @@
+import type { ConfirmationPayment } from '../../../../../../commerce/src/purchase/index';
+import { type RegistrationDisplay } from './registrationDisplay';
+import type { OccurrenceContext, RegistrationEvent, RegistrationResult } from './types';
+import type { RegistrationPresentation } from './wizardSteps';
+export type ConfirmationSummaryRow = Readonly<{
+    label: string;
+    value: string;
+}>;
+export type ConfirmationPaymentPresentation = Readonly<{
+    kind: 'none';
+}> | Readonly<{
+    kind: 'settled';
+    rows: readonly ConfirmationSummaryRow[];
+}> | Readonly<{
+    kind: 'due';
+    paidRows: readonly ConfirmationSummaryRow[];
+    amountDueRow: ConfirmationSummaryRow;
+    instructions: string | null;
+}>;
+export declare function confirmationPaymentRows(payment: ConfirmationPaymentPresentation): readonly ConfirmationSummaryRow[];
+/** The finished card and bar's facts. */
+export type FinishedBookingEntry = Readonly<{
+    title: string;
+    /** Long form for the card and panel header. */
+    when: string | null;
+    /** Short form for the bar: "Mon 5 Oct, 7:00pm". */
+    shortWhen: string | null;
+}> & (
+/** `places` is null when the booking's details could not be loaded. */
+Readonly<{
+    kind: 'booked';
+    places: string | null;
+}> | Readonly<{
+    kind: 'waitlisted';
+}>);
+export type FinishedBooking = Readonly<{
+    entry: FinishedBookingEntry;
+    /** The confirmation's rows. */
+    summary: readonly ConfirmationSummaryRow[];
+    payment: ConfirmationPaymentPresentation;
+}>;
+export type FinishedBookingContext = Readonly<{
+    /** The events this block books, already scoped and adapted. */
+    events: readonly RegistrationEvent[];
+    /** The draft's event. Only a waitlist place, which has no outcome, uses it. */
+    draftEvent: RegistrationEvent | null;
+    occurrenceContext: OccurrenceContext | null | undefined;
+    display: RegistrationDisplay;
+}>;
+type ConfirmedResult = Extract<RegistrationResult, {
+    status: 'confirmed';
+}>;
+type WaitlistResult = Extract<RegistrationResult, {
+    status: 'waitlist';
+}>;
+/** The panel's presentation with any finished booking already resolved. */
+export type ResolvedRegistrationPresentation = Exclude<RegistrationPresentation, {
+    screen: 'confirmed' | 'waitlisted';
+}> | Readonly<{
+    layout: 'whole';
+    screen: 'confirmed';
+    result: ConfirmedResult;
+    finished: FinishedBooking;
+}> | Readonly<{
+    layout: 'whole';
+    screen: 'waitlisted';
+    result: WaitlistResult;
+    finished: FinishedBooking;
+}>;
+/** Every evidenced debt carries its required amount row, independently of success prose. */
+export declare function presentConfirmationPayment(payment: ConfirmationPayment): ConfirmationPaymentPresentation;
+/**
+ * The one place a finished booking is resolved: the confirmation, the
+ * finished card and the bar all take this, never the raw result and events.
+ */
+export declare function resolveFinishedPresentation(presentation: RegistrationPresentation, context: FinishedBookingContext): ResolvedRegistrationPresentation;
+export {};

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

@@ -16,5 +16,4 @@ export { VerifyingPaymentStep } from './VerifyingPaymentStep';
 export { PaymentFailedStep } from './PaymentFailedStep';
 export { VerifyingTimeoutStep } from './VerifyingTimeoutStep';
 export { StepIndicator } from './StepIndicator';
-export { OrderSummary } from './OrderSummary';
 export { CheckIcon } from './CheckIcon';

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

@@ -0,0 +1,12 @@
+import { type BookingOfferingPresetSummary } from '../../../blocks/offerings-preview/model';
+import type { RegistrationEvent } from './types';
+export type OfferingNoun = Readonly<{
+    label: string;
+    pluralLabel: string;
+}>;
+/**
+ * What the site calls this kind of offering, in lower case for use mid-sentence
+ * ("Book the course", "3 workshops"). Site preset labels win; the canonical
+ * name stands in when the site has none.
+ */
+export declare function offeringNounForEvent(event: Pick<RegistrationEvent, 'eventPreset' | 'registrationSubject'> | null, presets: readonly BookingOfferingPresetSummary[] | null | undefined): OfferingNoun;

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

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

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

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

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

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

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

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