@riverbankcms/sdk 0.88.0 → 0.90.0

package/dist/_dts/blocks/src/system/runtime/components/runtime-backed-blocks.d.ts

@@ -341,6 +341,7 @@ export declare const runtimeBackedBlockServerEntries: {
                 loadMoreText?: string;
                 startOfWeek?: import("../..").WeekStart;
                 calendarTabViews?: import("../..").CalendarTabViews;
+                defaultCalendarView?: import("../..").CalendarView;
                 showFilters?: boolean | null;
                 showCategoryFilter?: import("../..").FilterAutoShow;
                 showVenueFilter?: boolean | null;
@@ -371,6 +372,7 @@ export declare const runtimeBackedBlockServerEntries: {
                     paginationAction: import("../nodes/events/shared/listOptions").EventListPaginationAction;
                     startOfWeek: import("../..").WeekStart;
                     calendarTabViews: import("../..").CalendarTabViews;
+                    defaultCalendarView: import("../..").CalendarView;
                     showFilters: boolean;
                     showCategoryFilter: import("../..").FilterAutoShow;
                     showVenueFilter: boolean;
@@ -418,6 +420,7 @@ export declare const runtimeBackedBlockServerEntries: {
                         loadMoreText?: string;
                         startOfWeek?: import("../..").WeekStart;
                         calendarTabViews?: import("../..").CalendarTabViews;
+                        defaultCalendarView?: import("../..").CalendarView;
                         showFilters?: boolean | null;
                         showCategoryFilter?: import("../..").FilterAutoShow;
                         showVenueFilter?: boolean | null;
@@ -454,6 +457,7 @@ export declare const runtimeBackedBlockServerEntries: {
                         loadMoreText?: string;
                         startOfWeek?: import("../..").WeekStart;
                         calendarTabViews?: import("../..").CalendarTabViews;
+                        defaultCalendarView?: import("../..").CalendarView;
                         showFilters?: boolean | null;
                         showCategoryFilter?: import("../..").FilterAutoShow;
                         showVenueFilter?: boolean | null;
@@ -487,6 +491,7 @@ export declare const runtimeBackedBlockServerEntries: {
                             paginationAction: import("../nodes/events/shared/listOptions").EventListPaginationAction;
                             startOfWeek: import("../..").WeekStart;
                             calendarTabViews: import("../..").CalendarTabViews;
+                            defaultCalendarView: import("../..").CalendarView;
                             showFilters: boolean;
                             showCategoryFilter: import("../..").FilterAutoShow;
                             showVenueFilter: boolean;
@@ -527,6 +532,7 @@ export declare const runtimeBackedBlockServerEntries: {
                             paginationAction: import("../nodes/events/shared/listOptions").EventListPaginationAction;
                             startOfWeek: import("../..").WeekStart;
                             calendarTabViews: import("../..").CalendarTabViews;
+                            defaultCalendarView: import("../..").CalendarView;
                             showFilters: boolean;
                             showCategoryFilter: import("../..").FilterAutoShow;
                             showVenueFilter: boolean;
@@ -1191,6 +1197,12 @@ export declare const runtimeBackedBlockServerEntries: {
                 spamProtectionEnabled?: boolean;
                 stage?: "preview" | "published";
                 supportEmail?: string;
+                sitePasses?: Readonly<{
+                    passes: readonly import("../..").PublicPassProduct[];
+                }> | null;
+                siteMemberships?: Readonly<{
+                    memberships: readonly import("../..").PublicMembershipProduct[];
+                }> | null;
             }>) => Readonly<{
                 display: Readonly<{
                     kind: "event-registration";
@@ -1229,6 +1241,12 @@ export declare const runtimeBackedBlockServerEntries: {
                         spamProtectionEnabled?: boolean;
                         stage?: "preview" | "published";
                         supportEmail?: string;
+                        sitePasses?: Readonly<{
+                            passes: readonly import("../..").PublicPassProduct[];
+                        }> | null;
+                        siteMemberships?: Readonly<{
+                            memberships: readonly import("../..").PublicMembershipProduct[];
+                        }> | null;
                     }>) => unknown;
                     decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                         siteId?: string;
@@ -1254,6 +1272,12 @@ export declare const runtimeBackedBlockServerEntries: {
                         spamProtectionEnabled?: boolean;
                         stage?: "preview" | "published";
                         supportEmail?: string;
+                        sitePasses?: Readonly<{
+                            passes: readonly import("../..").PublicPassProduct[];
+                        }> | null;
+                        siteMemberships?: Readonly<{
+                            memberships: readonly import("../..").PublicMembershipProduct[];
+                        }> | null;
                     }>>;
                 }>;
                 render: Readonly<{

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

@@ -0,0 +1 @@
+export declare function toError(error: unknown, fallbackMessage: string): Error;

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

@@ -15,7 +15,7 @@ export type UseAvailableDatesOptions = {
     initialDays?: number;
 };
 export type UseAvailableDatesResult = {
-    availableDates: Set<string>;
+    availableDates: ReadonlySet<string>;
     isLoading: boolean;
     isRefreshing: boolean;
     error: string | null;

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

@@ -0,0 +1,55 @@
+export type AvailableDatesLoadedRange = {
+    start: string;
+    end: string;
+};
+export type AvailableDatesData = {
+    availableDates: ReadonlySet<string>;
+    hasMore: boolean;
+    loadedRange: AvailableDatesLoadedRange | null;
+    nextStartDate: string | null;
+};
+export type AvailableDatesState = {
+    tag: "idle";
+    data: AvailableDatesData;
+} | {
+    tag: "loading";
+    data: AvailableDatesData;
+} | {
+    tag: "loaded";
+    data: AvailableDatesData;
+} | {
+    tag: "refreshing";
+    data: AvailableDatesData;
+} | {
+    tag: "error";
+    data: AvailableDatesData;
+    message: string;
+};
+export type AvailableDatesAction = {
+    type: "query-cleared";
+} | {
+    type: "load-started";
+} | {
+    type: "refresh-started";
+} | {
+    type: "load-succeeded";
+    dates: readonly string[];
+    hasMore: boolean;
+    nextStartDate: string | null;
+    startDate: string;
+    endDate: string;
+    append: boolean;
+} | {
+    type: "load-failed";
+    message: string;
+};
+export declare function createInitialAvailableDatesState(): AvailableDatesState;
+export declare const initialAvailableDatesState: AvailableDatesState;
+export declare function getAvailableDates(state: AvailableDatesState): ReadonlySet<string>;
+export declare function getAvailableDatesLoadedRange(state: AvailableDatesState): AvailableDatesLoadedRange | null;
+export declare function getAvailableDatesNextStartDate(state: AvailableDatesState): string | null;
+export declare function hasMoreAvailableDates(state: AvailableDatesState): boolean;
+export declare function isLoadingAvailableDates(state: AvailableDatesState): boolean;
+export declare function isRefreshingAvailableDates(state: AvailableDatesState): boolean;
+export declare function getAvailableDatesError(state: AvailableDatesState): string | null;
+export declare function availableDatesReducer(state: AvailableDatesState, action: AvailableDatesAction): AvailableDatesState;

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

@@ -0,0 +1,39 @@
+import type { TimeSlot } from "../api";
+export type AvailableSlotsState = {
+    tag: "idle";
+} | {
+    tag: "loading";
+    hasLoaded: boolean;
+} | {
+    tag: "loaded";
+    slots: TimeSlot[];
+} | {
+    tag: "refreshing";
+    slots: TimeSlot[];
+    hasLoaded: boolean;
+} | {
+    tag: "error";
+    slots: TimeSlot[];
+    hasLoaded: boolean;
+    message: string;
+};
+export type AvailableSlotsAction = {
+    type: "query-cleared";
+} | {
+    type: "load-started";
+} | {
+    type: "refresh-started";
+} | {
+    type: "load-succeeded";
+    slots: TimeSlot[];
+} | {
+    type: "load-failed";
+    message: string;
+};
+export declare const initialAvailableSlotsState: AvailableSlotsState;
+export declare function getAvailableSlots(state: AvailableSlotsState): TimeSlot[];
+export declare function hasLoadedAvailableSlots(state: AvailableSlotsState): boolean;
+export declare function isLoadingAvailableSlots(state: AvailableSlotsState): boolean;
+export declare function isRefreshingAvailableSlots(state: AvailableSlotsState): boolean;
+export declare function getAvailableSlotsError(state: AvailableSlotsState): string | null;
+export declare function availableSlotsReducer(state: AvailableSlotsState, action: AvailableSlotsAction): AvailableSlotsState;

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

@@ -4,34 +4,12 @@
  * Uses the Block API Client for type-safe API calls.
  * Must be used within a BlockApiProvider.
  */
-import type { FormField } from '../components/multi-step/DynamicFormFields';
-export interface Service {
-    id: string;
-    title: string;
-    description?: string;
-    durationMinutes?: number;
-    paymentTerms?: import("../../blocks/shared/bookingPaymentTerms").BlockBookingPaymentTerms;
-}
-export interface BookingFormConfig {
-    id: string;
-    name: string;
-    slug: string;
-    settings?: {
-        type: 'booking';
-        serviceId?: string;
-        serviceIds?: string[];
-        resourceId?: string;
-        requiresApproval?: boolean;
-        successMessage?: string;
-    };
-    schema?: {
-        version: string;
-        fields: FormField[];
-    };
-}
+import { type BookingFormConfig, type BookingFormService } from '../nodes/booking-form.state';
+export type Service = BookingFormService;
+export type { BookingFormConfig };
 interface UseBookingFormConfigResult {
     formConfig: BookingFormConfig | null;
-    services: Service[];
+    services: readonly Service[];
     isLoading: boolean;
     error: string | null;
 }
@@ -58,4 +36,3 @@ interface UseBookingFormConfigResult {
  * ```
  */
 export declare function useBookingFormConfig(siteId: string, formId: string): UseBookingFormConfigResult;
-export {};

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

@@ -0,0 +1,40 @@
+import type { BookingFormConfig, BookingFormService as Service } from '../nodes/booking-form.state';
+type BookingFormConfigSnapshot = Readonly<{
+    formConfig: BookingFormConfig | null;
+    services: readonly Service[];
+}>;
+export type BookingFormConfigState = Readonly<{
+    tag: 'loading';
+    previous: BookingFormConfigSnapshot;
+}> | Readonly<{
+    tag: 'loaded';
+    formConfig: BookingFormConfig;
+    services: readonly Service[];
+}> | Readonly<{
+    tag: 'error';
+    message: string;
+    previous: BookingFormConfigSnapshot;
+}>;
+export type BookingFormConfigAction = Readonly<{
+    type: 'load-started';
+}> | Readonly<{
+    type: 'form-loaded';
+    formConfig: BookingFormConfig;
+}> | Readonly<{
+    type: 'load-succeeded';
+    formConfig: BookingFormConfig;
+    services: readonly Service[];
+}> | Readonly<{
+    type: 'services-load-failed';
+    message: string;
+}> | Readonly<{
+    type: 'load-failed';
+    message: string;
+}>;
+export declare function createInitialBookingFormConfigState(): BookingFormConfigState;
+export declare function bookingFormConfigReducer(state: BookingFormConfigState, action: BookingFormConfigAction): BookingFormConfigState;
+export declare function selectBookingFormConfig(state: BookingFormConfigState): BookingFormConfig | null;
+export declare function selectBookingFormServices(state: BookingFormConfigState): readonly Service[];
+export declare function selectBookingFormConfigIsLoading(state: BookingFormConfigState): boolean;
+export declare function selectBookingFormConfigError(state: BookingFormConfigState): string | null;
+export {};

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

@@ -0,0 +1,20 @@
+export type CalendarEventCacheLoadState = Readonly<{
+    kind: 'idle';
+}> | Readonly<{
+    kind: 'loading';
+}> | Readonly<{
+    kind: 'error';
+    error: Error;
+}>;
+export type CalendarEventCacheLoadAction = Readonly<{
+    type: 'started';
+}> | Readonly<{
+    type: 'succeeded';
+}> | Readonly<{
+    type: 'failed';
+    error: Error;
+}>;
+export declare function calendarEventCacheLoadReducer(_state: CalendarEventCacheLoadState, action: CalendarEventCacheLoadAction): CalendarEventCacheLoadState;
+export declare function toCalendarEventCacheLoadError(error: unknown): Error;
+export declare function isCalendarEventCacheLoading(state: CalendarEventCacheLoadState): boolean;
+export declare function getCalendarEventCacheError(state: CalendarEventCacheLoadState): Error | null;

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

@@ -0,0 +1,31 @@
+import type { EventFiltersResponse } from '../api/types';
+export declare const EMPTY_EVENT_FILTERS: EventFiltersResponse;
+export type EventFiltersLoadState = Readonly<{
+    kind: 'idle';
+    filters: EventFiltersResponse;
+}> | Readonly<{
+    kind: 'loading';
+    filters: EventFiltersResponse;
+}> | Readonly<{
+    kind: 'loaded';
+    filters: EventFiltersResponse;
+}> | Readonly<{
+    kind: 'error';
+    filters: EventFiltersResponse;
+    error: Error;
+}>;
+export type EventFiltersLoadAction = Readonly<{
+    type: 'started';
+}> | Readonly<{
+    type: 'succeeded';
+    filters: EventFiltersResponse;
+}> | Readonly<{
+    type: 'failed';
+    error: Error;
+}>;
+export declare function createInitialEventFiltersLoadState(): EventFiltersLoadState;
+export declare function eventFiltersLoadReducer(state: EventFiltersLoadState, action: EventFiltersLoadAction): EventFiltersLoadState;
+export declare function toEventFiltersLoadError(error: unknown): Error;
+export declare function getEventFiltersData(state: EventFiltersLoadState): EventFiltersResponse;
+export declare function isEventFiltersLoading(state: EventFiltersLoadState): boolean;
+export declare function getEventFiltersError(state: EventFiltersLoadState): Error | null;

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

@@ -21,9 +21,9 @@ type UseEventPaginationOptions = {
     /** Fetch stage (preview vs published) */
     stage?: 'preview' | 'published';
 };
-type EventPaginationState = {
+type EventPaginationResult = {
     /** All loaded events */
-    events: PublicEvent[];
+    events: readonly PublicEvent[];
     /** Whether a load operation is in progress */
     loading: boolean;
     /** Error from last load attempt */
@@ -49,5 +49,5 @@ type EventPaginationState = {
  * ```
  */
 export declare function useEventPagination({ siteId: _siteId, // Deprecated: siteId now comes from BlockApiProvider context
-initialEvents, fetchInitialOnMount, initialFilters, filters, pageSize, stage, }: UseEventPaginationOptions): EventPaginationState;
+initialEvents, fetchInitialOnMount, initialFilters, filters, pageSize, stage, }: UseEventPaginationOptions): EventPaginationResult;
 export default useEventPagination;

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

@@ -0,0 +1,39 @@
+import type { PublicEvent } from '../../blocks/events/shared/types';
+export type EventPaginationLoadState = Readonly<{
+    kind: 'ready';
+    events: readonly PublicEvent[];
+    hasMore: boolean;
+}> | Readonly<{
+    kind: 'loading';
+    events: readonly PublicEvent[];
+    hasMore: boolean;
+}> | Readonly<{
+    kind: 'error';
+    events: readonly PublicEvent[];
+    hasMore: boolean;
+    error: Error;
+}>;
+export type EventPaginationLoadAction = Readonly<{
+    type: 'started';
+    reset: boolean;
+}> | Readonly<{
+    type: 'succeeded';
+    events: readonly PublicEvent[];
+    hasMore: boolean;
+}> | Readonly<{
+    type: 'failed';
+    error: Error;
+}> | Readonly<{
+    type: 'synced';
+    events: readonly PublicEvent[];
+    pageSize: number;
+}>;
+export declare function createInitialEventPaginationLoadState(events: readonly PublicEvent[], pageSize: number): EventPaginationLoadState;
+export declare function eventPaginationLoadReducer(state: EventPaginationLoadState, action: EventPaginationLoadAction): EventPaginationLoadState;
+export declare function getEventIdentity(event: PublicEvent): string;
+export declare function mergeEventPaginationEvents(existingEvents: readonly PublicEvent[], newEvents: readonly PublicEvent[]): readonly PublicEvent[];
+export declare function toEventPaginationLoadError(error: unknown): Error;
+export declare function getEventPaginationEvents(state: EventPaginationLoadState): readonly PublicEvent[];
+export declare function isEventPaginationLoading(state: EventPaginationLoadState): boolean;
+export declare function getEventPaginationError(state: EventPaginationLoadState): Error | null;
+export declare function hasMoreEventPages(events: readonly PublicEvent[], pageSize: number): boolean;

package/dist/_dts/blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationWizard.d.ts

@@ -44,9 +44,9 @@ export declare function useCourseRegistrationWizard(props: CourseRegistrationCli
     selectedMembershipId: string | null;
     setSelectedMembershipId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
     discountUiOpen: boolean;
-    setDiscountUiOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setDiscountUiOpen: (isOpen: boolean) => void;
     discountCode: string;
-    setDiscountCode: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setDiscountCode: (code: string) => void;
     discountsAvailable: boolean;
     manualCodeEntryAllowed: boolean;
     discountsAvailableLoading: boolean;

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

@@ -1,5 +1,5 @@
 import type { PublicEvent } from '../../../blocks/events/shared/types';
-import type { PublicPassProduct, PublicMembershipProduct } from '../../../blocks/shop';
+export { filterPassesForEvent, filterMembershipsForEvent, } from '../events/shared/eventProductEligibility';
 export type OccurrenceContextLike = {
     id: string;
     seriesId: string;
@@ -19,19 +19,3 @@ export declare function selectEventDetails(args: {
     nowIso: string;
     otherDatesLimit: string | number | null | undefined;
 }): EventDetailsSelection;
-/**
- * Filter site passes to only those that cover the selected event.
- *
- * @param sitePasses - Array of all site passes (may be null/undefined)
- * @param event - The selected event (may be null)
- * @returns Passes that cover the event based on category eligibility
- */
-export declare function filterPassesForEvent(sitePasses: PublicPassProduct[] | null | undefined, event: PublicEvent | null): PublicPassProduct[];
-/**
- * Filter site memberships to only those that cover the selected event.
- *
- * @param siteMemberships - Array of all site memberships (may be null/undefined)
- * @param event - The selected event (may be null)
- * @returns Memberships that cover the event based on category eligibility
- */
-export declare function filterMembershipsForEvent(siteMemberships: PublicMembershipProduct[] | null | undefined, event: PublicEvent | null): PublicMembershipProduct[];

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

@@ -2,7 +2,7 @@ import React from 'react';
 import type { EventAutoApplyDiscountPreview } from '../../blocks/event-details';
 import type { EventDetailsContentEntry, EventDetailsIslandProps } from '../../../contracts';
 import type { PublicEvent } from '../../blocks/events/shared/types';
-import type { PublicPassProduct, PublicMembershipProduct } from '../../blocks/shop';
+import type { PublicMembershipProductCollection, PublicPassProductCollection } from '../../blocks/shop';
 import { type OccurrenceContextLike } from './event-details/logic';
 export type EventDetailsClientProps = Readonly<{
     occurrenceContext?: OccurrenceContextLike | null;
@@ -15,14 +15,10 @@ export type EventDetailsClientProps = Readonly<{
     showCost?: boolean;
     showAcceptedPasses?: boolean;
     showAcceptedMemberships?: boolean;
-    /** Response from listPublicPasses API (wrapped in { passes: [...] }) */
-    sitePasses?: {
-        passes: PublicPassProduct[];
-    } | null;
-    /** Response from listPublicMemberships API (wrapped in { memberships: [...] }) */
-    siteMemberships?: {
-        memberships: PublicMembershipProduct[];
-    } | null;
+    /** Response from listPublicPasses API. */
+    sitePasses?: PublicPassProductCollection | null;
+    /** Response from listPublicMemberships API. */
+    siteMemberships?: PublicMembershipProductCollection | null;
     /** Best auto-apply discount code to advertise under the price, if any */
     autoApplyDiscount?: EventAutoApplyDiscountPreview | null;
     className?: string | null;

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

@@ -1,7 +1,7 @@
 import React from 'react';
 import type { EventAutoApplyDiscountPreview } from '../../blocks/event-details';
 import type { PublicEvent } from '../../blocks/events/shared/types';
-import type { PublicPassProduct, PublicMembershipProduct } from '../../blocks/shop';
+import type { PublicMembershipProductCollection, PublicPassProductCollection } from '../../blocks/shop';
 import { type OccurrenceContextLike } from './event-details/logic';
 type EventDetailsProps = {
     blockId?: string | null;
@@ -15,14 +15,10 @@ type EventDetailsProps = {
     showCost?: boolean;
     showAcceptedPasses?: boolean;
     showAcceptedMemberships?: boolean;
-    /** Response from listPublicPasses API (wrapped in { passes: [...] }) */
-    sitePasses?: {
-        passes: PublicPassProduct[];
-    } | null;
-    /** Response from listPublicMemberships API (wrapped in { memberships: [...] }) */
-    siteMemberships?: {
-        memberships: PublicMembershipProduct[];
-    } | null;
+    /** Response from listPublicPasses API. */
+    sitePasses?: PublicPassProductCollection | null;
+    /** Response from listPublicMemberships API. */
+    siteMemberships?: PublicMembershipProductCollection | null;
     /** Best auto-apply discount code to advertise under the price, if any */
     autoApplyDiscount?: EventAutoApplyDiscountPreview | null;
     className?: string | null;

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

@@ -1,4 +1,4 @@
-import type { PaymentMethod } from '../../api/types';
+import type { DirectCheckoutCollectionOptionKind, 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';
@@ -123,6 +123,7 @@ export type EventRegistrationPaymentSelection = Readonly<{
     method: 'free';
 }> | Readonly<{
     method: 'stripe';
+    collectionOptionKind?: DirectCheckoutCollectionOptionKind;
 }> | Readonly<{
     method: 'pass';
     passId: string;

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

@@ -0,0 +1,24 @@
+import type { DirectCheckoutCollectionOptionKind } from '../../api/types';
+import type { BlockBookingPaymentCollectionOption, BlockBookingPaymentTerms } from '../../../blocks/shared/bookingPaymentTerms';
+import { type BookingPaymentOptionViewModel } from '../../shared/bookingPaymentOptions';
+type SupportedEventDirectPaymentOption = Extract<BlockBookingPaymentCollectionOption, {
+    kind: 'upfront' | 'flexible_balance';
+}>;
+export type EventRegistrationDirectPaymentOption = Omit<BookingPaymentOptionViewModel, 'kind' | 'title'> & Readonly<{
+    kind: Extract<DirectCheckoutCollectionOptionKind, SupportedEventDirectPaymentOption['kind']>;
+    label: string;
+}>;
+export type EventRegistrationPaymentOptionsViewModel = Readonly<{
+    mode: 'single_option' | 'choice_required';
+    sectionTitle: string;
+    options: readonly EventRegistrationDirectPaymentOption[];
+}>;
+export declare function buildEventRegistrationPaymentOptionsViewModel(input: Readonly<{
+    eventTitle: string;
+    paymentTerms?: BlockBookingPaymentTerms | null;
+    totalPriceCents: number;
+    currency: string;
+    startsAt?: string | null;
+    locale?: string;
+}>): EventRegistrationPaymentOptionsViewModel;
+export {};

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

@@ -1,5 +1,6 @@
 import type { PublicEvent, PublicEventTicketType, PublicEventTicketTypeAvailability } from '../../../blocks/events/shared/types';
 import type { OccurrenceContext } from '../../../blocks/event-registration.shared';
+import type { PublicMembershipProductCollection, PublicPassProductCollection } from '../../../blocks/shop.shared';
 import type { AvailablePass, AvailableMembership, DirectCheckoutCollectionOptionKind, EligibilityEventTicketType } from '../../api/types';
 export type { PublicEvent, OccurrenceContext };
 export type { FormData } from '../../shared';
@@ -169,4 +170,8 @@ export type EventRegistrationClientProps = {
     stage?: 'preview' | 'published';
     /** Support email to display on timeout step */
     supportEmail?: string;
+    /** Site-wide public pass products; filtered against the selected event before prompting. */
+    sitePasses?: PublicPassProductCollection | null;
+    /** Site-wide public membership products; filtered against the selected event before prompting. */
+    siteMemberships?: PublicMembershipProductCollection | null;
 };

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

@@ -1,16 +1,16 @@
 import type { BlockApiClient } from '../../api';
-import type { AutoAppliedDiscountPreview, DiscountContext } from '../../api/types';
+import { type DiscountContext } from '../../api/types';
 export declare function useDiscountCodeUi(options: {
     api: BlockApiClient;
     discountContext: DiscountContext | null;
     subtotalCents?: number;
 }): {
     discountUiOpen: boolean;
-    setDiscountUiOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setDiscountUiOpen: (isOpen: boolean) => void;
     discountCode: string;
-    setDiscountCode: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setDiscountCode: (code: string) => void;
     discountsAvailable: boolean;
     manualCodeEntryAllowed: boolean;
-    autoAppliedDiscount: AutoAppliedDiscountPreview | null;
+    autoAppliedDiscount: import("../../api/types").AutoAppliedDiscountPreview | null;
     discountsAvailableLoading: boolean;
 };

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

@@ -0,0 +1,50 @@
+import { type AutoAppliedDiscountPreview, type DiscountContext, type DiscountsAvailableRequest, type DiscountsAvailableResponse } from '../../api/types';
+export type DiscountAvailabilityRequestPlan = Readonly<{
+    ok: false;
+    key: 'disabled';
+}> | Readonly<{
+    ok: true;
+    key: string;
+    request: Omit<DiscountsAvailableRequest, 'siteId'>;
+}>;
+type DiscountAvailabilityState = Readonly<{
+    tag: 'disabled';
+}> | Readonly<{
+    tag: 'loading';
+}> | Readonly<{
+    tag: 'unavailable';
+}> | Readonly<{
+    tag: 'available';
+    manualCodeEntryAllowed: boolean;
+    autoAppliedDiscount: AutoAppliedDiscountPreview | null;
+}> | Readonly<{
+    tag: 'error';
+}>;
+export type DiscountCodeUiState = Readonly<{
+    discountUiOpen: boolean;
+    discountCode: string;
+    availability: DiscountAvailabilityState;
+}>;
+export type DiscountCodeUiEvent = Readonly<{
+    type: 'availability-disabled';
+}> | Readonly<{
+    type: 'availability-loading';
+}> | Readonly<{
+    type: 'availability-loaded';
+    response: DiscountsAvailableResponse;
+}> | Readonly<{
+    type: 'availability-failed';
+}> | Readonly<{
+    type: 'discount-code-changed';
+    code: string;
+}> | Readonly<{
+    type: 'discount-ui-open-changed';
+    isOpen: boolean;
+}>;
+export declare const initialDiscountCodeUiState: DiscountCodeUiState;
+export declare function buildDiscountAvailabilityRequestPlan(options: {
+    discountContext: DiscountContext | null;
+    subtotalCents?: number;
+}): DiscountAvailabilityRequestPlan;
+export declare function discountCodeUiReducer(state: DiscountCodeUiState, event: DiscountCodeUiEvent): DiscountCodeUiState;
+export {};

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

@@ -88,9 +88,9 @@ export declare function useEventRegistrationWizard(options: {
     hasMembershipEligibility: boolean;
     requireGuestDetails: boolean;
     discountCode: string;
-    setDiscountCode: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setDiscountCode: (code: string) => void;
     discountUiOpen: boolean;
-    setDiscountUiOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setDiscountUiOpen: (isOpen: boolean) => void;
     discountsAvailable: boolean;
     manualCodeEntryAllowed: boolean;
     autoAppliedDiscount: import("../../api/types").AutoAppliedDiscountPreview | null;