@riverbankcms/sdk 0.82.0 → 0.84.1

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

@@ -0,0 +1,33 @@
+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 { HeadlessEventRegistrationFlow } from '../nodes/event-registration/event-registration.headless.state';
+import { createEventRegistrationBlockApiConfig } from '../nodes/event-registration/event-registration.headless.state';
+export type { BlockApiConfig };
+export { createEventRegistrationBlockApiConfig };
+export type { EventRegistrationAttendeeModel, EventRegistrationDiscountModel, EventRegistrationEventsModel, EventRegistrationFlowActionResult, EventRegistrationFlowActions, EventRegistrationFlowStatus, EventRegistrationFlowStep, EventRegistrationFlowStepId, EventRegistrationFlowView, EventRegistrationGuestsModel, EventRegistrationLoadState, EventRegistrationOverrideData, EventRegistrationOverrideInput, EventRegistrationOverrideInputResult, EventRegistrationOverridePropsLike, EventRegistrationPaymentModel, EventRegistrationPaymentSelection, EventRegistrationPortalAuthModel, EventRegistrationSpamProtectionModel, EventRegistrationTerminalModel, EventRegistrationTicketsModel, HeadlessEventRegistrationFlow, } from '../nodes/event-registration/event-registration.headless.state';
+export type { EventRegistrationSubmitOptions, EventRegistrationSubmitResult, } from '../nodes/event-registration/useEventRegistrationSubmit';
+export type HeadlessEventRegistrationFlowOptions = Readonly<{
+    anchorId?: string;
+    occurrenceContext?: EventRegistrationClientProps['occurrenceContext'];
+    contentEntry?: EventRegistrationClientProps['contentEntry'];
+    events?: readonly NonNullable<EventRegistrationClientProps['events']>[number][];
+    maxTickets?: string | number;
+    spamProtectionEnabled?: boolean;
+}>;
+export type HeadlessEventRegistrationProviderProps = Readonly<{
+    config: BlockApiConfig;
+    children?: React.ReactNode;
+}>;
+export type EventRegistrationController = Readonly<{
+    flow: HeadlessEventRegistrationFlow;
+    wizard: ReturnType<typeof useEventRegistrationWizard>;
+}>;
+export type EventRegistrationWizardController = Readonly<{
+    wizard: ReturnType<typeof useEventRegistrationWizard>;
+}>;
+export declare function HeadlessEventRegistrationProvider({ config, children, }: HeadlessEventRegistrationProviderProps): React.ReactElement;
+export declare function useHeadlessEventRegistrationFlow(options: HeadlessEventRegistrationFlowOptions): HeadlessEventRegistrationFlow;
+export declare function useEventRegistrationController(options: HeadlessEventRegistrationFlowOptions): EventRegistrationController;
+export declare function useEventRegistrationWizardController(options: HeadlessEventRegistrationFlowOptions): EventRegistrationWizardController;

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

@@ -1,5 +1,3 @@
 import React from 'react';
 import type { EventRegistrationClientProps } from './types';
-/** Anchor ID for the registration block, used for post-logout scroll targeting */
-export declare const EVENT_REGISTRATION_ANCHOR_ID = "event-registration";
 export declare function EventRegistrationWizard(props: EventRegistrationClientProps): React.JSX.Element;

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

@@ -0,0 +1 @@
+export declare const EVENT_REGISTRATION_ANCHOR_ID = "event-registration";

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

