@riverbankcms/sdk 0.64.0 → 0.68.0

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

@@ -0,0 +1,140 @@
+import React from "react";
+import { type BlockApiConfig } from "../api";
+import type { AutoAppliedDiscountPreview } from "../api/types";
+import type { BookingFormConfig, BookingFormData, BookingFormService, BookingSelectedCollectionOptionKind } from "../nodes/booking-form.state";
+import { type BookingPaymentSelectionViewModel } from "../shared/bookingPaymentOptions";
+import { createBookingBlockApiConfig, type BookingAppointmentPackagesModel, type BookingFieldValue, type BookingFieldView, type BookingFlowActionResult, type BookingFlowFeedback, type BookingFlowStatus, type BookingFlowView, type BookingResourceView, type BookingFlowStep, type BookingFlowStepId, type BookingSlotView, type BookingSubmitActionResult, type BookingSubmitOptions, type LoadState } from "./useHeadlessBookingFlow.state";
+export type { BlockApiConfig };
+export type { BookingAppointmentPackagesModel };
+export { createBookingBlockApiConfig };
+export type HeadlessBookingFlowOptions = Readonly<{
+    siteId: string;
+    formId: string;
+    form: BookingFormConfig | null;
+    services: readonly BookingFormService[];
+    initialServiceId?: string;
+    initialResourceId?: string;
+    initialData?: Partial<BookingFormData>;
+    requiresServiceSelection?: boolean;
+    requiresResourceSelection?: boolean;
+    shouldAutoSelectSingleResource?: boolean;
+    enableAppointmentPackages?: boolean;
+    spamProtectionEnabled?: boolean;
+    successMessage?: string;
+    anchorId?: string;
+    viewerTimeZone?: string;
+    navigateToCheckout?: (checkoutUrl: string) => void;
+}>;
+export type BookingServicesModel = Readonly<{
+    items: readonly BookingFormService[];
+    selected: BookingFormService | null;
+    defaultServiceId?: string;
+    requiresSelection: boolean;
+}>;
+export type BookingResourcesModel = Readonly<{
+    items: readonly BookingResourceView[];
+    selected: BookingResourceView | null;
+    selectedResourceId?: string;
+    state: LoadState<readonly BookingResourceView[]>;
+    requiresSelection: boolean;
+}>;
+export type BookingAvailabilityModel = Readonly<{
+    selectedDate?: string;
+    availableDates: readonly string[];
+    selectedSlot: BookingSlotView | null;
+    slots: readonly BookingSlotView[];
+    datesState: LoadState<readonly string[]>;
+    slotsState: LoadState<readonly BookingSlotView[]>;
+    timezone: string;
+    hasMoreDates: boolean;
+    loadMoreDates: () => void;
+}>;
+export type BookingFieldsModel = Readonly<{
+    items: readonly BookingFieldView[];
+    values: Readonly<Record<string, BookingFieldValue>>;
+    errors: Readonly<Record<string, string>>;
+    touched: Readonly<Record<string, boolean>>;
+}>;
+export type BookingPaymentModel = Readonly<{
+    kind: "unsupported";
+    mode: "unsupported";
+    selection: null;
+    selectedCollectionOptionKind?: BookingSelectedCollectionOptionKind;
+    selectedAppointmentPackageId?: string;
+    appointmentPackages: BookingAppointmentPackagesModel;
+    errorMessage: string;
+}> | Readonly<{
+    kind: "ok";
+    mode: "hidden" | "disclosure_only" | "choice_required";
+    selection: BookingPaymentSelectionViewModel | null;
+    selectedCollectionOptionKind?: BookingSelectedCollectionOptionKind;
+    selectedAppointmentPackageId?: string;
+    appointmentPackages: BookingAppointmentPackagesModel;
+}>;
+export type BookingDiscountModel = Readonly<{
+    code: string;
+    isOpen: boolean;
+    manualCodeEntryAllowed: boolean;
+    loading: boolean;
+    autoAppliedDiscount: AutoAppliedDiscountPreview | null;
+    setCode: (code: string) => void;
+    setOpen: (isOpen: boolean) => void;
+    clear: () => void;
+}>;
+export type BookingSpamProtectionModel = Readonly<{
+    enabled: false;
+}> | Readonly<{
+    enabled: true;
+    provider: "altcha";
+    challenge: {
+        url: string;
+        auto: "onfocus";
+    };
+    solution: string | null;
+}>;
+export type BookingFlowActions = Readonly<{
+    selectService: (serviceId: string) => void;
+    selectResource: (resourceId: string | null) => void;
+    selectDate: (date: string | null) => void;
+    selectSlot: (slot: BookingSlotView | null) => void;
+    updateField: (fieldId: string, value: BookingFieldValue) => void;
+    markFieldTouched: (fieldId: string) => void;
+    selectPaymentOption: (kind: BookingSelectedCollectionOptionKind | null) => void;
+    selectAppointmentPackage: (packageId: string | null) => void;
+    setDiscountCode: (code: string) => void;
+    clearDiscountCode: () => void;
+    setAltchaSolution: (solution: string | null) => void;
+    invalidateSpamProtection: () => void;
+    next: () => Promise<BookingFlowActionResult>;
+    back: () => void;
+    /**
+     * Moves to a visible step without validating previous steps. Consumers that
+     * want linear progression should consult `steps[].canEnter` or call `next()`.
+     */
+    goToStep: (stepId: BookingFlowStepId) => Promise<BookingFlowActionResult>;
+    submit: (options?: BookingSubmitOptions) => Promise<BookingSubmitActionResult>;
+    reset: () => void;
+    clearFeedback: () => void;
+}>;
+export type HeadlessBookingFlow = Readonly<{
+    status: BookingFlowStatus;
+    view: BookingFlowView;
+    steps: readonly BookingFlowStep[];
+    currentStep: BookingFlowStep | null;
+    data: Partial<BookingFormData>;
+    services: BookingServicesModel;
+    resources: BookingResourcesModel;
+    availability: BookingAvailabilityModel;
+    fields: BookingFieldsModel;
+    payment: BookingPaymentModel;
+    discount: BookingDiscountModel;
+    spamProtection: BookingSpamProtectionModel;
+    feedback: BookingFlowFeedback;
+    actions: BookingFlowActions;
+}>;
+export type HeadlessBookingProviderProps = Readonly<{
+    config: BlockApiConfig;
+    children?: React.ReactNode;
+}>;
+export declare function HeadlessBookingProvider({ config, children, }: HeadlessBookingProviderProps): React.ReactElement;
+export declare function useHeadlessBookingFlow(options: HeadlessBookingFlowOptions): HeadlessBookingFlow;

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

