@riverbankcms/sdk 0.151.0 → 0.153.0

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

@@ -1,18 +1,8 @@
 import { useBlockApi } from '../../api';
-import type { PublicEvent } from '../../../blocks/events/shared/types';
-import type { EventRegistrationEventSource } from './eventSourceRecovery';
-export type EventSourceRecovery = Readonly<{
-    kind: 'ready';
-    events: PublicEvent[];
-}> | Readonly<{
-    kind: 'loading';
-}> | Readonly<{
-    kind: 'exhausted';
-    retry: () => void;
-}>;
+import type { EventRegistrationEventSource, EventSourceRecovery } from './eventSourceRecovery';
+export type { EventSourceRecovery } from './eventSourceRecovery';
 type RecoveryDeps = Readonly<{
     useApi: typeof useBlockApi;
     wait: (milliseconds: number, signal: AbortSignal) => Promise<void>;
 }>;
 export declare function useEventSourceRecovery(source: EventRegistrationEventSource, deps?: RecoveryDeps): EventSourceRecovery;
-export {};

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

@@ -1,13 +1,13 @@
 import { type Dispatch, type SetStateAction } from 'react';
 import type { BlockApiClient } from '../../api/client';
-import type { EventCheckoutReturnRequest, EventCheckoutReturnResponse, EventEmbeddedCheckout, EventRegistrationPaymentSubject } from '../../api/types';
+import type { EventCheckoutReturnRequest, EventEmbeddedCheckout, EventRegistrationPaymentSubject } from '../../api/types';
 import type { EventPaymentState, PaymentStatusRecoveryState, RegistrationResult, RegistrationStep } from './types';
 type Options = Readonly<{
     api: BlockApiClient;
     beginNewSubmission: () => void;
-    setRegistrationResult: Dispatch<SetStateAction<RegistrationResult | null>>;
+    complete: (result: RegistrationResult) => void;
     setOptionsRefreshKey: Dispatch<SetStateAction<number>>;
-    setStep: (step: RegistrationStep) => void;
+    setStep: (step: Exclude<RegistrationStep, 'success'>) => void;
     /** Whether this page still holds the booker's details; a restored page after a reload does not. */
     detailsInPage: () => boolean;
 }>;