@@ -0,0 +1,275 @@
+import type { PaymentMethod } from '../../api/types';
+import type { EventRegistrationContentEntry } from '../event-registration.interactive';
+import type { EligibilityData, FormData, Guest, GuestErrors, OccurrenceContext, PaymentSelection, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult } from './types';
+import type { SelectableEventTicketType } from './utils';
+import type { PortalAuthState, PortalProfile } from './hooks';
+import type { UseWaitlistClaimResult } from '../../shared/useWaitlistClaim';
+import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
+import type { EventRegistrationSubmitOptions, EventRegistrationSubmitResult } from './useEventRegistrationSubmit';
+export declare const DEFAULT_EVENT_REGISTRATION_MAX_TICKETS = 5;
+export type EventRegistrationLoadState<T> = Readonly<{
+    tag: 'idle';
+    value: T | null;
+}> | Readonly<{
+    tag: 'loading';
+    value: T | null;
+}> | Readonly<{
+    tag: 'loaded';
+    value: T;
+}>;
+export type EventRegistrationSubmitArgs = Readonly<{
+    method: PaymentMethod;
+    passId?: string;
+    membershipId?: string;
+    selection?: PaymentSelection;
+}>;
+export type EventRegistrationSubmitPlan = Readonly<{
+    ok: true;
+    args: EventRegistrationSubmitArgs;
+}> | Readonly<{
+    ok: false;
+    reason: 'payment-selection-required';
+    message: string;
+}>;
+export type EventRegistrationFlowStatus = Readonly<{
+    tag: 'ready';
+}> | Readonly<{
+    tag: 'submitting';
+}> | Readonly<{
+    tag: 'redirecting';
+}> | Readonly<{
+    tag: 'verifying-payment';
+}> | Readonly<{
+    tag: 'verifying-timeout';
+}> | Readonly<{
+    tag: 'payment-failed';
+    message: string;
+}> | Readonly<{
+    tag: 'success';
+    result: RegistrationResult;
+}> | Readonly<{
+    tag: 'error';
+    message: string;
+}>;
+export type EventRegistrationFlowView = Readonly<{
+    kind: 'empty';
+    message: string;
+}> | Readonly<{
+    kind: 'unavailable';
+    message: string;
+}> | Readonly<{
+    kind: 'form';
+}> | Readonly<{
+    kind: 'verifying';
+    message: string;
+}> | Readonly<{
+    kind: 'success';
+    result: RegistrationResult;
+}> | Readonly<{
+    kind: 'error';
+    message: string;
+}>;
+export type EventRegistrationFlowStepId = 'select-event' | 'select-tickets' | 'enter-details' | 'select-payment';
+export type EventRegistrationFlowStepState = 'complete' | 'active' | 'available' | 'blocked';
+export type EventRegistrationFlowStep = Readonly<{
+    id: EventRegistrationFlowStepId;
+    label: string;
+    state: EventRegistrationFlowStepState;
+    index: number;
+    canEnter: boolean;
+    canLeave: boolean;
+}>;
+export type EventRegistrationFlowActionResult = Readonly<{
+    ok: true;
+}> | Readonly<{
+    ok: false;
+    reason: 'blocked' | 'validation-failed' | 'submission-failed';
+    message: string;
+}>;
+export type EventRegistrationEventsModel = Readonly<{
+    items: readonly PublicEvent[];
+    scoped: readonly RegistrationEvent[];
+    selected: RegistrationEvent | null;
+    preSelected: RegistrationEvent | null;
+    hasPreSelectedContext: boolean;
+    target: UseEventRegistrationWizardResult['registrationTarget'];
+    occurrenceContext: OccurrenceContext | null | undefined;
+    contentEntry: EventRegistrationContentEntry | null | undefined;
+}>;
+export type EventRegistrationTicketsModel = Readonly<{
+    count: number;
+    max: number;
+    selectedTicketTypeId: string | null;
+    selectedTicketType: SelectableEventTicketType | null;
+    visibleTicketTypes: readonly SelectableEventTicketType[];
+    selectionRequired: boolean;
+    hasValidSelection: boolean;
+    eventRequiresPayment: boolean;
+    selectedAttendanceMode: 'in_person' | 'online' | null;
+}>;
+export type EventRegistrationAttendeeModel = Readonly<{
+    values: FormData;
+    errors: Partial<Record<keyof FormData, string>>;
+}>;
+export type EventRegistrationGuestsModel = Readonly<{
+    required: boolean;
+    items: readonly Guest[];
+    errors: GuestErrors;
+    shake: boolean;
+}>;
+export type EventRegistrationPaymentSelection = Readonly<{
+    method: 'none';
+}> | Readonly<{
+    method: 'free';
+}> | Readonly<{
+    method: 'stripe';
+}> | Readonly<{
+    method: 'pass';
+    passId: string;
+    productName?: string;
+}> | Readonly<{
+    method: 'membership';
+    membershipId: string;
+    productName?: string;
+}> | Readonly<{
+    method: 'pass_bundle';
+    passId: string;
+    productName?: string;
+}> | Readonly<{
+    method: 'membership_bundle';
+    membershipId: string;
+    productName?: string;
+}>;
+export type EventRegistrationPaymentModel = Readonly<{
+    kind: 'hidden';
+    selection: EventRegistrationPaymentSelection;
+    stepState: PaymentStepState;
+}> | Readonly<{
+    kind: 'loading' | 'error' | 'not-eligible' | 'ready';
+    selection: EventRegistrationPaymentSelection;
+    stepState: PaymentStepState;
+    eligibility: EligibilityData | null;
+    eligibilityError: string | null | undefined;
+}>;
+export type EventRegistrationDiscountModel = Readonly<{
+    code: string;
+    isOpen: boolean;
+    available: boolean;
+    manualCodeEntryAllowed: boolean;
+    loading: boolean;
+    autoAppliedDiscount: UseEventRegistrationWizardResult['autoAppliedDiscount'];
+}>;
+export type EventRegistrationPortalAuthModel = Readonly<{
+    state: PortalAuthState;
+    profile: PortalProfile | null;
+    isAuthenticated: boolean;
+    showMagicLinkModal: boolean;
+}>;
+export type EventRegistrationSpamProtectionModel = Readonly<{
+    enabled: false;
+}> | Readonly<{
+    enabled: true;
+    provider: 'altcha';
+    challenge: {
+        url: string;
+        auto: 'onfocus';
+    };
+    solution: string | null;
+}>;
+export type EventRegistrationTerminalModel = Readonly<{
+    result: RegistrationResult | null;
+    errorMessage: string;
+    verification: UseEventRegistrationWizardResult['verification'];
+}>;
+export type EventRegistrationFlowActions = Readonly<{
+    selectEvent: (event: RegistrationEvent) => void;
+    selectAttendanceMode: (mode: 'in_person' | 'online' | null) => void;
+    selectTicketType: (ticketTypeId: string | null) => void;
+    setTicketsCount: (count: number) => void;
+    updateAttendee: (values: FormData) => void;
+    updateGuests: (guests: Guest[]) => void;
+    selectPayment: (selection: EventRegistrationPaymentSelection) => void;
+    setDiscountCode: (code: string) => void;
+    setDiscountOpen: (isOpen: boolean) => void;
+    setAltchaSolution: (solution: string | null) => void;
+    requestLogin: () => void;
+    logout: () => void;
+    next: () => Promise<EventRegistrationFlowActionResult>;
+    back: () => void;
+    submit: (options?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
+    retry: () => void;
+}>;
+export type HeadlessEventRegistrationFlow = Readonly<{
+    status: EventRegistrationFlowStatus;
+    view: EventRegistrationFlowView;
+    steps: readonly EventRegistrationFlowStep[];
+    currentStep: EventRegistrationFlowStep | null;
+    events: EventRegistrationEventsModel;
+    tickets: EventRegistrationTicketsModel;
+    attendee: EventRegistrationAttendeeModel;
+    guests: EventRegistrationGuestsModel;
+    payment: EventRegistrationPaymentModel;
+    discount: EventRegistrationDiscountModel;
+    portalAuth: EventRegistrationPortalAuthModel;
+    existingRegistration: Readonly<{
+        state: EventRegistrationLoadState<UseEventRegistrationWizardResult['existingRegistration']>;
+        registration: UseEventRegistrationWizardResult['existingRegistration'];
+    }>;
+    waitlistClaim: UseWaitlistClaimResult;
+    spamProtection: EventRegistrationSpamProtectionModel;
+    terminal: EventRegistrationTerminalModel;
+    actions: EventRegistrationFlowActions;
+}>;
+export type EventRegistrationOverrideData = Readonly<{
+    events?: readonly PublicEvent[] | null;
+}>;
+export type EventRegistrationOverridePropsLike = Readonly<{
+    content?: Partial<{
+        maxTickets: string | null;
+        showVenue: boolean | null;
+        showCapacity: boolean | null;
+        successMessage: string | null;
+        waitlistMessage: string | null;
+        buttonVariant: 'primary' | 'secondary' | 'outline' | null;
+        buttonText: string | null;
+        spamProtectionEnabled: boolean | null;
+        supportEmail: string | null;
+    }> | null;
+    data?: EventRegistrationOverrideData | Record<string, unknown> | null;
+    siteId?: string;
+    apiBaseUrl?: string;
+    portalToken?: string | null;
+    previewToken?: string | null;
+    stage?: 'preview' | 'published';
+    occurrenceContext?: OccurrenceContext | null;
+    contentEntry?: Record<string, unknown> | null;
+    blockId?: string | null;
+}>;
+export type EventRegistrationOverrideInput = Readonly<{
+    siteId: string;
+    apiBaseUrl: string;
+    portalToken: string | null;
+    previewToken: string | null;
+    stage?: 'preview' | 'published';
+    occurrenceContext?: OccurrenceContext | null;
+    contentEntry?: EventRegistrationContentEntry | null;
+    events: readonly PublicEvent[];
+    maxTickets?: string;
+    showVenue?: boolean;
+    showCapacity?: boolean;
+    successMessage?: string;
+    waitlistMessage?: string;
+    buttonText?: string | null;
+    buttonVariant?: 'primary' | 'secondary' | 'outline';
+    spamProtectionEnabled?: boolean;
+    supportEmail?: string;
+    blockId?: string | null;
+}>;
+export type EventRegistrationOverrideInputResult = Readonly<{
+    ok: true;
+    value: EventRegistrationOverrideInput;
+}> | Readonly<{
+    ok: false;
+    reason: 'missing-site-id' | 'missing-api-base-url';
+    message: string;
+}>;

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

@@ -0,0 +1,10 @@
+import type { BlockApiConfig } from '../../api';
+import type { EventRegistrationOverrideInputResult, EventRegistrationOverridePropsLike } from './event-registration.headless.contract';
+export declare function createEventRegistrationBlockApiConfig(input: Readonly<{
+    siteId: string;
+    apiBaseUrl: string;
+    portalToken?: string | null;
+    previewToken?: string | null;
+    stage?: 'preview' | 'published';
+}>): BlockApiConfig;
+export declare function getEventRegistrationOverrideInput(props: EventRegistrationOverridePropsLike): EventRegistrationOverrideInputResult;

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

@@ -0,0 +1,22 @@
+import type { PaymentSelection, PublicEvent, RegistrationStep } from './types';
+import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
+import { type EventRegistrationFlowStatus, type EventRegistrationFlowStep, type EventRegistrationFlowView, type EventRegistrationPaymentSelection, type EventRegistrationSubmitPlan } from './event-registration.headless.contract';
+export declare function getRegistrableStatuses(isPreview: boolean | undefined): readonly PublicEvent['status'][];
+export declare function normalizeEventRegistrationMaxTickets(value: string | number | undefined): number;
+export declare function toHeadlessPaymentSelection(selection: PaymentSelection): EventRegistrationPaymentSelection;
+export declare function toInternalPaymentSelection(selection: EventRegistrationPaymentSelection): PaymentSelection;
+export declare function resolveEventRegistrationSubmitPlan(input: Readonly<{
+    paymentSelection: PaymentSelection;
+    eventRequiresPayment: boolean;
+    canJoinWaitlist?: boolean | null;
+}>): EventRegistrationSubmitPlan;
+export declare function resolveHeadlessEventRegistrationStatus(wizard: Pick<UseEventRegistrationWizardResult, 'step' | 'registrationResult' | 'errorMessage'>): EventRegistrationFlowStatus;
+export declare function resolveHeadlessEventRegistrationView(wizard: Readonly<Pick<UseEventRegistrationWizardResult, 'step' | 'scopedEvents' | 'occurrenceContext' | 'registrationResult' | 'errorMessage'> & {
+    api: Pick<UseEventRegistrationWizardResult['api'], 'config'>;
+}>): EventRegistrationFlowView;
+export declare function deriveEventRegistrationSteps(input: Readonly<{
+    step: RegistrationStep;
+    hasPreSelectedContext: boolean;
+    eventRequiresPayment: boolean;
+    paymentSelection: PaymentSelection;
+}>): readonly EventRegistrationFlowStep[];

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

@@ -0,0 +1,3 @@
+export * from './event-registration.headless.contract';
+export * from './event-registration.headless.override';
+export * from './event-registration.headless.planning';

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

@@ -2,6 +2,25 @@ import type { BlockApiClient } from '../../api';
 import type { FormData, Guest, RegistrationResult, RegistrationStep, PaymentSelection } from './types';
 import type { PaymentMethod } from '../../api/types';
 import type { RegistrationTarget } from './registrationDerivations';
+export type EventRegistrationSubmitOptions = Readonly<{
+    redirect?: 'auto' | 'manual';
+}>;
+export type EventRegistrationSubmitResult = Readonly<{
+    ok: true;
+    outcome: {
+        kind: 'completed';
+    };
+}> | Readonly<{
+    ok: true;
+    outcome: {
+        kind: 'checkout_redirect';
+        checkoutUrl: string;
+    };
+}> | Readonly<{
+    ok: false;
+    reason: 'blocked' | 'missing-target' | 'submission-failed';
+    message: string;
+}>;
 export declare function useEventRegistrationSubmit(options: {
     api: BlockApiClient;
     registrationTarget: RegistrationTarget | null;
@@ -18,4 +37,4 @@ export declare function useEventRegistrationSubmit(options: {
     setStep: (step: RegistrationStep) => void;
     setRegistrationResult: (result: RegistrationResult) => void;
     setErrorMessage: (message: string) => void;
-}): (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection) => Promise<void>;
+}): (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;

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

@@ -1,6 +1,13 @@
 import type { DiscountContext } from '../../api/types';
 import type { EventRegistrationClientProps, FormData, Guest, GuestErrors, PaymentSelection, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult, RegistrationStep } from './types';
-import type { PaymentMethod } from './PaymentSelectionStep';
+export type EventRegistrationDetailsCompleteResult = Readonly<{
+    ok: true;
+    outcome: 'payment-step' | 'submitted';
+}> | Readonly<{
+    ok: false;
+    reason: 'blocked' | 'validation-failed' | 'submission-failed';
+    message: string;
+}>;
 export declare function useEventRegistrationWizard(options: {
     anchorId: string;
     occurrenceContext: EventRegistrationClientProps['occurrenceContext'];
@@ -61,6 +68,7 @@ export declare function useEventRegistrationWizard(options: {
     altchaSolution: string | null;
     setAltchaSolution: import("react").Dispatch<import("react").SetStateAction<string | null>>;
     portalAuthState: import("./hooks").PortalAuthState;
+    portalProfile: import("./hooks").PortalProfile | null;
     showMagicLinkModal: boolean;
     setShowMagicLinkModal: import("react").Dispatch<import("react").SetStateAction<boolean>>;
     handleLogout: () => void;
@@ -75,6 +83,7 @@ export declare function useEventRegistrationWizard(options: {
     eligibilityError: string | null;
     existingRegistration: import("../../api").CustomerEventRegistration | null;
     existingRegistrationLoading: boolean;
+    existingRegistrationState: import("./hooks.state").ExistingRegistrationLookupState;
     hasEligibility: boolean;
     hasMembershipEligibility: boolean;
     requireGuestDetails: boolean;
@@ -89,11 +98,11 @@ export declare function useEventRegistrationWizard(options: {
     discountContext: DiscountContext | null;
     shouldShowDiscountToggle: boolean;
     verification: import("../../hooks/usePaymentVerification").PaymentVerificationResult;
-    handleDetailsComplete: () => Promise<void>;
-    handlePaymentSelect: (method: PaymentMethod, passId?: string, membershipId?: string) => Promise<void>;
+    handleDetailsComplete: () => Promise<EventRegistrationDetailsCompleteResult>;
+    handlePaymentSelect: () => Promise<void>;
     handleUseCardInsteadOfPass: () => void;
     handleBookForSomeoneElse: () => void;
-    handleSubmit: (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection) => Promise<void>;
+    handleSubmit: (method: import("./PaymentSelectionStep").PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: import("./useEventRegistrationSubmit").EventRegistrationSubmitOptions) => Promise<import("./useEventRegistrationSubmit").EventRegistrationSubmitResult>;
     handleEventSelect: (event: RegistrationEvent) => void;
     handleRetry: () => void;
 };

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

@@ -2,7 +2,7 @@ import type { EligibilityCheckResponse } from '../../api/types';
 import type { EligibilityData, EligibilityEventTicketType, PublicEvent, PublicEventTicketType, RegistrationEvent } from './types';
 export declare const DEFAULT_EVENT_CURRENCY = "usd";
 export type SelectableEventTicketType = EligibilityEventTicketType | PublicEventTicketType;
-type TicketTypeSourceEvent = Pick<PublicEvent, 'pricing'> | Pick<RegistrationEvent, 'pricing'>;
+type TicketTypeSourceEvent = PublicEvent | RegistrationEvent;
 /**
  * Format date for display
  */

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

@@ -7,6 +7,10 @@ export type EventRegistrationContentEntry = Readonly<{
     slug: string;
     contentTypeSlug: string;
 }>;
+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"];
+export type EventRegistrationGenericShellStepLabels = typeof EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
+type EventRegistrationShellStepLabel = typeof EVENT_REGISTRATION_SHELL_STEP_LABELS[number];
 export type EventRegistrationSourceProps = Readonly<{
     siteId?: string;
     apiBaseUrl?: string;
@@ -29,8 +33,11 @@ export type EventRegistrationSourceProps = Readonly<{
 }>;
 export type EventRegistrationDisplay = Readonly<{
     kind: 'event-registration';
-    state: 'shell';
+    state: 'generic-shell';
     className: string | null;
+    titleText: string;
+    bodyText: string;
+    stepLabels: readonly EventRegistrationShellStepLabel[];
     summaryButtonText: string;
 }>;
 export type EventRegistrationHydration = Readonly<Omit<InternalEventRegistrationClientProps, 'siteId' | 'stage' | 'registrationEndpoint' | 'eligibilityEndpoint' | 'checkoutEndpoint' | 'buttonText' | 'className'>>;
@@ -71,8 +78,11 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
     }>) => Readonly<{
         display: Readonly<{
             kind: "event-registration";
-            state: "shell";
+            state: "generic-shell";
             className: string | null;
+            titleText: string;
+            bodyText: string;
+            stepLabels: readonly EventRegistrationShellStepLabel[];
             summaryButtonText: string;
         }>;
         hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText" | "registrationEndpoint" | "eligibilityEndpoint" | "checkoutEndpoint">>;
@@ -132,8 +142,11 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
             encode: (value: Readonly<{
                 display: Readonly<{
                     kind: "event-registration";
-                    state: "shell";
+                    state: "generic-shell";
                     className: string | null;
+                    titleText: string;
+                    bodyText: string;
+                    stepLabels: readonly EventRegistrationShellStepLabel[];
                     summaryButtonText: string;
                 }>;
                 hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText" | "registrationEndpoint" | "eligibilityEndpoint" | "checkoutEndpoint">>;
@@ -141,8 +154,11 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
             decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                 display: Readonly<{
                     kind: "event-registration";
-                    state: "shell";
+                    state: "generic-shell";
                     className: string | null;
+                    titleText: string;
+                    bodyText: string;
+                    stepLabels: readonly EventRegistrationShellStepLabel[];
                     summaryButtonText: string;
                 }>;
                 hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText" | "registrationEndpoint" | "eligibilityEndpoint" | "checkoutEndpoint">>;
@@ -164,8 +180,11 @@ export declare const eventRegistrationInteractiveIslandPropsCodec: Readonly<{
         } & Readonly<{
             display: Readonly<{
                 kind: "event-registration";
-                state: "shell";
+                state: "generic-shell";
                 className: string | null;
+                titleText: string;
+                bodyText: string;
+                stepLabels: readonly EventRegistrationShellStepLabel[];
                 summaryButtonText: string;
             }>;
             hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText" | "registrationEndpoint" | "eligibilityEndpoint" | "checkoutEndpoint">>;
@@ -184,8 +203,11 @@ export declare const eventRegistrationInteractiveIslandPropsCodec: Readonly<{
         } & Readonly<{
             display: Readonly<{
                 kind: "event-registration";
-                state: "shell";
+                state: "generic-shell";
                 className: string | null;
+                titleText: string;
+                bodyText: string;
+                stepLabels: readonly EventRegistrationShellStepLabel[];
                 summaryButtonText: string;
             }>;
             hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText" | "registrationEndpoint" | "eligibilityEndpoint" | "checkoutEndpoint">>;

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

@@ -0,0 +1,14 @@
+import type { PublicEventPricing } from '../../../../../../../core/src/index';
+import type { PublicEventTicketType } from '../../../../blocks/events/shared/types';
+type RuntimeEventPricingSource = {
+    pricing?: unknown;
+    requiresRegistration?: boolean | null;
+    pricingType?: unknown;
+    price?: unknown;
+    currency?: unknown;
+    priceDisplay?: unknown;
+    pricingMode?: unknown;
+    ticketTypes?: unknown;
+};
+export declare function resolveRuntimeEventPricing(event: RuntimeEventPricingSource): PublicEventPricing<PublicEventTicketType>;
+export {};

package/dist/_dts/content-editor/src/controller/EntryControllerProvider.d.ts

@@ -1,6 +1,6 @@
 import { type ContentEntrySnapshot, type ContentTypeSchema, type ToolbarState } from "../../../content-model/src/index";
 import type { EditorBlockId } from "../../../core/src/index";
-import type { BlockItem } from "../../../editor-blocks/src/index";
+import type { BlockItem } from "../../../editor-blocks/src/block-editor/types";
 import { type ReactNode } from "react";
 import { type PublishOptions } from "../hooks/useEntryActions";
 import { type ApiClient } from "../services";

package/dist/_dts/content-editor/src/controller/buildBlockPublishedBaselines.d.ts

@@ -1,4 +1,4 @@
 import { type EditorBlockPublishedBaselineInput } from '../../../core/src/index';
-import type { BlockItem } from '../../../editor-blocks/src/index';
+import type { BlockItem } from '../../../editor-blocks/src/block-editor/types';
 export type BlockPublishedBaselineInput = EditorBlockPublishedBaselineInput;
 export declare function buildBlockPublishedBaselines(blocks: readonly BlockItem[]): BlockPublishedBaselineInput[];

package/dist/_dts/content-editor/src/controller/seedDraftBaselinesFromBlocks.d.ts

@@ -1,4 +1,4 @@
-import type { BlockItem } from '../../../editor-blocks/src/index';
+import type { BlockItem } from '../../../editor-blocks/src/block-editor/types';
 import type { EditorUiState } from '../ui/editorUiStore';
 type StoreApi<T> = {
     getState: () => T;

package/dist/_dts/content-editor/src/controller/useBlocksList.d.ts

@@ -1,4 +1,4 @@
-import type { BlockItem } from '../../../editor-blocks/src/index';
+import type { BlockItem } from '../../../editor-blocks/src/block-editor/types';
 import type { EditorUiState } from '../ui/editorUiStore';
 import type { ApiClient } from '../services';
 type StoreApi<T> = {

package/dist/_dts/content-editor/src/controller/useInvalidBlockRecovery.d.ts

@@ -1,4 +1,4 @@
-import type { BlockItem } from '../../../editor-blocks/src/index';
+import type { BlockItem } from '../../../editor-blocks/src/block-editor/types';
 import type { EditorUiStoreInstance } from '../ui/editorUiStore';
 import { type RecoveryConflict } from './deriveRecoveryConflict';
 type UseInvalidBlockRecoveryOptions = Readonly<{

package/dist/_dts/content-editor/src/primitives/PreviewRichTextEditor.d.ts

@@ -2,10 +2,11 @@ import type { RichTextPrimitiveProps } from "../../../blocks/src/index";
 import type { PreviewLinkedEntryFieldBinding } from '../../../blocks/src/system/data/index';
 type PreviewRichTextEditorProps = RichTextPrimitiveProps & {
     onLinkedEntryFieldFocus?: (binding: PreviewLinkedEntryFieldBinding) => void;
+    onBlockFieldFocus?: (path: string) => void;
 };
 /**
  * Memoized version to prevent unnecessary re-renders.
  * Only re-renders when path, doc, variant, or className props actually change.
  */
-export declare const PreviewRichTextEditor: import("react").MemoExoticComponent<({ path, linkedEntryField, onLinkedEntryFieldFocus, className, doc, variant }: PreviewRichTextEditorProps) => import("react").JSX.Element>;
+export declare const PreviewRichTextEditor: import("react").MemoExoticComponent<({ path, linkedEntryField, onLinkedEntryFieldFocus, onBlockFieldFocus, className, doc, variant }: PreviewRichTextEditorProps) => import("react").JSX.Element>;
 export {};

package/dist/_dts/content-editor/src/primitives/PreviewTextEditor.d.ts

@@ -2,6 +2,7 @@ import type { TextProps } from '../../../blocks/src/index';
 import type { PreviewLinkedEntryFieldBinding } from '../../../blocks/src/system/data/index';
 type PreviewTextEditorProps = TextProps & {
     onLinkedEntryFieldFocus?: (binding: PreviewLinkedEntryFieldBinding) => void;
+    onBlockFieldFocus?: (path: string) => void;
 };
 /**
  * Inline text editor for preview mode with local authority.

package/dist/_dts/content-model/src/entry-slots/index.d.ts

@@ -0,0 +1 @@
+export * from './types';