@@ -0,0 +1,2 @@
+export { bookingFlowReducer, buildBookingAvailabilityQuery, buildBookingStepPlan, buildBookingSubmitPlan, createBookingBlockApiConfig, createEmptyBookingValidationErrors, createFieldBookingValidationErrors, createFormBookingValidationError, createInitialBookingFlowReducerState, describeUnknownError, deriveBookingFieldViews, deriveBookingFlowSteps, getAppointmentBookingOverrideInput, hasBookingValidationErrors, resolveAppointmentPackagesModel, resolveAvailabilitySelectionInvalidation, resolveHeadlessBookingStatus, resolveHeadlessBookingView, toBookingFormData, toBookingSlotView, toBookingSlotViews, validateBookingField, validateBookingFields, validateBookingStep, } from "../nodes/booking-form.headless.state";
+export type { AppointmentBookingOverrideData, AppointmentBookingOverrideInput, AppointmentBookingOverrideInputResult, AppointmentBookingOverridePropsLike, BookingAvailabilityQuery, BookingAppointmentPackagesModel, BookingAppointmentPackagesUnavailableReason, BookingFieldValue, BookingFieldView, BookingFlowActionResult, BookingFlowFeedback, BookingFlowStatus, BookingFlowStep, BookingFlowStepId, BookingFlowView, BookingResourceView, BookingSlotView, BookingSubmitActionResult, BookingSubmitOptions, BookingValidationErrors, DerivedBookingFlowSteps, DeriveBookingFlowStepsInput, LoadState, } from "../nodes/booking-form.headless.state";

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