@@ -24,7 +24,150 @@ export declare function usePaymentStatusRecovery(options: Options): {
         retry: () => void;
         retryReturn: () => void;
         status: "idle" | "polling" | "completed" | "failed" | "timeout";
-        result: EventCheckoutReturnResponse | null;
+        result: {
+            kind: "checkout";
+            subject: {
+                scope: "occurrence";
+                submissionId: string;
+                attendeeId: string;
+            } | {
+                scope: "wholeSeries";
+                submissionId: string;
+            };
+            outcome: {
+                kind: "resolved";
+                outcome: {
+                    kind: "detailsAvailable";
+                    identity: {
+                        submissionId: string;
+                        seriesId: string;
+                        attendanceMode: "in_person" | "online";
+                        scope: "occurrence";
+                        attendeeId: string;
+                        occurrenceId: string;
+                    } | {
+                        submissionId: string;
+                        seriesId: string;
+                        attendanceMode: "in_person" | "online";
+                        scope: "wholeSeries";
+                        registrationId: string;
+                    };
+                    ticketLines: readonly [{
+                        label: string;
+                        quantity: number;
+                    }, ...{
+                        label: string;
+                        quantity: number;
+                    }[]];
+                    payment: {
+                        kind: "free";
+                        balance: {
+                            kind: "settled";
+                        };
+                    } | {
+                        kind: "waived";
+                        balance: {
+                            kind: "settled";
+                        };
+                    } | {
+                        kind: "pass";
+                        passName: string | null;
+                        passCreditsUsed: number | null;
+                        balance: {
+                            kind: "settled";
+                        };
+                    } | {
+                        kind: "membership";
+                        membershipName: string | null;
+                        balance: {
+                            kind: "settled";
+                        };
+                    } | {
+                        kind: "manual_due";
+                        currency: import("../../../../../../commerce/src/purchase/index").CurrencyCode;
+                        balance: {
+                            kind: "due";
+                            amountCents: import("../../../../../../core/src/index").PositiveCents;
+                            dueAt: string | null;
+                        };
+                    } | {
+                        balance: {
+                            kind: "due";
+                            amountCents: import("../../../../../../core/src/index").PositiveCents;
+                            dueAt: string | null;
+                        };
+                        amountPaidCents: import("../../../../../../core/src/index").NonNegativeCents;
+                        currency: import("../../../../../../commerce/src/purchase/index").CurrencyCode;
+                        kind: "managed_balance_due";
+                    } | {
+                        paymentMethod: "mixed" | "manual" | "stripe" | "store_credit";
+                        balance: {
+                            kind: "settled";
+                        } | {
+                            kind: "due";
+                            amountCents: import("../../../../../../core/src/index").PositiveCents;
+                            dueAt: string | null;
+                        };
+                        amountPaidCents: import("../../../../../../core/src/index").NonNegativeCents;
+                        currency: import("../../../../../../commerce/src/purchase/index").CurrencyCode;
+                        kind: "monetary";
+                    };
+                } | {
+                    kind: "detailsUnavailable";
+                    identity: {
+                        submissionId: string;
+                        seriesId: string;
+                        attendanceMode: "in_person" | "online";
+                        scope: "occurrence";
+                        attendeeId: string;
+                        occurrenceId: string;
+                    } | {
+                        submissionId: string;
+                        seriesId: string;
+                        attendanceMode: "in_person" | "online";
+                        scope: "wholeSeries";
+                        registrationId: string;
+                    };
+                };
+            } | {
+                kind: "abandoned";
+            } | {
+                kind: "reconciliationRequired";
+            } | {
+                kind: "paymentProcessing";
+                recoverableUntil?: string | undefined;
+            } | {
+                kind: "paymentAvailable";
+                checkout: {
+                    kind: "embedded";
+                    sessionId: string;
+                    clientSecret: string;
+                    livemode: boolean;
+                    expiresAt: string;
+                    browser: {
+                        kind: "connect";
+                        publishableKey: string;
+                        accountId: string;
+                    } | {
+                        kind: "direct";
+                        publishableKey: string;
+                    };
+                };
+                recoverableUntil?: string | undefined;
+            } | {
+                kind: "paymentRetryAvailable";
+                place: "released" | "held";
+            } | {
+                kind: "paymentCheckUnavailable";
+                recoverableUntil?: string | undefined;
+            } | {
+                kind: "paymentAssistanceRequired";
+            };
+        } | {
+            kind: "notFound";
+        } | {
+            kind: "reconciliationRequired";
+        } | null;
         error: Error | null;
     };
     state: EventPaymentState;

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

@@ -28,12 +28,60 @@ export declare function formatTime(isoTimestamp: string, options?: {
     locale?: string;
 }): string;
 /**
- * Format date and time in short form for compact displays (e.g., order summary)
+ * How a booking date is written (issue 1581). One owner, explicit variants:
+ * - `long`: the card and panel header, "Mon 5 Oct · 7:00pm – 8:15pm"
+ * - `short`: the bar and the confirmation's When row, "Mon 5 Oct, 7:00pm"
+ * - `day`: the date chips and "next" dates, "Mon 5 Oct"
+ * - `dayLong`: the date step's rows, "Friday 2 October"
+ * - `timeRange`: under them, "7:00pm – 8:15pm"
+ * - `time`: the stored schedule start, "7:00pm"
+ * - `month`: the date step's month labels, "October"
+ * - `monthYear`: which month a date falls in, "October 2026" (grouping key)
  */
