import type React from 'react';
import type { InteractiveBlockRuntime, RuntimeKind, RuntimeRender, RuntimeSource } from '../../../contracts/runtime';
import type { SystemBlockDefinition } from '../../registry';
type AnyInteractiveRuntime = InteractiveBlockRuntime<any, any, any>;
type RuntimeBackedBlockDefinition<TRuntime extends AnyInteractiveRuntime = AnyInteractiveRuntime> = SystemBlockDefinition<unknown, TRuntime> & Readonly<{
    manifest: Readonly<{
        name: string;
    }>;
    runtime: TRuntime;
}>;
export type RuntimeBackedClientComponentProps<TRuntime extends AnyInteractiveRuntime, TMode extends string> = Readonly<RuntimeSource<TRuntime> & {
    renderKind: RuntimeKind<TRuntime>;
    render: Readonly<{
        mode: TMode;
    } & RuntimeRender<TRuntime>>;
}>;
export type RuntimeBackedClientBlockEntry<TRuntime extends AnyInteractiveRuntime, TMode extends string = string> = Readonly<{
    definition: RuntimeBackedBlockDefinition<TRuntime>;
    renderKind: TRuntime['kind'];
    mode: TMode;
    client: React.ElementType;
}>;
export declare const runtimeBackedBlockServerEntries: {
    readonly form: Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "progressive";
            buildRender: (source: Readonly<{
                value?: import("../nodes/form.types").FormRecord;
                siteId?: string;
                apiBaseUrl?: string;
                submitLabel?: string;
                successMessage?: string | null;
                className?: string;
                spamProtectionEnabled?: boolean;
            }>) => Readonly<{
                display: Readonly<{
                    kind: "form";
                    state: "missing" | "ready";
                    className: string | null;
                    formId: string | null;
                    submitLabel: string;
                    successMessage: string | null;
                    form: import("../nodes/form.types").FormRecord | null;
                    groups: readonly import("../nodes/form-layout").FormFieldGroup[];
                }>;
                hydration: Readonly<{
                    spamProtectionEnabled?: boolean;
                }>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: Readonly<{
                        value?: import("../nodes/form.types").FormRecord;
                        siteId?: string;
                        apiBaseUrl?: string;
                        submitLabel?: string;
                        successMessage?: string | null;
                        className?: string;
                        spamProtectionEnabled?: boolean;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        value?: import("../nodes/form.types").FormRecord;
                        siteId?: string;
                        apiBaseUrl?: string;
                        submitLabel?: string;
                        successMessage?: string | null;
                        className?: string;
                        spamProtectionEnabled?: boolean;
                    }>>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "form";
                            state: "missing" | "ready";
                            className: string | null;
                            formId: string | null;
                            submitLabel: string;
                            successMessage: string | null;
                            form: import("../nodes/form.types").FormRecord | null;
                            groups: readonly import("../nodes/form-layout").FormFieldGroup[];
                        }>;
                        hydration: Readonly<{
                            spamProtectionEnabled?: boolean;
                        }>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "form";
                            state: "missing" | "ready";
                            className: string | null;
                            formId: string | null;
                            submitLabel: string;
                            successMessage: string | null;
                            form: import("../nodes/form.types").FormRecord | null;
                            groups: readonly import("../nodes/form-layout").FormFieldGroup[];
                        }>;
                        hydration: Readonly<{
                            spamProtectionEnabled?: boolean;
                        }>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "progressive";
        server: React.ElementType;
    }>;
    readonly 'event-listing': Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "progressive";
            buildRender: (source: Readonly<{
                events?: import("../..").PublicEvent[] | null;
                siteId: string;
                apiBaseUrl?: string;
                stage?: "preview" | "published";
                layout?: import("../..").EventLayout;
                columns?: import("../..").ColumnOption;
                eventsPerPage?: string;
                paginationMode?: "loadMore" | "seeAllLink";
                seeAllUrl?: string;
                loadMoreText?: string;
                cardVariant?: import("../..").CardVariant;
                buttonVariant?: import("../..").ButtonVariant;
                buttonText?: string;
                showVenue?: boolean;
                showMap?: boolean;
                showCapacity?: boolean;
                emptyMessage?: string;
                className?: string;
                showFilters?: boolean | null;
                showCategoryFilter?: import("../..").FilterAutoShow;
                showVenueFilter?: boolean | null;
                showStaffFilter?: boolean | null;
                eventKind?: import("../..").EventBlockKind | null;
                eventSurface?: import("../..").EventSurfaceScope | null;
                filterEventPresets?: readonly string[] | string | null;
                scheduleScope?: import("../..").EventScheduleScope | null;
                filterCategoryIds?: string | null;
                filterStaffMemberId?: string | null;
                filterVenueId?: string | null;
            }>) => Readonly<{
                display: Readonly<{
                    kind: "event-listing";
                    state: "loading" | "empty" | "ready";
                    listLayout: import("../..").EventLayout;
                    className: string | null;
                    emptyMessage: string;
                    loadingMessage: string;
                    containerClass: string;
                    cardVariant: import("../..").CardVariant;
                    buttonVariant: import("../..").ButtonVariant;
                    buttonText: string;
                    showVenue: boolean;
                    showMap: boolean;
                    showCapacity: boolean;
                    orientation: import("../..").CardOrientation;
                    events: readonly import("../..").PublicEvent[];
                }>;
                hydration: Readonly<{
                    siteId: string;
                    stage?: "preview" | "published";
                    eventsPerPage: string;
                    paginationMode: "loadMore" | "seeAllLink";
                    seeAllUrl?: string;
                    loadMoreText: string;
                    showFilters: boolean;
                    showCategoryFilter: import("../..").FilterAutoShow;
                    showVenueFilter: boolean;
                    showStaffFilter: boolean;
                    eventKind: import("../..").EventBlockKind;
                    eventSurface: import("../..").EventSurfaceScope;
                    filterEventPresets: string | null;
                    scheduleScope: import("../..").EventScheduleScope;
                    filterCategoryIds?: string | null;
                    filterStaffMemberId?: string | null;
                    filterVenueId?: string | null;
                    fetchInitialEventsOnMount: boolean;
                }>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: Readonly<{
                        events?: import("../..").PublicEvent[] | null;
                        siteId: string;
                        apiBaseUrl?: string;
                        stage?: "preview" | "published";
                        layout?: import("../..").EventLayout;
                        columns?: import("../..").ColumnOption;
                        eventsPerPage?: string;
                        paginationMode?: "loadMore" | "seeAllLink";
                        seeAllUrl?: string;
                        loadMoreText?: string;
                        cardVariant?: import("../..").CardVariant;
                        buttonVariant?: import("../..").ButtonVariant;
                        buttonText?: string;
                        showVenue?: boolean;
                        showMap?: boolean;
                        showCapacity?: boolean;
                        emptyMessage?: string;
                        className?: string;
                        showFilters?: boolean | null;
                        showCategoryFilter?: import("../..").FilterAutoShow;
                        showVenueFilter?: boolean | null;
                        showStaffFilter?: boolean | null;
                        eventKind?: import("../..").EventBlockKind | null;
                        eventSurface?: import("../..").EventSurfaceScope | null;
                        filterEventPresets?: readonly string[] | string | null;
                        scheduleScope?: import("../..").EventScheduleScope | null;
                        filterCategoryIds?: string | null;
                        filterStaffMemberId?: string | null;
                        filterVenueId?: string | null;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        events?: import("../..").PublicEvent[] | null;
                        siteId: string;
                        apiBaseUrl?: string;
                        stage?: "preview" | "published";
                        layout?: import("../..").EventLayout;
                        columns?: import("../..").ColumnOption;
                        eventsPerPage?: string;
                        paginationMode?: "loadMore" | "seeAllLink";
                        seeAllUrl?: string;
                        loadMoreText?: string;
                        cardVariant?: import("../..").CardVariant;
                        buttonVariant?: import("../..").ButtonVariant;
                        buttonText?: string;
                        showVenue?: boolean;
                        showMap?: boolean;
                        showCapacity?: boolean;
                        emptyMessage?: string;
                        className?: string;
                        showFilters?: boolean | null;
                        showCategoryFilter?: import("../..").FilterAutoShow;
                        showVenueFilter?: boolean | null;
                        showStaffFilter?: boolean | null;
                        eventKind?: import("../..").EventBlockKind | null;
                        eventSurface?: import("../..").EventSurfaceScope | null;
                        filterEventPresets?: readonly string[] | string | null;
                        scheduleScope?: import("../..").EventScheduleScope | null;
                        filterCategoryIds?: string | null;
                        filterStaffMemberId?: string | null;
                        filterVenueId?: string | null;
                    }>>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "event-listing";
                            state: "loading" | "empty" | "ready";
                            listLayout: import("../..").EventLayout;
                            className: string | null;
                            emptyMessage: string;
                            loadingMessage: string;
                            containerClass: string;
                            cardVariant: import("../..").CardVariant;
                            buttonVariant: import("../..").ButtonVariant;
                            buttonText: string;
                            showVenue: boolean;
                            showMap: boolean;
                            showCapacity: boolean;
                            orientation: import("../..").CardOrientation;
                            events: readonly import("../..").PublicEvent[];
                        }>;
                        hydration: Readonly<{
                            siteId: string;
                            stage?: "preview" | "published";
                            eventsPerPage: string;
                            paginationMode: "loadMore" | "seeAllLink";
                            seeAllUrl?: string;
                            loadMoreText: string;
                            showFilters: boolean;
                            showCategoryFilter: import("../..").FilterAutoShow;
                            showVenueFilter: boolean;
                            showStaffFilter: boolean;
                            eventKind: import("../..").EventBlockKind;
                            eventSurface: import("../..").EventSurfaceScope;
                            filterEventPresets: string | null;
                            scheduleScope: import("../..").EventScheduleScope;
                            filterCategoryIds?: string | null;
                            filterStaffMemberId?: string | null;
                            filterVenueId?: string | null;
                            fetchInitialEventsOnMount: boolean;
                        }>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "event-listing";
                            state: "loading" | "empty" | "ready";
                            listLayout: import("../..").EventLayout;
                            className: string | null;
                            emptyMessage: string;
                            loadingMessage: string;
                            containerClass: string;
                            cardVariant: import("../..").CardVariant;
                            buttonVariant: import("../..").ButtonVariant;
                            buttonText: string;
                            showVenue: boolean;
                            showMap: boolean;
                            showCapacity: boolean;
                            orientation: import("../..").CardOrientation;
                            events: readonly import("../..").PublicEvent[];
                        }>;
                        hydration: Readonly<{
                            siteId: string;
                            stage?: "preview" | "published";
                            eventsPerPage: string;
                            paginationMode: "loadMore" | "seeAllLink";
                            seeAllUrl?: string;
                            loadMoreText: string;
                            showFilters: boolean;
                            showCategoryFilter: import("../..").FilterAutoShow;
                            showVenueFilter: boolean;
                            showStaffFilter: boolean;
                            eventKind: import("../..").EventBlockKind;
                            eventSurface: import("../..").EventSurfaceScope;
                            filterEventPresets: string | null;
                            scheduleScope: import("../..").EventScheduleScope;
                            filterCategoryIds?: string | null;
                            filterStaffMemberId?: string | null;
                            filterVenueId?: string | null;
                            fetchInitialEventsOnMount: boolean;
                        }>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "progressive";
        server: React.ElementType;
    }>;
    readonly 'event-calendar': Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "progressive";
            buildRender: (source: Readonly<{
                events?: import("../..").PublicEvent[] | null;
                siteId: string;
                apiBaseUrl?: string;
                stage?: "preview" | "published";
                displayMode?: import("../..").DisplayMode | null;
                listLayout?: import("../..").EventLayout;
                listColumns?: import("../..").ColumnOption;
                layout?: import("../..").EventLayout;
                columns?: import("../..").ColumnOption;
                eventsPerPage?: string;
                compactEventsPerPage?: string;
                loadMoreText?: string;
                startOfWeek?: import("../..").WeekStart;
                calendarTabViews?: import("../..").CalendarTabViews;
                showFilters?: boolean | null;
                showCategoryFilter?: import("../..").FilterAutoShow;
                showVenueFilter?: boolean | null;
                showStaffFilter?: boolean | null;
                kind?: import("../..").EventBlockKind | null;
                eventSurface?: import("../..").EventSurfaceScope | null;
                filterEventPresets?: readonly string[] | string | null;
                scheduleScope?: import("../..").EventScheduleScope | null;
                filterCategoryIds?: readonly string[] | string | null;
                filterStaffMemberId?: string | null;
                filterVenueId?: string | null;
                buttonVariant?: import("../..").ButtonVariant;
                buttonText?: string;
                showVenue?: boolean | null;
                showMap?: boolean | null;
                showCapacity?: boolean | null;
                emptyMessage?: string;
                className?: string;
            }>) => Readonly<{
                display: Readonly<{
                    kind: "event-calendar";
                    displayMode: import("../..").DisplayMode;
                    className: string | null;
                    events: readonly import("../..").PublicEvent[];
                    listLayout: import("../..").EventLayout;
                    listColumns: import("../..").ColumnOption;
                    eventsPerPage: string;
                    loadMoreText: string;
                    startOfWeek: import("../..").WeekStart;
                    calendarTabViews: import("../..").CalendarTabViews;
                    showFilters: boolean;
                    showCategoryFilter: import("../..").FilterAutoShow;
                    showVenueFilter: boolean;
                    showStaffFilter: boolean;
                    eventKind: import("../..").EventBlockKind;
                    eventSurface: import("../..").EventSurfaceScope;
                    filterEventPresets: string | null;
                    scheduleScope: import("../..").EventScheduleScope;
                    filterCategoryIds: string | null;
                    filterStaffMemberId: string | null;
                    filterVenueId: string | null;
                    buttonVariant: import("../..").ButtonVariant;
                    buttonText: string;
                    showVenue: boolean;
                    showMap: boolean;
                    showCapacity: boolean;
                    emptyMessage: string;
                }>;
                hydration: Readonly<{
                    siteId: string;
                    stage?: "preview" | "published";
                    prefetchedEvents: boolean;
                    eventKind: import("../..").EventBlockKind;
                    eventSurface: import("../..").EventSurfaceScope;
                    filterEventPresets: string | null;
                    scheduleScope: import("../..").EventScheduleScope;
                }>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: Readonly<{
                        events?: import("../..").PublicEvent[] | null;
                        siteId: string;
                        apiBaseUrl?: string;
                        stage?: "preview" | "published";
                        displayMode?: import("../..").DisplayMode | null;
                        listLayout?: import("../..").EventLayout;
                        listColumns?: import("../..").ColumnOption;
                        layout?: import("../..").EventLayout;
                        columns?: import("../..").ColumnOption;
                        eventsPerPage?: string;
                        compactEventsPerPage?: string;
                        loadMoreText?: string;
                        startOfWeek?: import("../..").WeekStart;
                        calendarTabViews?: import("../..").CalendarTabViews;
                        showFilters?: boolean | null;
                        showCategoryFilter?: import("../..").FilterAutoShow;
                        showVenueFilter?: boolean | null;
                        showStaffFilter?: boolean | null;
                        kind?: import("../..").EventBlockKind | null;
                        eventSurface?: import("../..").EventSurfaceScope | null;
                        filterEventPresets?: readonly string[] | string | null;
                        scheduleScope?: import("../..").EventScheduleScope | null;
                        filterCategoryIds?: readonly string[] | string | null;
                        filterStaffMemberId?: string | null;
                        filterVenueId?: string | null;
                        buttonVariant?: import("../..").ButtonVariant;
                        buttonText?: string;
                        showVenue?: boolean | null;
                        showMap?: boolean | null;
                        showCapacity?: boolean | null;
                        emptyMessage?: string;
                        className?: string;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        events?: import("../..").PublicEvent[] | null;
                        siteId: string;
                        apiBaseUrl?: string;
                        stage?: "preview" | "published";
                        displayMode?: import("../..").DisplayMode | null;
                        listLayout?: import("../..").EventLayout;
                        listColumns?: import("../..").ColumnOption;
                        layout?: import("../..").EventLayout;
                        columns?: import("../..").ColumnOption;
                        eventsPerPage?: string;
                        compactEventsPerPage?: string;
                        loadMoreText?: string;
                        startOfWeek?: import("../..").WeekStart;
                        calendarTabViews?: import("../..").CalendarTabViews;
                        showFilters?: boolean | null;
                        showCategoryFilter?: import("../..").FilterAutoShow;
                        showVenueFilter?: boolean | null;
                        showStaffFilter?: boolean | null;
                        kind?: import("../..").EventBlockKind | null;
                        eventSurface?: import("../..").EventSurfaceScope | null;
                        filterEventPresets?: readonly string[] | string | null;
                        scheduleScope?: import("../..").EventScheduleScope | null;
                        filterCategoryIds?: readonly string[] | string | null;
                        filterStaffMemberId?: string | null;
                        filterVenueId?: string | null;
                        buttonVariant?: import("../..").ButtonVariant;
                        buttonText?: string;
                        showVenue?: boolean | null;
                        showMap?: boolean | null;
                        showCapacity?: boolean | null;
                        emptyMessage?: string;
                        className?: string;
                    }>>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "event-calendar";
                            displayMode: import("../..").DisplayMode;
                            className: string | null;
                            events: readonly import("../..").PublicEvent[];
                            listLayout: import("../..").EventLayout;
                            listColumns: import("../..").ColumnOption;
                            eventsPerPage: string;
                            loadMoreText: string;
                            startOfWeek: import("../..").WeekStart;
                            calendarTabViews: import("../..").CalendarTabViews;
                            showFilters: boolean;
                            showCategoryFilter: import("../..").FilterAutoShow;
                            showVenueFilter: boolean;
                            showStaffFilter: boolean;
                            eventKind: import("../..").EventBlockKind;
                            eventSurface: import("../..").EventSurfaceScope;
                            filterEventPresets: string | null;
                            scheduleScope: import("../..").EventScheduleScope;
                            filterCategoryIds: string | null;
                            filterStaffMemberId: string | null;
                            filterVenueId: string | null;
                            buttonVariant: import("../..").ButtonVariant;
                            buttonText: string;
                            showVenue: boolean;
                            showMap: boolean;
                            showCapacity: boolean;
                            emptyMessage: string;
                        }>;
                        hydration: Readonly<{
                            siteId: string;
                            stage?: "preview" | "published";
                            prefetchedEvents: boolean;
                            eventKind: import("../..").EventBlockKind;
                            eventSurface: import("../..").EventSurfaceScope;
                            filterEventPresets: string | null;
                            scheduleScope: import("../..").EventScheduleScope;
                        }>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "event-calendar";
                            displayMode: import("../..").DisplayMode;
                            className: string | null;
                            events: readonly import("../..").PublicEvent[];
                            listLayout: import("../..").EventLayout;
                            listColumns: import("../..").ColumnOption;
                            eventsPerPage: string;
                            loadMoreText: string;
                            startOfWeek: import("../..").WeekStart;
                            calendarTabViews: import("../..").CalendarTabViews;
                            showFilters: boolean;
                            showCategoryFilter: import("../..").FilterAutoShow;
                            showVenueFilter: boolean;
                            showStaffFilter: boolean;
                            eventKind: import("../..").EventBlockKind;
                            eventSurface: import("../..").EventSurfaceScope;
                            filterEventPresets: string | null;
                            scheduleScope: import("../..").EventScheduleScope;
                            filterCategoryIds: string | null;
                            filterStaffMemberId: string | null;
                            filterVenueId: string | null;
                            buttonVariant: import("../..").ButtonVariant;
                            buttonText: string;
                            showVenue: boolean;
                            showMap: boolean;
                            showCapacity: boolean;
                            emptyMessage: string;
                        }>;
                        hydration: Readonly<{
                            siteId: string;
                            stage?: "preview" | "published";
                            prefetchedEvents: boolean;
                            eventKind: import("../..").EventBlockKind;
                            eventSurface: import("../..").EventSurfaceScope;
                            filterEventPresets: string | null;
                            scheduleScope: import("../..").EventScheduleScope;
                        }>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "progressive";
        server: React.ElementType;
    }>;
    readonly 'newsletter-form': Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "progressive";
            buildRender: (source: Readonly<{
                siteId?: string;
                apiBaseUrl?: string;
                listId?: string | null;
                preset?: import("../nodes/newsletter-form.types").NewsletterPreset;
                includePhone?: boolean;
                buttonLabel?: string | null;
                successMessage?: string | null;
                privacyNote?: string | null;
                tags?: string | null;
                spamProtectionEnabled?: boolean;
                className?: string | null;
            }>) => Readonly<{
                display: Readonly<{
                    kind: "newsletter-form";
                    className: string | null;
                    buttonLabel: string;
                    successMessage: string | null;
                    privacyNote: string | null;
                    fields: readonly import("../nodes/newsletter-form.types").NewsletterFieldDef[];
                }>;
                hydration: Readonly<{
                    listId?: string | null;
                    preset: import("../nodes/newsletter-form.types").NewsletterPreset;
                    includePhone: boolean;
                    tags?: string | null;
                    spamProtectionEnabled?: boolean;
                }>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: Readonly<{
                        siteId?: string;
                        apiBaseUrl?: string;
                        listId?: string | null;
                        preset?: import("../nodes/newsletter-form.types").NewsletterPreset;
                        includePhone?: boolean;
                        buttonLabel?: string | null;
                        successMessage?: string | null;
                        privacyNote?: string | null;
                        tags?: string | null;
                        spamProtectionEnabled?: boolean;
                        className?: string | null;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        siteId?: string;
                        apiBaseUrl?: string;
                        listId?: string | null;
                        preset?: import("../nodes/newsletter-form.types").NewsletterPreset;
                        includePhone?: boolean;
                        buttonLabel?: string | null;
                        successMessage?: string | null;
                        privacyNote?: string | null;
                        tags?: string | null;
                        spamProtectionEnabled?: boolean;
                        className?: string | null;
                    }>>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "newsletter-form";
                            className: string | null;
                            buttonLabel: string;
                            successMessage: string | null;
                            privacyNote: string | null;
                            fields: readonly import("../nodes/newsletter-form.types").NewsletterFieldDef[];
                        }>;
                        hydration: Readonly<{
                            listId?: string | null;
                            preset: import("../nodes/newsletter-form.types").NewsletterPreset;
                            includePhone: boolean;
                            tags?: string | null;
                            spamProtectionEnabled?: boolean;
                        }>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "newsletter-form";
                            className: string | null;
                            buttonLabel: string;
                            successMessage: string | null;
                            privacyNote: string | null;
                            fields: readonly import("../nodes/newsletter-form.types").NewsletterFieldDef[];
                        }>;
                        hydration: Readonly<{
                            listId?: string | null;
                            preset: import("../nodes/newsletter-form.types").NewsletterPreset;
                            includePhone: boolean;
                            tags?: string | null;
                            spamProtectionEnabled?: boolean;
                        }>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "progressive";
        server: React.ElementType;
    }>;
    readonly 'product-list': Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "progressive";
            buildRender: (source: import("../nodes/shop.interactive").ShopSourceProps) => Readonly<{
                display: Readonly<{
                    kind: "product-list";
                    state: "empty" | "ready";
                    heading: string | null;
                    className: string | null;
                    layout: "grid" | "list";
                    columns: string;
                    emptyMessage: string;
                    cards: readonly Readonly<{
                        productId: string;
                        title: string;
                        path: string | null;
                        summary: string | null;
                        priceLabel: string | null;
                        badges: readonly string[];
                        image: Readonly<{
                            url: string;
                            alt: string | null;
                        }> | null;
                        variantOptions: readonly Readonly<{
                            id: string;
                            label: string;
                            soldOut: boolean;
                        }>[];
                        selectedVariantId: string | null;
                        selectionLabel: string;
                        actionLabel: string;
                        soldOut: boolean;
                    }>[];
                }>;
                hydration: Readonly<{
                    products: readonly import("../../blocks/products/shared").PublicProduct[];
                    showSummary: boolean;
                    showBadges: boolean;
                    showPrices: boolean;
                    addButtonText: string;
                }>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: import("../nodes/shop.interactive").ShopSourceProps) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<import("../nodes/shop.interactive").ShopSourceProps>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "product-list";
                            state: "empty" | "ready";
                            heading: string | null;
                            className: string | null;
                            layout: "grid" | "list";
                            columns: string;
                            emptyMessage: string;
                            cards: readonly Readonly<{
                                productId: string;
                                title: string;
                                path: string | null;
                                summary: string | null;
                                priceLabel: string | null;
                                badges: readonly string[];
                                image: Readonly<{
                                    url: string;
                                    alt: string | null;
                                }> | null;
                                variantOptions: readonly Readonly<{
                                    id: string;
                                    label: string;
                                    soldOut: boolean;
                                }>[];
                                selectedVariantId: string | null;
                                selectionLabel: string;
                                actionLabel: string;
                                soldOut: boolean;
                            }>[];
                        }>;
                        hydration: Readonly<{
                            products: readonly import("../../blocks/products/shared").PublicProduct[];
                            showSummary: boolean;
                            showBadges: boolean;
                            showPrices: boolean;
                            addButtonText: string;
                        }>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "product-list";
                            state: "empty" | "ready";
                            heading: string | null;
                            className: string | null;
                            layout: "grid" | "list";
                            columns: string;
                            emptyMessage: string;
                            cards: readonly Readonly<{
                                productId: string;
                                title: string;
                                path: string | null;
                                summary: string | null;
                                priceLabel: string | null;
                                badges: readonly string[];
                                image: Readonly<{
                                    url: string;
                                    alt: string | null;
                                }> | null;
                                variantOptions: readonly Readonly<{
                                    id: string;
                                    label: string;
                                    soldOut: boolean;
                                }>[];
                                selectedVariantId: string | null;
                                selectionLabel: string;
                                actionLabel: string;
                                soldOut: boolean;
                            }>[];
                        }>;
                        hydration: Readonly<{
                            products: readonly import("../../blocks/products/shared").PublicProduct[];
                            showSummary: boolean;
                            showBadges: boolean;
                            showPrices: boolean;
                            addButtonText: string;
                        }>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "progressive";
        server: React.ElementType;
    }>;
    readonly 'product-detail': Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "progressive";
            buildRender: (source: import("../nodes/shop.interactive").ShopSourceProps) => Readonly<{
                display: import("../../../contracts").ProductDetailDisplay;
                hydration: Readonly<{
                    products: readonly import("../../blocks/products/shared").PublicProduct[];
                    productId: string | null;
                    showSummary: boolean;
                    showBadges: boolean;
                    showBody: boolean;
                    addButtonText: string;
                }>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: import("../nodes/shop.interactive").ShopSourceProps) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<import("../nodes/shop.interactive").ShopSourceProps>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: import("../../../contracts").ProductDetailDisplay;
                        hydration: Readonly<{
                            products: readonly import("../../blocks/products/shared").PublicProduct[];
                            productId: string | null;
                            showSummary: boolean;
                            showBadges: boolean;
                            showBody: boolean;
                            addButtonText: string;
                        }>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: import("../../../contracts").ProductDetailDisplay;
                        hydration: Readonly<{
                            products: readonly import("../../blocks/products/shared").PublicProduct[];
                            productId: string | null;
                            showSummary: boolean;
                            showBadges: boolean;
                            showBody: boolean;
                            addButtonText: string;
                        }>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "progressive";
        server: React.ElementType;
    }>;
    readonly cart: Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "client-owned";
            buildRender: (source: import("../nodes/shop.interactive").ShopSourceProps) => Readonly<{
                display: Readonly<{
                    kind: "cart";
                    state: "empty" | "ready";
                    heading: string | null;
                    className: string | null;
                    emptyMessage: string;
                    supportText: string | null;
                    items: readonly Readonly<{
                        key: string;
                        title: string;
                        priceLabel: string;
                        quantity: number;
                        quantityEditable: boolean;
                    }>[];
                    subtotalLabel: string | null;
                    checkoutButtonText: string;
                    clearButtonText: string;
                }>;
                hydration: Readonly<{
                    emptyStateText: string;
                    checkoutButtonText: string;
                    clearButtonText: string;
                }>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: import("../nodes/shop.interactive").ShopSourceProps) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<import("../nodes/shop.interactive").ShopSourceProps>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "cart";
                            state: "empty" | "ready";
                            heading: string | null;
                            className: string | null;
                            emptyMessage: string;
                            supportText: string | null;
                            items: readonly Readonly<{
                                key: string;
                                title: string;
                                priceLabel: string;
                                quantity: number;
                                quantityEditable: boolean;
                            }>[];
                            subtotalLabel: string | null;
                            checkoutButtonText: string;
                            clearButtonText: string;
                        }>;
                        hydration: Readonly<{
                            emptyStateText: string;
                            checkoutButtonText: string;
                            clearButtonText: string;
                        }>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "cart";
                            state: "empty" | "ready";
                            heading: string | null;
                            className: string | null;
                            emptyMessage: string;
                            supportText: string | null;
                            items: readonly Readonly<{
                                key: string;
                                title: string;
                                priceLabel: string;
                                quantity: number;
                                quantityEditable: boolean;
                            }>[];
                            subtotalLabel: string | null;
                            checkoutButtonText: string;
                            clearButtonText: string;
                        }>;
                        hydration: Readonly<{
                            emptyStateText: string;
                            checkoutButtonText: string;
                            clearButtonText: string;
                        }>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "client-owned";
        server: React.ElementType;
    }>;
    readonly checkout: Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "client-owned";
            buildRender: (source: import("../nodes/shop.interactive").ShopSourceProps) => Readonly<{
                display: Readonly<{
                    kind: "checkout";
                    state: "empty" | "blocked" | "ready";
                    heading: string | null;
                    className: string | null;
                    message: string | null;
                    submitButtonText: string;
                }>;
                hydration: Readonly<{
                    emptyStateText: string;
                    submitButtonText: string;
                }>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: import("../nodes/shop.interactive").ShopSourceProps) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<import("../nodes/shop.interactive").ShopSourceProps>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "checkout";
                            state: "empty" | "blocked" | "ready";
                            heading: string | null;
                            className: string | null;
                            message: string | null;
                            submitButtonText: string;
                        }>;
                        hydration: Readonly<{
                            emptyStateText: string;
                            submitButtonText: string;
                        }>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "checkout";
                            state: "empty" | "blocked" | "ready";
                            heading: string | null;
                            className: string | null;
                            message: string | null;
                            submitButtonText: string;
                        }>;
                        hydration: Readonly<{
                            emptyStateText: string;
                            submitButtonText: string;
                        }>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "client-owned";
        server: React.ElementType;
    }>;
    readonly 'course-registration': Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "client-owned";
            buildRender: (source: Readonly<{
                siteId?: string;
                apiBaseUrl?: string;
                portalToken?: string | null;
                contentEntry?: Readonly<{
                    id: string;
                    slug: string;
                    contentTypeSlug: string;
                }> | null;
                entrySubrouteContext?: import("../nodes/course-registration.interactive").CourseEntrySubrouteContext | null;
                courses?: import("../..").PublicCourse[] | null;
                className?: string | null;
                showSessions?: boolean;
                showPrice?: boolean;
                showCapacity?: boolean;
                showVenue?: boolean;
                successMessage?: string;
                waitlistMessage?: string;
                membershipMessage?: string;
                buttonText?: string | null;
                buttonVariant?: "primary" | "secondary" | "outline";
                stage?: "preview" | "published";
            }>) => Readonly<{
                display: Readonly<{
                    kind: "course-registration";
                    state: "shell";
                    className: string | null;
                    summaryButtonText: string;
                }>;
                hydration: Readonly<Omit<import("../nodes/course-registration").CourseRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: Readonly<{
                        siteId?: string;
                        apiBaseUrl?: string;
                        portalToken?: string | null;
                        contentEntry?: Readonly<{
                            id: string;
                            slug: string;
                            contentTypeSlug: string;
                        }> | null;
                        entrySubrouteContext?: import("../nodes/course-registration.interactive").CourseEntrySubrouteContext | null;
                        courses?: import("../..").PublicCourse[] | null;
                        className?: string | null;
                        showSessions?: boolean;
                        showPrice?: boolean;
                        showCapacity?: boolean;
                        showVenue?: boolean;
                        successMessage?: string;
                        waitlistMessage?: string;
                        membershipMessage?: string;
                        buttonText?: string | null;
                        buttonVariant?: "primary" | "secondary" | "outline";
                        stage?: "preview" | "published";
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        siteId?: string;
                        apiBaseUrl?: string;
                        portalToken?: string | null;
                        contentEntry?: Readonly<{
                            id: string;
                            slug: string;
                            contentTypeSlug: string;
                        }> | null;
                        entrySubrouteContext?: import("../nodes/course-registration.interactive").CourseEntrySubrouteContext | null;
                        courses?: import("../..").PublicCourse[] | null;
                        className?: string | null;
                        showSessions?: boolean;
                        showPrice?: boolean;
                        showCapacity?: boolean;
                        showVenue?: boolean;
                        successMessage?: string;
                        waitlistMessage?: string;
                        membershipMessage?: string;
                        buttonText?: string | null;
                        buttonVariant?: "primary" | "secondary" | "outline";
                        stage?: "preview" | "published";
                    }>>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "course-registration";
                            state: "shell";
                            className: string | null;
                            summaryButtonText: string;
                        }>;
                        hydration: Readonly<Omit<import("../nodes/course-registration").CourseRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "course-registration";
                            state: "shell";
                            className: string | null;
                            summaryButtonText: string;
                        }>;
                        hydration: Readonly<Omit<import("../nodes/course-registration").CourseRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "client-owned";
        server: React.ElementType;
    }>;
    readonly gifting: Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "client-owned";
            buildRender: (source: import("../nodes/gifting.interactive").GiftingSourceProps) => Readonly<{
                display: Readonly<{
                    kind: "gifting";
                    state: "ready";
                    className: string | null;
                    heading: string;
                    intro: string | null;
                    giftCardsHeading: string;
                    vouchersHeading: string;
                    emptyStateText: string;
                }>;
                hydration: Readonly<{
                    offers: import("../nodes/gifting.interactive").PublicGiftingOffersResponse | null;
                    checkoutButtonText: string;
                    successMessage: string;
                }>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: import("../nodes/gifting.interactive").GiftingSourceProps) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<import("../nodes/gifting.interactive").GiftingSourceProps>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "gifting";
                            state: "ready";
                            className: string | null;
                            heading: string;
                            intro: string | null;
                            giftCardsHeading: string;
                            vouchersHeading: string;
                            emptyStateText: string;
                        }>;
                        hydration: Readonly<{
                            offers: import("../nodes/gifting.interactive").PublicGiftingOffersResponse | null;
                            checkoutButtonText: string;
                            successMessage: string;
                        }>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "gifting";
                            state: "ready";
                            className: string | null;
                            heading: string;
                            intro: string | null;
                            giftCardsHeading: string;
                            vouchersHeading: string;
                            emptyStateText: string;
                        }>;
                        hydration: Readonly<{
                            offers: import("../nodes/gifting.interactive").PublicGiftingOffersResponse | null;
                            checkoutButtonText: string;
                            successMessage: string;
                        }>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "client-owned";
        server: React.ElementType;
    }>;
    readonly 'event-registration': Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "client-owned";
            buildRender: (source: Readonly<{
                siteId?: string;
                apiBaseUrl?: string;
                portalToken?: string | null;
                occurrenceContext?: import("../..").OccurrenceContext | null;
                contentEntry?: Readonly<{
                    id: string;
                    slug: string;
                    contentTypeSlug: string;
                }> | null;
                events?: import("../..").PublicEvent[] | null;
                className?: string | null;
                buttonText?: string | null;
                maxTickets?: string | null;
                showVenue?: boolean;
                showCapacity?: boolean;
                successMessage?: string;
                waitlistMessage?: string;
                buttonVariant?: "primary" | "secondary" | "outline";
                spamProtectionEnabled?: boolean;
                stage?: "preview" | "published";
                supportEmail?: string;
            }>) => Readonly<{
                display: Readonly<{
                    kind: "event-registration";
                    state: "shell";
                    className: string | null;
                    summaryButtonText: string;
                }>;
                hydration: Readonly<Omit<import("../nodes/event-registration").EventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText" | "registrationEndpoint" | "eligibilityEndpoint" | "checkoutEndpoint">>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: Readonly<{
                        siteId?: string;
                        apiBaseUrl?: string;
                        portalToken?: string | null;
                        occurrenceContext?: import("../..").OccurrenceContext | null;
                        contentEntry?: Readonly<{
                            id: string;
                            slug: string;
                            contentTypeSlug: string;
                        }> | null;
                        events?: import("../..").PublicEvent[] | null;
                        className?: string | null;
                        buttonText?: string | null;
                        maxTickets?: string | null;
                        showVenue?: boolean;
                        showCapacity?: boolean;
                        successMessage?: string;
                        waitlistMessage?: string;
                        buttonVariant?: "primary" | "secondary" | "outline";
                        spamProtectionEnabled?: boolean;
                        stage?: "preview" | "published";
                        supportEmail?: string;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        siteId?: string;
                        apiBaseUrl?: string;
                        portalToken?: string | null;
                        occurrenceContext?: import("../..").OccurrenceContext | null;
                        contentEntry?: Readonly<{
                            id: string;
                            slug: string;
                            contentTypeSlug: string;
                        }> | null;
                        events?: import("../..").PublicEvent[] | null;
                        className?: string | null;
                        buttonText?: string | null;
                        maxTickets?: string | null;
                        showVenue?: boolean;
                        showCapacity?: boolean;
                        successMessage?: string;
                        waitlistMessage?: string;
                        buttonVariant?: "primary" | "secondary" | "outline";
                        spamProtectionEnabled?: boolean;
                        stage?: "preview" | "published";
                        supportEmail?: string;
                    }>>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "event-registration";
                            state: "shell";
                            className: string | null;
                            summaryButtonText: string;
                        }>;
                        hydration: Readonly<Omit<import("../nodes/event-registration").EventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText" | "registrationEndpoint" | "eligibilityEndpoint" | "checkoutEndpoint">>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "event-registration";
                            state: "shell";
                            className: string | null;
                            summaryButtonText: string;
                        }>;
                        hydration: Readonly<Omit<import("../nodes/event-registration").EventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText" | "registrationEndpoint" | "eligibilityEndpoint" | "checkoutEndpoint">>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "client-owned";
        server: React.ElementType;
    }>;
    readonly shop: Readonly<{
        definition: RuntimeBackedBlockDefinition<Readonly<{
            kind: "progressive";
            buildRender: (source: import("../nodes/shop.interactive").ShopSourceProps) => Readonly<{
                display: Readonly<{
                    kind: "passes-memberships";
                    state: "empty" | "ready";
                    className: string | null;
                    layout: "grid" | "list";
                    columns: string;
                    emptyMessage: string;
                    passesHeading: string;
                    membershipsHeading: string;
                    passes: readonly Readonly<{
                        id: string;
                        title: string;
                        description: string | null;
                        priceLabel: string;
                        creditsLabel: string;
                        perCreditLabel: string | null;
                        validityLabel: string | null;
                        actionLabel: string;
                    }>[];
                    memberships: readonly Readonly<{
                        id: string;
                        title: string;
                        description: string | null;
                        priceLabel: string;
                        intervalLabel: string;
                        actionLabel: string;
                    }>[];
                }>;
                hydration: Readonly<{
                    passes: readonly import("../..").PublicPassProduct[];
                    memberships: readonly import("../..").PublicMembershipProduct[];
                    passPurchaseMode: "add_to_cart" | "buy_now";
                }>;
            }>;
            contracts: Readonly<{
                source: Readonly<{
                    encode: (value: import("../nodes/shop.interactive").ShopSourceProps) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<import("../nodes/shop.interactive").ShopSourceProps>;
                }>;
                render: Readonly<{
                    encode: (value: Readonly<{
                        display: Readonly<{
                            kind: "passes-memberships";
                            state: "empty" | "ready";
                            className: string | null;
                            layout: "grid" | "list";
                            columns: string;
                            emptyMessage: string;
                            passesHeading: string;
                            membershipsHeading: string;
                            passes: readonly Readonly<{
                                id: string;
                                title: string;
                                description: string | null;
                                priceLabel: string;
                                creditsLabel: string;
                                perCreditLabel: string | null;
                                validityLabel: string | null;
                                actionLabel: string;
                            }>[];
                            memberships: readonly Readonly<{
                                id: string;
                                title: string;
                                description: string | null;
                                priceLabel: string;
                                intervalLabel: string;
                                actionLabel: string;
                            }>[];
                        }>;
                        hydration: Readonly<{
                            passes: readonly import("../..").PublicPassProduct[];
                            memberships: readonly import("../..").PublicMembershipProduct[];
                            passPurchaseMode: "add_to_cart" | "buy_now";
                        }>;
                    }>) => unknown;
                    decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                        display: Readonly<{
                            kind: "passes-memberships";
                            state: "empty" | "ready";
                            className: string | null;
                            layout: "grid" | "list";
                            columns: string;
                            emptyMessage: string;
                            passesHeading: string;
                            membershipsHeading: string;
                            passes: readonly Readonly<{
                                id: string;
                                title: string;
                                description: string | null;
                                priceLabel: string;
                                creditsLabel: string;
                                perCreditLabel: string | null;
                                validityLabel: string | null;
                                actionLabel: string;
                            }>[];
                            memberships: readonly Readonly<{
                                id: string;
                                title: string;
                                description: string | null;
                                priceLabel: string;
                                intervalLabel: string;
                                actionLabel: string;
                            }>[];
                        }>;
                        hydration: Readonly<{
                            passes: readonly import("../..").PublicPassProduct[];
                            memberships: readonly import("../..").PublicMembershipProduct[];
                            passPurchaseMode: "add_to_cart" | "buy_now";
                        }>;
                    }>>;
                }>;
            }>;
        }>>;
        renderKind: "progressive";
        server: React.ElementType;
    }>;
};
export type RuntimeBackedBlockKind = keyof typeof runtimeBackedBlockServerEntries;
export declare const runtimeBackedBlockModes: {
    readonly form: "form";
    readonly 'event-listing': "event-listing";
    readonly 'event-calendar': "event-calendar";
    readonly 'newsletter-form': "newsletter-form";
    readonly 'product-list': "product-list";
    readonly 'product-detail': "product-detail";
    readonly cart: "cart";
    readonly checkout: "checkout";
    readonly 'course-registration': "course-registration";
    readonly gifting: "gifting";
    readonly 'event-registration': "event-registration";
    readonly shop: "passes-memberships";
};
export type RuntimeBackedBlockMode<TKind extends RuntimeBackedBlockKind> = typeof runtimeBackedBlockModes[TKind];
export declare const runtimeBackedBlockKinds: readonly ("cart" | "event-registration" | "form" | "event-listing" | "event-calendar" | "shop" | "product-list" | "product-detail" | "checkout" | "gifting" | "course-registration" | "newsletter-form")[];
export declare const runtimeBackedBlockServerRegistry: Readonly<{
    readonly form: React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly 'event-listing': React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly 'event-calendar': React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly 'newsletter-form': React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly 'product-list': React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly 'product-detail': React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly cart: React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly checkout: React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly 'course-registration': React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly gifting: React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly 'event-registration': React.ElementType<any, keyof React.JSX.IntrinsicElements>;
    readonly shop: React.ElementType<any, keyof React.JSX.IntrinsicElements>;
}>;
export {};