@@ -0,0 +1,10 @@
+export declare const MIN_AVAILABILITY_REFRESH_INTERVAL_MS = 15000;
+type UseVisibleTabPollingOptions = {
+    enabled: boolean;
+    intervalMs: number;
+    jitterMs: number;
+    minVisibleRefreshIntervalMs?: number;
+    onPoll: () => Promise<void> | void;
+};
+export declare function useVisibleTabPolling({ enabled, intervalMs, jitterMs, minVisibleRefreshIntervalMs, onPoll, }: UseVisibleTabPollingOptions): void;
+export {};

package/dist/_dts/blocks/src/system/runtime/nodes/booking-form.default-ui.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { HeadlessBookingFlow } from "../hooks/useHeadlessBookingFlow";
+type HeadlessBookingDefaultFormProps = Readonly<{
+    booking: HeadlessBookingFlow;
+    onSubmit: () => Promise<void>;
+}>;
+export declare function HeadlessBookingDefaultForm({ booking, onSubmit, }: HeadlessBookingDefaultFormProps): React.ReactElement;
+export {};

package/dist/_dts/blocks/src/system/runtime/nodes/booking-form.headless.state.d.ts

@@ -0,0 +1,484 @@
+import type { BlockApiConfig, EligibleAppointmentPackage } from "../api/types";
+import type { TimeSlot } from "../api/types";
+import type { BookingFormConfig, BookingFormData, BookingFormField, BookingPaymentStepResolution, BookingFormServicesSource, BookingFormService, BookingSelectedCollectionOptionKind, BookingSubmissionData } from "./booking-form.state";
+export type LoadState<T> = Readonly<{
+    tag: "idle";
+}> | Readonly<{
+    tag: "loading";
+}> | Readonly<{
+    tag: "loaded";
+    value: T;
+}> | Readonly<{
+    tag: "error";
+    message: string;
+}>;
+export type BookingFlowStepId = "service-selection" | "datetime-selection" | "payment-selection" | "custom-fields";
+export type BookingFlowStepState = "complete" | "active" | "available" | "blocked" | "hidden";
+export type BookingFlowStep = Readonly<{
+    id: BookingFlowStepId;
+    label: string;
+    state: BookingFlowStepState;
+    index: number;
+    visibleIndex: number | null;
+    errors: BookingValidationErrors;
+    canEnter: boolean;
+    canLeave: boolean;
+}>;
+export type BookingValidationErrors = Readonly<{
+    formError: string | null;
+    fieldErrors: Readonly<Record<string, string>>;
+}>;
+export type BookingFieldValue = string | number | boolean | readonly string[] | null;
+export type BookingSlotView = Readonly<{
+    key: string;
+    startAt: string;
+    endAt: string;
+    resourceId: string;
+    resourceName?: string;
+    label?: string;
+}>;
+export type BookingResourceView = Readonly<{
+    id: string;
+    label: string;
+}>;
+export type BookingFlowFeedback = Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "success";
+    message: string;
+    resourceName: string | null;
+}> | Readonly<{
+    kind: "error";
+    scope: "submission" | "verification" | "discount" | "altcha" | "availability" | "payment";
+    message: string;
+}> | Readonly<{
+    kind: "info";
+    scope: "verification" | "payment";
+    message: string;
+}>;
+export type AvailabilitySelectionInvalidation = Readonly<{
+    kind: "preserve";
+}> | Readonly<{
+    kind: "date_unavailable";
+    message: string;
+}> | Readonly<{
+    kind: "slot_unavailable";
+    message: string;
+}>;
+export type BookingFlowStatus = Readonly<{
+    tag: "ready";
+}> | Readonly<{
+    tag: "submitting";
+}> | Readonly<{
+    tag: "success";
+    resourceName: string | null;
+}> | Readonly<{
+    tag: "error";
+    message: string;
+}>;
+export type BookingFlowView = Readonly<{
+    kind: "missing";
+    message: string;
+}> | Readonly<{
+    kind: "form";
+}> | Readonly<{
+    kind: "success";
+    message: string;
+    resourceName: string | null;
+}> | Readonly<{
+    kind: "error";
+    message: string;
+}>;
+export type BookingFlowActionResult = Readonly<{
+    ok: true;
+}> | Readonly<{
+    ok: false;
+    reason: "validation-failed";
+    errors: BookingValidationErrors;
+}> | Readonly<{
+    ok: false;
+    reason: "blocked";
+    message: string;
+}> | Readonly<{
+    ok: false;
+    reason: "submission-failed";
+    message: string;
+}>;
+export type BookingSubmitOptions = Readonly<{
+    /**
+     * Checkout return URLs apply only to standard paid bookings. Appointment
+     * package submissions complete directly through the portal booking API and
+     * intentionally ignore these URLs.
+     */
+    redirect?: "manual" | "auto";
+    successUrl?: string;
+    cancelUrl?: string;
+}>;
+export type BookingSubmitActionResult = Readonly<{
+    ok: true;
+    outcome: {
+        kind: "booked";
+        appointmentId: string;
+        resourceName: string | null;
+    };
+}> | Readonly<{
+    ok: true;
+    outcome: {
+        kind: "checkout_redirect";
+        checkoutUrl: string;
+    };
+}> | Exclude<BookingFlowActionResult, Readonly<{
+    ok: true;
+}>>;
+export type BookingFieldView = Readonly<{
+    field: BookingFormField;
+    id: string;
+    label: string;
+    type: BookingFormField["type"];
+    value: BookingFieldValue;
+    required: boolean;
+    error: string | null;
+    helpText: string | null;
+    inputId: string;
+    labelId: string;
+    helpTextId: string | null;
+    errorId: string | null;
+    describedBy: string | undefined;
+    ariaInvalid: boolean;
+}>;
+export type BookingFlowReducerState = Readonly<{
+    currentStepId: BookingFlowStepId;
+    selectedServiceId?: string;
+    selectedResourceId?: string;
+    selectedDate?: string;
+    selectedSlot: BookingSlotView | null;
+    fieldValues: Readonly<Record<string, BookingFieldValue>>;
+    touchedFields: Readonly<Record<string, boolean>>;
+    discountCode: string;
+    selectedCollectionOptionKind?: BookingSelectedCollectionOptionKind;
+    selectedAppointmentPackageId?: string;
+    altchaSolution: string | null;
+    validationErrors: BookingValidationErrors;
+    feedback: BookingFlowFeedback;
+    isSubmitting: boolean;
+}>;
+export type BookingFlowEvent = Readonly<{
+    type: "service-selected";
+    serviceId: string;
+}> | Readonly<{
+    type: "resource-selected";
+    resourceId: string | null;
+}> | Readonly<{
+    type: "date-selected";
+    date: string | null;
+}> | Readonly<{
+    type: "slot-selected";
+    slot: BookingSlotView | null;
+}> | Readonly<{
+    type: "field-updated";
+    fieldId: string;
+    value: BookingFieldValue;
+}> | Readonly<{
+    type: "field-touched";
+    fieldId: string;
+}> | Readonly<{
+    type: "payment-option-selected";
+    kind: BookingSelectedCollectionOptionKind | null;
+}> | Readonly<{
+    type: "appointment-package-selected";
+    packageId: string | null;
+}> | Readonly<{
+    type: "discount-code-changed";
+    code: string;
+}> | Readonly<{
+    type: "altcha-solution-set";
+    solution: string | null;
+}> | Readonly<{
+    type: "altcha-solution-invalidated";
+}> | Readonly<{
+    type: "step-changed";
+    stepId: BookingFlowStepId;
+}> | Readonly<{
+    type: "validation-errors-set";
+    errors: BookingValidationErrors;
+}> | Readonly<{
+    type: "feedback-set";
+    feedback: BookingFlowFeedback;
+}> | Readonly<{
+    type: "availability-selection-invalidated";
+    invalidation: Exclude<AvailabilitySelectionInvalidation, {
+        kind: "preserve";
+    }>;
+}> | Readonly<{
+    type: "feedback-cleared";
+}> | Readonly<{
+    type: "submission-started";
+}> | Readonly<{
+    type: "submission-finished";
+}> | Readonly<{
+    type: "reset";
+    initial: BookingFlowReducerState;
+}>;
+export type BuildBookingStepPlanInput = Readonly<{
+    form: BookingFormConfig | null;
+    services: readonly BookingFormService[];
+    data: Partial<BookingFormData>;
+    defaultServiceId?: string;
+    defaultResourceId?: string;
+    requiresServiceSelection?: boolean;
+    requiresResourceSelection?: boolean;
+    enableAppointmentPackages?: boolean;
+}>;
+export type BookingStepPlanItem = Readonly<{
+    id: BookingFlowStepId;
+    label: string;
+    visible: boolean;
+}>;
+export type BookingStepValidationResult = Readonly<{
+    ok: true;
+}> | Readonly<{
+    ok: false;
+    errors: BookingValidationErrors;
+}>;
+export type DeriveBookingFlowStepsInput = Readonly<{
+    form: BookingFormConfig | null;
+    services: readonly BookingFormService[];
+    data: Partial<BookingFormData>;
+    defaultServiceId?: string;
+    defaultResourceId?: string;
+    currentStepId: BookingFlowStepId;
+    requiresServiceSelection?: boolean;
+    requiresResourceSelection?: boolean;
+    enableAppointmentPackages?: boolean;
+}>;
+export type DerivedBookingFlowSteps = Readonly<{
+    steps: readonly BookingFlowStep[];
+    currentStepIndex: number;
+    currentStep: BookingFlowStep | null;
+    stepIds: readonly BookingFlowStepId[];
+    validations: ReadonlyMap<BookingFlowStepId, BookingStepValidationResult>;
+}>;
+export type BookingAvailabilityQuery = Readonly<{
+    ok: true;
+    key: string;
+    serviceId: string;
+    resourceId?: string;
+    selectedDate?: string;
+    timezone: string;
+}> | Readonly<{
+    ok: false;
+    reason: "missing-service" | "missing-date";
+    key: string;
+}>;
+export type BookingSubmitRedirectMode = "manual" | "auto";
+export type BookingSubmitPlan = Readonly<{
+    ok: true;
+    redirect: BookingSubmitRedirectMode;
+    value: BookingSubmissionData;
+}> | Readonly<{
+    ok: false;
+    errors: BookingValidationErrors;
+    message: string;
+}>;
+export type BookingAppointmentPackagesModel = Readonly<{
+    kind: "disabled";
+    enabled: false;
+    canLoad: false;
+    unavailableReason: "disabled";
+    state: Readonly<{
+        tag: "idle";
+    }>;
+    items: readonly [];
+    selected: null;
+}> | Readonly<{
+    kind: "unavailable";
+    enabled: true;
+    canLoad: false;
+    unavailableReason: "missing-portal-auth" | "missing-priced-service";
+    state: Readonly<{
+        tag: "idle";
+    }>;
+    items: readonly [];
+    selected: null;
+}> | Readonly<{
+    kind: "idle";
+    enabled: true;
+    canLoad: true;
+    unavailableReason: null;
+    state: Readonly<{
+        tag: "idle";
+    }>;
+    items: readonly [];
+    selected: null;
+}> | Readonly<{
+    kind: "loading";
+    enabled: true;
+    canLoad: true;
+    unavailableReason: null;
+    state: Readonly<{
+        tag: "loading";
+    }>;
+    items: readonly [];
+    selected: null;
+}> | Readonly<{
+    kind: "error";
+    enabled: true;
+    canLoad: true;
+    unavailableReason: null;
+    state: Readonly<{
+        tag: "error";
+        message: string;
+    }>;
+    items: readonly [];
+    selected: null;
+}> | Readonly<{
+    kind: "ready";
+    enabled: true;
+    canLoad: true;
+    unavailableReason: null;
+    state: Readonly<{
+        tag: "loaded";
+        value: readonly EligibleAppointmentPackage[];
+    }>;
+    items: readonly EligibleAppointmentPackage[];
+    selected: EligibleAppointmentPackage | null;
+}>;
+export type BookingAppointmentPackagesUnavailableReason = "disabled" | "missing-portal-auth" | "missing-priced-service";
+export type AppointmentBookingOverrideData = Readonly<{
+    form?: BookingFormConfig | Record<string, unknown> | null;
+    services?: BookingFormServicesSource | Record<string, unknown> | null;
+}>;
+export type AppointmentBookingOverrideContent = Readonly<{
+    formId?: string;
+    serviceId?: string;
+    resourceId?: string;
+    requiresServiceSelection?: boolean;
+    requiresResourceSelection?: boolean;
+    shouldAutoSelectSingleResource?: boolean;
+    spamProtectionEnabled?: boolean;
+    successMessage?: string;
+}>;
+export type AppointmentBookingOverridePropsLike = Readonly<{
+    content?: AppointmentBookingOverrideContent | null;
+    data?: AppointmentBookingOverrideData | Record<string, unknown> | null;
+    siteId?: string;
+    apiBaseUrl?: string;
+    portalToken?: string | null;
+    blockId?: string | null;
+}>;
+export type AppointmentBookingOverrideInput = Readonly<{
+    siteId: string;
+    apiBaseUrl: string;
+    portalToken: string | null;
+    formId: string;
+    form: BookingFormConfig;
+    services: readonly BookingFormService[];
+    initialServiceId?: string;
+    initialResourceId?: string;
+    requiresServiceSelection: boolean;
+    requiresResourceSelection: boolean;
+    shouldAutoSelectSingleResource: boolean;
+    spamProtectionEnabled?: boolean;
+    successMessage?: string;
+    blockId?: string | null;
+}>;
+export type AppointmentBookingOverrideInputResult = Readonly<{
+    ok: true;
+    value: AppointmentBookingOverrideInput;
+}> | Readonly<{
+    ok: false;
+    reason: "missing-site-id" | "missing-api-base-url" | "missing-form" | "missing-form-id" | "missing-services";
+    message: string;
+}>;
+export declare function createEmptyBookingValidationErrors(): BookingValidationErrors;
+export declare function createFormBookingValidationError(formError: string): BookingValidationErrors;
+export declare function createFieldBookingValidationErrors(fieldErrors: Readonly<Record<string, string>>): BookingValidationErrors;
+export declare function hasBookingValidationErrors(errors: BookingValidationErrors): boolean;
+export declare function createInitialBookingFlowReducerState(input: Readonly<{
+    defaultServiceId?: string;
+    defaultResourceId?: string;
+    initialData?: Partial<BookingFormData>;
+}>): BookingFlowReducerState;
+export declare function bookingFlowReducer(state: BookingFlowReducerState, event: BookingFlowEvent): BookingFlowReducerState;
+export declare function resolveAvailabilitySelectionInvalidation(input: Readonly<{
+    selectedDate?: string;
+    selectedSlot: BookingSlotView | null;
+    availableDates: readonly string[];
+    slots: readonly BookingSlotView[];
+}>): AvailabilitySelectionInvalidation;
+export declare function toBookingSlotView(slot: TimeSlot): BookingSlotView;
+export declare function toBookingSlotViews(slots: readonly TimeSlot[]): BookingSlotView[];
+export declare function toBookingFormData(state: BookingFlowReducerState): BookingFormData;
+export declare function buildBookingStepPlan(input: BuildBookingStepPlanInput): readonly BookingStepPlanItem[];
+export declare function validateBookingStep(input: Readonly<{
+    stepId: BookingFlowStepId;
+    form: BookingFormConfig | null;
+    services: readonly BookingFormService[];
+    data: Partial<BookingFormData>;
+    defaultServiceId?: string;
+    defaultResourceId?: string;
+    requiresResourceSelection?: boolean;
+    paymentResolution?: BookingPaymentStepResolution;
+}>): BookingStepValidationResult;
+export declare function validateBookingFields(input: Readonly<{
+    fields: readonly BookingFormField[];
+    values: Readonly<Record<string, unknown>>;
+}>): Record<string, string>;
+export declare function validateBookingField(field: BookingFormField, value: unknown): string | null;
+export declare function deriveBookingFlowSteps(input: DeriveBookingFlowStepsInput): DerivedBookingFlowSteps;
+export declare function buildBookingAvailabilityQuery(input: Readonly<{
+    serviceId?: string;
+    resourceId?: string;
+    selectedDate?: string;
+    timezone: string;
+    requireDate?: boolean;
+}>): BookingAvailabilityQuery;
+export declare function deriveBookingFieldViews(input: Readonly<{
+    form: BookingFormConfig | null;
+    values: Readonly<Record<string, BookingFieldValue>>;
+    errors: Readonly<Record<string, string>>;
+    touched?: Readonly<Record<string, boolean>>;
+    idPrefix: string;
+}>): readonly BookingFieldView[];
+export declare function buildBookingSubmitPlan(input: Readonly<{
+    formId: string;
+    form: BookingFormConfig | null;
+    state: BookingFlowReducerState;
+    services: readonly BookingFormService[];
+    defaultServiceId?: string;
+    defaultResourceId?: string;
+    requiresResourceSelection?: boolean;
+    altchaSolution?: string | null;
+    viewerTimeZone: string;
+    redirect: BookingSubmitRedirectMode;
+    successUrl?: string;
+    cancelUrl?: string;
+}>): BookingSubmitPlan;
+export declare function getAppointmentBookingOverrideInput(props: AppointmentBookingOverridePropsLike): AppointmentBookingOverrideInputResult;
+export declare function createBookingBlockApiConfig(input: Readonly<{
+    siteId: string;
+    apiBaseUrl: string;
+    portalToken?: string | null;
+}>): BlockApiConfig;
+export declare function resolveHeadlessBookingSelectedService(input: Readonly<{
+    state: BookingFlowReducerState;
+    services: readonly BookingFormService[];
+    defaultServiceId?: string;
+}>): BookingFormService | null;
+export declare function resolveAppointmentPackagesModel(input: Readonly<{
+    enabled: boolean;
+    canLoad: boolean;
+    unavailableReason: BookingAppointmentPackagesUnavailableReason | null;
+    state: LoadState<readonly EligibleAppointmentPackage[]>;
+    items: readonly EligibleAppointmentPackage[];
+    selected: EligibleAppointmentPackage | null;
+}>): BookingAppointmentPackagesModel;
+export declare function resolveHeadlessBookingStatus(input: Readonly<{
+    feedback: BookingFlowFeedback;
+    isSubmitting: boolean;
+}>): BookingFlowStatus;
+export declare function resolveHeadlessBookingView(input: Readonly<{
+    form: BookingFormConfig | null;
+    feedback: BookingFlowFeedback;
+}>): BookingFlowView;
+export declare function describeUnknownError(error: unknown, fallback: string): string;