+export type BookingDateVariant = 'long' | 'short' | 'day' | 'dayLong' | 'timeRange' | 'time' | 'month' | 'monthYear';
+export type BookingDateInput = Readonly<{
+    startsAt: string;
+    /** Only the long form writes an end time. */
+    endsAt?: string | null;
+    timeZone?: string | null;
+    /** The site's own zone decides the locale (day or month first). */
+    siteTimeZone?: string | null;
+}>;
+/**
+ * The locale a site's booking dates are written in: the one the site's time
+ * zone places it in (`eventDateLocale`, shared with event cards), or British
+ * English when the site names no zone.
+ */
+export declare function bookingDateLocale(siteTimeZone: string | null | undefined): string;
+/** A stored local clock has no date or DST offset; UTC preserves its digits. */
+export declare function formatBookingScheduleSummary(event: Pick<RegistrationEvent, 'scheduleSummary' | 'siteTimeZone'>): string | null;
+/** The one booking date formatter; every variant derives from it. */
+export declare function formatBookingWhen(input: BookingDateInput, variant: BookingDateVariant): string;
+/** A single instant in the short form, e.g. "Mon 5 Oct, 7:00pm". */
 export declare function formatEventDateTime(isoTimestamp: string, options?: {
     timeZone?: string | null;
-    locale?: string;
+    siteTimeZone?: string | null;
 }): string;
+/** The title an occurrence was given on its own, when it overrides the event's. */
+export declare function occurrenceTitleOverride(occurrence: Readonly<{
+    overrides?: Readonly<Record<string, unknown>> | null;
+}> | null | undefined): string | null;
+/** The event as this page names it: an occurrence's own title wins. */
+export declare function withOccurrenceTitle<T extends Readonly<{
+    title: string;
+}>>(event: T | null, occurrence: Parameters<typeof occurrenceTitleOverride>[0]): T | null;
+type ScheduleEvent = Pick<RegistrationEvent, 'startsAt' | 'endsAt' | 'timeZone' | 'siteTimeZone' | 'registrationSubject'>;
+type ScheduleOccurrence = Readonly<{
+    startsAt?: string | null;
+    endsAt?: string | null;
+    timeZone?: string | null;
+}> | null;
+/**
+ * When a booking happens, in one line: the occurrence's date and time, or a
+ * course's session count and first and last dates. `short` by default (bar,
+ * confirmation); `long` adds the end time (card, panel header).
+ */
+export declare function formatRegistrationSchedule(event: ScheduleEvent, occurrence?: ScheduleOccurrence, variant?: Extract<BookingDateVariant, 'long' | 'short'>): string | null;
 export { formatPrice } from '../../shared';
 /** Tooltip text shown when pass/membership redemptions are unavailable for multi-ticket bookings. */
 export declare const ENTITLEMENT_SINGLE_TICKET_TOOLTIP = "Only available for single-ticket bookings";

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