package/dist/_dts/blocks/src/system/runtime/nodes/booking-form.state.d.ts

@@ -50,6 +50,7 @@ export type BookingFormSourceRecord = Readonly<{
     createdAt: string;
     updatedAt: string;
 }>;
+export type BookingFormConfigSource = BookingFormConfig | BookingFormSourceRecord | Readonly<Record<string, unknown>>;
 type BlockBookingPaymentTermsAvailability = Readonly<{
     kind: "available";
     paymentTerms: BlockBookingPaymentTerms;
@@ -196,8 +197,10 @@ export declare function deriveBookingFormViewState(input: Readonly<{
     verificationState: AppointmentCheckoutVerificationState;
 }>): BookingFormViewState;
 export declare function resolveBookingSiteId(siteId: string | undefined, form: BookingFormSourceRecord | null | undefined): string;
-export declare function normalizeBookingFormConfig(form: BookingFormSourceRecord | null | undefined): BookingFormConfig | null;
-export declare function normalizeBookingServices(services: BookingFormServicesSource | null | undefined): readonly BookingFormService[];
+export declare function normalizeBookingFormConfig(form: unknown): BookingFormConfig | null;
+export declare function normalizeBookingServices(services: unknown): readonly BookingFormService[];
+export declare const BOOKING_FORM_DATA_RESERVED_KEYS: Set<string>;
+export declare function toSelectedCollectionOptionKind(value: unknown): BookingSelectedCollectionOptionKind | undefined;
 export declare function getBookingServicePaymentSelectionMode(service: BookingFormService | undefined): BookingPaymentSelectionMode;
 export declare function resolveDefaultBookingServiceId(formConfig: BookingFormConfig | null | undefined, services: readonly BookingFormService[]): string | null;
 export declare function resolveBookingSelectedService(input: Readonly<{

package/dist/_dts/blocks/src/system/transforms/registry/formatting.d.ts

@@ -7,6 +7,7 @@ export declare const fallbackTransform: TransformDefinition<{
 export declare const dateFormatShort: TransformDefinition;
 export declare const arrayLengthTransform: TransformDefinition;
 export declare const jsonArrayTransform: TransformDefinition;
+export declare const csvTransform: TransformDefinition;
 declare const marqueeLoopOptionsSchema: z.ZodObject<{
     minItems: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;