@@ -1,10 +1,13 @@
+import type { EventSourceRecovery } from './eventSourceRecovery';
 import type { ResolveWaitlistClaimResponse } from '../../api/types';
 import type { EventTicketSelectionLine, RegistrationEvent } from './types';
 export type WaitlistClaimRestoration = Readonly<{
-    ok: false;
+    kind: 'awaitingEvents';
+}> | Readonly<{
+    kind: 'different-event';
     message: string;
 }> | Readonly<{
-    ok: true;
+    kind: 'ready';
     event: RegistrationEvent | null;
     attendanceMode: 'in_person' | 'online';
     ticketSelections: readonly EventTicketSelectionLine[];
@@ -13,8 +16,6 @@ export type WaitlistClaimRestoration = Readonly<{
 }>;
 export declare function resolveWaitlistClaimRestoration(input: Readonly<{
     claim: ResolveWaitlistClaimResponse;
-    scopedEvents: readonly RegistrationEvent[];
+    events: EventSourceRecovery<RegistrationEvent>;
     occurrenceContextId?: string;
 }>): WaitlistClaimRestoration;
-export declare function resolveClaimedTicketSelections(claim: ResolveWaitlistClaimResponse | null): readonly EventTicketSelectionLine[] | null;
-export declare function resolveClaimTicketCount(claim: ResolveWaitlistClaimResponse | null, fallback: number): number;

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

@@ -1,22 +1,92 @@
-import type { RegistrationStep } from './types';
+import type { PaymentSelection, RegistrationResult, RegistrationStep } from './types';
+import type { RegistrationAdmission } from './registrationCompletion';
+/** The steps that can be counted in the visitor's route through the wizard. */
+export type RegistrationRouteStep = Extract<RegistrationStep, 'select-event' | 'select-tickets' | 'enter-details' | 'select-payment' | 'payment'>;
+/** The ordered steps the visitor is on course to take, as far as we know now. */
+export type RegistrationRoute = readonly RegistrationRouteStep[];
 /**
- * Steps that are part of the main wizard and should show the step indicator
+ * Which payment steps the route counts.
+ * - `none`: free, a paid waitlist, or an entitlement chosen before the payment options step.
+ * - `options`: an entitlement chosen on the payment options step, so only Payment drops.
+ * - `optionsAndPayment`: card payment is expected, so both are counted up front.
  */
-export declare const WIZARD_STEPS: RegistrationStep[];
-/** Recovery uses the form surface without adding a progress step. */
-export declare function getRegistrationStepPresentation(step: RegistrationStep, progressSteps: readonly RegistrationStep[]): Readonly<{
-    isWizardStep: boolean;
-    totalSteps: number;
+export type RegistrationPaymentRoute = 'none' | 'options' | 'optionsAndPayment';
+export type RegistrationProgress = Readonly<{
+    steps: RegistrationRoute;
+    /** 1-based position of the current step in `steps`. */
+    current: number;
 }>;
+export type RegistrationScreen = 'processing' | 'confirmed' | 'waitlisted' | 'error' | 'verifying' | 'verifyingTimeout' | 'paymentStatus' | 'paymentFailed';
 /**
- * Determine which wizard steps to show based on context and payment requirements.
- *
- * @param hasPreSelectedContext - Whether event is pre-selected (skips event selection)
- * @param needsPaymentStep - Whether user must complete payment method selection
- * @returns Array of wizard steps to display
+ * What the booking surface renders: the step layout (with progress only when
+ * the step is part of the route), or one whole-panel screen. Never both.
  */
-export declare function getWizardStepsForContext(hasPreSelectedContext: boolean, needsPaymentStep: boolean, paymentActive?: boolean): readonly RegistrationStep[];
+export type RegistrationPresentation = Readonly<{
+    layout: 'steps';
+    progress: RegistrationProgress | null;
+}> | Readonly<{
+    layout: 'whole';
+    screen: Exclude<RegistrationScreen, 'confirmed' | 'waitlisted'>;
+}> | Readonly<{
+    layout: 'whole';
+    screen: 'confirmed';
+    result: Extract<RegistrationResult, {
+        status: 'confirmed';
+    }>;
+}> | Readonly<{
+    layout: 'whole';
+    screen: 'waitlisted';
+    result: Extract<RegistrationResult, {
+        status: 'waitlist';
+    }>;
+}>;
+export type RegistrationOutcome = RegistrationResult['status'] | null;
+/**
+ * The payment part of the route, from facts the wizard already has.
+ * The count follows the current route: picking a pass drops Payment, and
+ * "Pay by card instead" adds it back.
+ */
+export declare function registrationPaymentRoute(facts: Readonly<{
+    step: RegistrationStep;
+    admission: RegistrationAdmission;
+    eventRequiresPayment: boolean;
+    paymentSelection: PaymentSelection;
+}>): RegistrationPaymentRoute;
+export declare function registrationRoute(input: Readonly<{
+    chooseEvent: boolean;
+    payment: RegistrationPaymentRoute;
+}>): RegistrationRoute;
+/** One presentation decision for every registration step. */
+export declare function registrationPresentation(state: Readonly<{
+    step: Exclude<RegistrationStep, 'success'>;
+}> | Readonly<{
+    step: 'success';
+    result: RegistrationResult;
+}>, route: RegistrationRoute): RegistrationPresentation;
 /**
- * Map wizard step to step number based on the active wizard steps
+ * Payment-return and recovery states the visitor must see, so entering one
+ * opens the booking panel. `payment` covers "Return to payment".
  */
-export declare function getStepNumber(step: RegistrationStep, wizardSteps: readonly RegistrationStep[]): number;
+export declare function panelShouldOpen(step: RegistrationStep): boolean;
+export declare const REGISTRATION_STEP_LABELS: readonly ["Event", "Date", "Tickets", "Places", "Your details", "How you’ll pay", "Payment"];
+export type RegistrationStepLabel = (typeof REGISTRATION_STEP_LABELS)[number];
+export type RegistrationEventSelectionMode = 'event' | 'date';
+/** Several dates of one series are a date choice; anything else is an event choice. */
+export declare function getEventSelectionMode(events: readonly Readonly<{
+    seriesId: string;
+}>[]): RegistrationEventSelectionMode;
+export type RegistrationStepLabelContext = Readonly<{
+    eventSelection: RegistrationEventSelectionMode;
+    /** Whole-series (course) bookings count places rather than tickets. */
+    booksWholeSeries: boolean;
+}>;
+/** The label facts for a surface: what the visitor chooses from, and what they book. */
+export declare function registrationStepLabelContext(scopedEvents: readonly Readonly<{
+    seriesId: string;
+}>[], bookedEvent: Readonly<{
+    registrationSubject: Readonly<{
+        kind: string;
+    }>;
+}> | null): RegistrationStepLabelContext;
+/** One label owner for the live progress and the server placeholder. */
+export declare function registrationStepLabel(step: RegistrationRouteStep, context: RegistrationStepLabelContext): RegistrationStepLabel;

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

@@ -1,3 +1,4 @@
+import { type RegistrationDisplay } from './event-registration/registrationDisplay';
 import { type MailingListRuntimeContext } from '../../../../../core/src/index';
 import type { BrowserReadAuthority } from '../api/types';
 import type { BlockButtonRole } from '../../constants/buttonRoles';
@@ -5,13 +6,15 @@ import type { PublicEvent } from '../../blocks/events/shared/types';
 import { type PublicMembershipProductCollection, type PublicPassProductCollection } from '../../blocks/shop.shared';
 import type { OccurrenceContext } from '../../blocks/event-registration.shared';
 import type { EventRegistrationClientProps as InternalEventRegistrationClientProps } from './event-registration/types';
+import type { BookingOfferingPresetSummary } from '../../blocks/offerings-preview/model';
+import { type BookingHost, type IdleBookingEntry } from './event-registration/bookingCardDisplay';
 import { type EventRegistrationPageSurfaceSubject } from './event-registration/eventScope';
 import { type InteractiveIslandProps } from '../../../contracts/islands';
+import { type RegistrationStepLabel } from './event-registration/wizardSteps';
 import { type EventRegistrationEventSource } from './event-registration/eventSourceRecovery';
-export declare const EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS: readonly ["Date", "Tickets", "Details"];
-declare const EVENT_REGISTRATION_SHELL_STEP_LABELS: readonly ["Event", "Date", "Tickets", "Details", "Payment options", "Payment"];
+export declare const EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS: readonly ["Date", "Tickets", "Your details"];
 export type EventRegistrationGenericShellStepLabels = typeof EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
-type EventRegistrationShellStepLabel = (typeof EVENT_REGISTRATION_SHELL_STEP_LABELS)[number];
+type EventRegistrationShellStepLabel = RegistrationStepLabel;
 export type EventRegistrationSourceProps = Readonly<{
     siteId?: string;
     demoEmailSuppressed?: boolean;
@@ -32,7 +35,8 @@ export type EventRegistrationSourceProps = Readonly<{
     showCapacity?: boolean;
     successMessage?: string;
     buttonVariant?: BlockButtonRole;
-    overlayEnabled?: boolean;
+    /** Pages built around booking pass 'inPlace'; editor-placed blocks use the overlay. */
+    host?: BookingHost;
     spamProtectionEnabled?: boolean;
     stage?: 'preview' | 'published';
     supportEmail?: string;
@@ -40,6 +44,8 @@ export type EventRegistrationSourceProps = Readonly<{
     siteMemberships?: PublicMembershipProductCollection | null;
     mailingList?: MailingListRuntimeContext;
     siteName?: string;
+    /** The site's booking preset rows; the server resolves the offering noun from them. */
+    bookingOfferingPresets?: readonly BookingOfferingPresetSummary[] | null;
 }>;
 export type EventRegistrationDisplay = Readonly<{
     kind: 'event-registration';
@@ -55,7 +61,19 @@ export type EventRegistrationDisplay = Readonly<{
     className: string | null;
     titleText: string;
     bodyText: string;
+}> | Readonly<{
+    kind: 'event-registration';
+    state: 'booking-card';
+    className: string | null;
+    entry: IdleBookingEntry;
+    buttonVariant: BlockButtonRole | null;
+    /** The block's own button text, carried to the wizard's final submit. */
+    buttonText: string;
 }>;
+/** The block's button text, whichever state the server rendered. */
+export declare function displayButtonText(display: Exclude<EventRegistrationDisplay, {
+    state: 'registration-closed';
+}>): string | undefined;
 export type EventRegistrationHydration = Readonly<Omit<InternalEventRegistrationClientProps, 'siteId' | 'stage' | 'buttonText' | 'className' | 'events'> & {
     eventSource: EventRegistrationEventSource;
 }>;
@@ -67,7 +85,7 @@ type EventRegistrationIslandMeta = Readonly<{
     readAuthority?: BrowserReadAuthority;
     stage?: 'preview' | 'published';
 }>;
-export declare function buildEventRegistrationDisplayFromScopedEvents(source: EventRegistrationSourceProps, scopedSourceEvents: readonly PublicEvent[]): EventRegistrationDisplay;
+export declare function buildEventRegistrationDisplayFromScopedEvents(source: EventRegistrationSourceProps, scopedSourceEvents: readonly PublicEvent[], display: RegistrationDisplay): EventRegistrationDisplay;
 export type EventRegistrationInteractiveIslandProps = InteractiveIslandProps<EventRegistrationIslandMeta, 'event-registration', typeof eventRegistrationBlockRuntime>;
 export declare const eventRegistrationBlockRuntime: Readonly<{
     kind: "client-owned";
@@ -91,7 +109,8 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
         showCapacity?: boolean;
         successMessage?: string;
         buttonVariant?: BlockButtonRole;
-        overlayEnabled?: boolean;
+        /** Pages built around booking pass 'inPlace'; editor-placed blocks use the overlay. */
+        host?: BookingHost;
         spamProtectionEnabled?: boolean;
         stage?: "preview" | "published";
         supportEmail?: string;
@@ -103,6 +122,14 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
         }> | null;
         mailingList?: MailingListRuntimeContext;
         siteName?: string;
+        /** The site's booking preset rows; the server resolves the offering noun from them. */
+        bookingOfferingPresets?: readonly Readonly<{
+            id: string;
+            canonicalBehaviour: import("../../blocks/offerings-preview/model").BookingOfferingCanonicalBehaviour;
+            engine: import("../../blocks/offerings-preview/model").BookingOfferingEngine;
+            label: string;
+            pluralLabel: string;
+        }>[] | null;
     }>) => Readonly<{
         display: EventRegistrationDisplay;
         hydration: Readonly<Omit<InternalEventRegistrationClientProps, "stage" | "siteId" | "events" | "className" | "buttonText"> & {
@@ -131,7 +158,8 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
                 showCapacity?: boolean;
                 successMessage?: string;
                 buttonVariant?: BlockButtonRole;
-                overlayEnabled?: boolean;
+                /** Pages built around booking pass 'inPlace'; editor-placed blocks use the overlay. */
+                host?: BookingHost;
                 spamProtectionEnabled?: boolean;
                 stage?: "preview" | "published";
                 supportEmail?: string;
@@ -143,6 +171,14 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
                 }> | null;
                 mailingList?: MailingListRuntimeContext;
                 siteName?: string;
+                /** The site's booking preset rows; the server resolves the offering noun from them. */
+                bookingOfferingPresets?: readonly Readonly<{
+                    id: string;
+                    canonicalBehaviour: import("../../blocks/offerings-preview/model").BookingOfferingCanonicalBehaviour;
+                    engine: import("../../blocks/offerings-preview/model").BookingOfferingEngine;
+                    label: string;
+                    pluralLabel: string;
+                }>[] | null;
             }>) => unknown;
             decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                 siteId?: string;
@@ -164,7 +200,8 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
                 showCapacity?: boolean;
                 successMessage?: string;
                 buttonVariant?: BlockButtonRole;
-                overlayEnabled?: boolean;
+                /** Pages built around booking pass 'inPlace'; editor-placed blocks use the overlay. */
+                host?: BookingHost;
                 spamProtectionEnabled?: boolean;
                 stage?: "preview" | "published";
                 supportEmail?: string;
@@ -176,6 +213,14 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
                 }> | null;
                 mailingList?: MailingListRuntimeContext;
                 siteName?: string;
+                /** The site's booking preset rows; the server resolves the offering noun from them. */
+                bookingOfferingPresets?: readonly Readonly<{
+                    id: string;
+                    canonicalBehaviour: import("../../blocks/offerings-preview/model").BookingOfferingCanonicalBehaviour;
+                    engine: import("../../blocks/offerings-preview/model").BookingOfferingEngine;
+                    label: string;
+                    pluralLabel: string;
+                }>[] | null;
             }>>;
         }>;
         render: Readonly<{

package/dist/_dts/blocks/src/system/runtime/nodes/events/shared/CardListItem.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import type { CardListItemPart } from '../../../../../../../theme-core/src/site-styles/index';
-import type { Media } from '../../../../../lib/media';
+import type { RuntimeMedia as Media } from '../../../../../lib/media';
 import { type LookListPresentation } from '../../../lookSurfaces';
 import type { ButtonVariant } from '../../../../blocks/events/shared/types';
 export type CardListItemContent = Readonly<{

package/dist/_dts/blocks/src/system/runtime/nodes/events/shared/MonthLookView.d.ts

@@ -9,12 +9,19 @@ export type MonthLookViewProps = LookListPresentation & Pick<EventItemProps, 'sh
     dayNames: readonly string[];
     eventsByDate: ReadonlyMap<string, readonly PublicEvent[]>;
     selectedDay: string;
-    onSelectDay?: (day: string) => void;
-    onOpenDay?: (date: CalendarDate, events: readonly PublicEvent[]) => void;
     viewDate: CalendarDate;
     today: CalendarDate;
     timeZone: string;
     emptyMessage: string;
 }>;
+/** The server view has no controls; the client supplies both calendar actions. */
+type MonthLookControls = Readonly<{
+    selectDay: (day: string) => void;
+    openDay: (date: CalendarDate, events: readonly PublicEvent[]) => void;
+}>;
+type MonthLookPresentationProps = MonthLookViewProps & Readonly<{
+    controls?: MonthLookControls;
+}>;
 /** Both Looks and the legacy month grid consume the same per-day model. */
-export declare function MonthLookView(props: MonthLookViewProps): React.JSX.Element;
+export declare function MonthLookView(props: MonthLookPresentationProps): React.JSX.Element;
+export {};