@contentful/experiences-core 3.8.3-dev-20251010T1235-2d92513.0 → 3.8.3-dev-20251020T1356-dca4ced.0

package/dist/types/index.d.ts

@@ -0,0 +1,1675 @@
+import { ExperienceUnboundValues, ComponentDefinitionPropertyType, BindingSourceTypeEnum, ComponentPropertyValue, ExperienceDataSource, Breakpoint, Parameter, ExperienceComponentTree, ExperienceUsedComponents, ExperienceComponentSettings, ValuesByBreakpoint, PrimitiveValue, DesignValue, BoundValue, ComponentTreeNode, ParameterDefinition, VariableMapping } from '@contentful/experiences-validators';
+export { BoundValue, Breakpoint, ComponentDefinitionPropertyType as ComponentDefinitionVariableType, ComponentPropertyValue, ComponentTreeNode, ComponentValue, DesignValue, ExperienceComponentSettings, ExperienceDataSource, ExperienceUnboundValues, NoValue, Parameter, ParameterDefinition, PrimitiveValue, SchemaVersions, UnboundValue, ValuesByBreakpoint, VariableMapping } from '@contentful/experiences-validators';
+import * as contentful from 'contentful';
+import { UnresolvedLink, Asset, Entry, ChainModifiers, AssetFile, ContentfulClientApi } from 'contentful';
+import { Document } from '@contentful/rich-text-types';
+import * as react from 'react';
+import { Entry as Entry$1, Asset as Asset$1 } from 'contentful/dist/types/types';
+import * as zustand from 'zustand';
+
+declare const structureComponentIds: Set<"contentful-section" | "contentful-container" | "contentful-columns" | "contentful-single-column">;
+type ComponentAllowOnRoot = {
+    type?: string;
+    category?: string;
+    componentId?: string;
+};
+declare const allContentfulComponentIds: Set<"contentful-section" | "contentful-container" | "contentful-columns" | "contentful-single-column" | "contentful-button" | "contentful-heading" | "contentful-image" | "contentful-richText" | "contentful-text" | "contentful-divider" | "contentful-carousel">;
+type SetElement<ElementType> = ElementType extends Set<infer E> ? E : never;
+type StructureComponentId = SetElement<typeof structureComponentIds>;
+type AllContentfulComponentId = SetElement<typeof allContentfulComponentIds>;
+declare const isPatternComponent: (type?: string) => boolean;
+declare const isContentfulStructureComponent: (componentId?: string) => componentId is StructureComponentId;
+declare const isContentfulComponent: (componentId?: string) => componentId is AllContentfulComponentId;
+declare const isComponentAllowedOnRoot: ({ type, category, componentId }: ComponentAllowOnRoot) => boolean;
+declare const isStructureWithRelativeHeight: (componentId?: string, height?: string | number) => componentId is StructureComponentId;
+
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+declare const SCROLL_STATES: {
+    readonly Start: "scrollStart";
+    readonly IsScrolling: "isScrolling";
+    readonly End: "scrollEnd";
+};
+declare const OUTGOING_EVENTS: {
+    readonly Connected: "connected";
+    readonly DesignTokens: "registerDesignTokens";
+    readonly RegisteredBreakpoints: "registeredBreakpoints";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly MouseMove: "mouseMove";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly ComponentSelected: "componentSelected";
+    readonly RegisteredComponents: "registeredComponents";
+    readonly RequestComponentTreeUpdate: "requestComponentTreeUpdate";
+    readonly CanvasReload: "canvasReload";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly UpdateSelectedComponentCoordinates: "updateSelectedComponentCoordinates";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly CanvasScroll: "canvasScrolling";
+    readonly CanvasError: "canvasError";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly OutsideCanvasClick: "outsideCanvasClick";
+    readonly SDKFeatures: "sdkFeatures";
+    readonly RequestEntities: "REQUEST_ENTITIES";
+    readonly CanvasGeometryUpdated: "canvasGeometryUpdated";
+    readonly CanvasPan: "canvasPan";
+};
+declare const INCOMING_EVENTS: {
+    readonly RequestEditorMode: "requestEditorMode";
+    readonly RequestReadOnlyMode: "requestReadOnlyMode";
+    readonly ExperienceUpdated: "componentTreeUpdated";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly ComponentDraggingChanged: "componentDraggingChanged";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly ComponentDragCanceled: "componentDragCanceled";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly ComponentDragStarted: "componentDragStarted";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly ComponentDragEnded: "componentDragEnded";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly ComponentMoveEnded: "componentMoveEnded";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly CanvasResized: "canvasResized";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly SelectComponent: "selectComponent";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly HoverComponent: "hoverComponent";
+    readonly UpdatedEntity: "updatedEntity";
+    /** @deprecated not needed after `patternResolution` was introduced. Will be removed in the next major version. */
+    readonly AssembliesAdded: "assembliesAdded";
+    /** @deprecated not needed after `patternResolution` was introduced. Will be removed in the next major version. */
+    readonly AssembliesRegistered: "assembliesRegistered";
+    /** @deprecated will be removed when dropping backward compatibility for old DND */
+    readonly MouseMove: "mouseMove";
+    readonly RequestedEntities: "REQUESTED_ENTITIES";
+};
+declare const INTERNAL_EVENTS: {
+    readonly ComponentsRegistered: "cfComponentsRegistered";
+    readonly VisualEditorInitialize: "cfVisualEditorInitialize";
+};
+/**
+ * These modes are ONLY intended to be internally used within the context of
+ * editing an experience inside of Contentful Studio. i.e. these modes
+ * intentionally do not include preview/delivery modes.
+ */
+declare enum StudioCanvasMode {
+    READ_ONLY = "readOnlyMode",
+    EDITOR = "editorMode",
+    NONE = "none"
+}
+declare enum PostMessageMethods {
+    REQUEST_ENTITIES = "REQUEST_ENTITIES",
+    REQUESTED_ENTITIES = "REQUESTED_ENTITIES"
+}
+
+interface EntityFromLink {
+    getEntityFromLink(link: UnresolvedLink<'Entry' | 'Asset'>): Asset | Entry | undefined;
+}
+/**
+ * Base Store for entities
+ * Can be extended for the different loading behaviours (editor, production, ..)
+ */
+declare abstract class EntityStoreBase implements EntityFromLink {
+    locale: string;
+    protected entryMap: Map<string, Entry>;
+    protected assetMap: Map<string, Asset<ChainModifiers, string>>;
+    constructor({ entities, locale }: {
+        entities: Array<Entry | Asset>;
+        locale: string;
+    });
+    get entities(): (Entry | Asset<ChainModifiers, string>)[];
+    updateEntity(entity: Entry | Asset): void;
+    getEntryOrAsset(linkOrEntryOrAsset: UnresolvedLink<'Entry' | 'Asset'> | Asset | Entry, path: string): Entry | Asset | undefined;
+    /**
+     * @deprecated in the base class this should be simply an abstract method
+     * @param entityLink
+     * @param path
+     * @returns
+     */
+    getValue(entityLink: UnresolvedLink<'Entry' | 'Asset'>, path: string[]): string | undefined;
+    getEntityFromLink(link: UnresolvedLink<'Entry' | 'Asset'>): Asset | Entry | undefined;
+    getAssetById(assetId: string): Asset | undefined;
+    getEntryById(entryId: string): Entry | undefined;
+    protected getEntitiesFromMap(type: 'Entry' | 'Asset', ids: string[]): {
+        resolved: (Entry | Asset<ChainModifiers, string>)[];
+        missing: string[];
+    };
+    protected addEntity(entity: Entry | Asset): void;
+    fetchAsset(id: string): Promise<Asset | undefined>;
+    fetchAssets(ids: string[]): Promise<Asset[]>;
+    fetchEntry(id: string): Promise<Entry | undefined>;
+    fetchEntries(ids: string[]): Promise<Entry[]>;
+    private getDeepEntry;
+    private getEntity;
+    toJSON(): {
+        entryMap: {
+            [k: string]: Entry;
+        };
+        assetMap: {
+            [k: string]: Asset<ChainModifiers, string>;
+        };
+        locale: string;
+    };
+}
+
+type SendMessage = (method: PostMessageMethods.REQUEST_ENTITIES, params: RequestEntitiesMessage) => void;
+type Subscribe = (method: PostMessageMethods.REQUESTED_ENTITIES, cb: (message: RequestedEntitiesMessage) => void) => VoidFunction;
+/**
+ * EntityStore which resolves entries and assets from the editor
+ * over the sendMessage and subscribe functions.
+ */
+declare abstract class EditorEntityStore extends EntityStoreBase {
+    private requestCache;
+    private sendMessage;
+    private subscribe;
+    private timeoutDuration;
+    constructor({ entities, locale, sendMessage, subscribe, timeoutDuration, }: {
+        entities: Array<Entry | Asset>;
+        locale: string;
+        sendMessage: SendMessage;
+        subscribe: Subscribe;
+        timeoutDuration?: number;
+    });
+    private cleanupPromise;
+    private cacheIdSeperator;
+    private getCacheId;
+    private fetchEntity;
+    fetchAsset(id: string, skipCache?: boolean): Promise<Asset | undefined>;
+    fetchAssets(ids: string[], skipCache?: boolean): Promise<Asset[]>;
+    fetchEntry(id: string, skipCache?: boolean): Promise<Entry | undefined>;
+    fetchEntries(ids: string[], skipCache?: boolean): Promise<Entry[]>;
+}
+
+declare class EditorModeEntityStore extends EditorEntityStore {
+    constructor({ entities, locale }: {
+        entities: Array<Asset | Entry>;
+        locale: string;
+    });
+    /**
+     * This function collects and returns the list of requested entries and assets. Additionally, it checks
+     * upfront whether any async fetching logic is actually happening. If not, it returns a plain `false` value, so we
+     * can detect this early and avoid unnecessary re-renders.
+     * @param entityLinks
+     * @returns false if no async fetching is happening, otherwise a promise that resolves when all entities are fetched
+     */
+    fetchEntities({ missingEntryIds, missingAssetIds, skipCache, }: {
+        missingEntryIds: string[];
+        missingAssetIds: string[];
+        skipCache?: boolean;
+    }): Promise<void>;
+    getMissingEntityIds(entityLinks: UnresolvedLink<'Entry' | 'Asset'>[]): {
+        missingEntryIds: string[];
+        missingAssetIds: string[];
+    };
+    getValue(entityLinkOrEntity: UnresolvedLink<'Entry' | 'Asset'> | Entry | Asset, path: string[]): string | undefined;
+}
+
+type EntityStoreArgs = {
+    experienceEntry: ExperienceEntry | Entry;
+    entities: Array<Entry | Asset>;
+    locale: string;
+};
+declare class EntityStore extends EntityStoreBase {
+    private _isExperienceAPatternEntry;
+    private _experienceEntryFields;
+    private _experienceEntryId;
+    private _unboundValues;
+    private _usedComponentsWithDeepReferences;
+    private _hoistedParameterDefinitions;
+    private _hoistedVariableMappings;
+    constructor(json: string);
+    constructor({ experienceEntry, entities, locale }: EntityStoreArgs);
+    private static calculateHoistedParameterDefinitions;
+    private static calculateHoistedVariableMappings;
+    getCurrentLocale(): string;
+    get isExperienceAPatternEntry(): boolean;
+    get hoistedVariableMappings(): Record<string, {
+        type: "ContentTypeMapping";
+        parameterId: string;
+        pathsByContentType: Record<string, {
+            path: string;
+        }>;
+    }>;
+    get hoistedParameterDefinitions(): Record<string, {
+        contentTypes: string[];
+        passToNodes: {
+            prebindingId: string;
+            parameterId: string;
+            nodeId: string;
+        }[];
+        defaultSource?: {
+            type: "Entry";
+            contentTypeId: string;
+            link: {
+                sys: {
+                    type: "Link";
+                    id: string;
+                    linkType: "Entry";
+                };
+            };
+        } | undefined;
+    }>;
+    get experienceEntryFields(): ExperienceFields | undefined;
+    get experienceEntryId(): string | undefined;
+    get schemaVersion(): "2023-09-28" | undefined;
+    get breakpoints(): {
+        id: string;
+        query: "*" | `>${number}px` | `<${number}px`;
+        displayName: string;
+        previewSize?: string | undefined;
+        displayIcon?: "desktop" | "tablet" | "mobile" | undefined;
+    }[];
+    get dataSource(): Record<string, {
+        sys: {
+            type: "Link";
+            id: string;
+            linkType: "Entry" | "Asset";
+        };
+    }>;
+    get unboundValues(): Record<string, {
+        value?: string | number | boolean | Record<any, any> | undefined;
+    }>;
+    get usedComponents(): ExperienceEntry[];
+    /**
+     * Extend the existing set of unbound values with the ones from the assembly definition.
+     * When creating a new assembly out of a container, the unbound value keys are copied and
+     * thus the existing and the added ones have colliding keys. In the case of overlapping value
+     * keys, the ones from the experience overrule the ones from the assembly definition as
+     * the latter one is certainly just a default value while the other one is from the actual instance.
+     * @param unboundValues set of unbound values defined in the assembly definition
+     */
+    addAssemblyUnboundValues(unboundValues: ExperienceUnboundValues): void;
+    getValue(entityLinkOrEntity: UnresolvedLink<'Entry' | 'Asset'> | Entry | Asset, path: string[]): string | undefined;
+    toJSON(): {
+        entryMap: {
+            [k: string]: Entry;
+        };
+        assetMap: {
+            [k: string]: Asset<contentful.ChainModifiers, string>;
+        };
+        locale: string;
+        _experienceEntryFields: ExperienceFields | undefined;
+        _experienceEntryId: string | undefined;
+        _unboundValues: Record<string, {
+            value?: string | number | boolean | Record<any, any> | undefined;
+        }> | undefined;
+    };
+}
+
+interface InMemoryEntitiesState {
+    entityStore: EntityStoreBase;
+    areEntitiesFetched: boolean;
+    setEntitiesFetched: (fetched: boolean) => void;
+    resolveEntity: <T extends 'Entry' | 'Asset'>(link?: UnresolvedLink<T>) => Entry | Asset | undefined;
+    resolveAssetById: (assetId?: string) => Asset | undefined;
+    resolveEntryById: (entryId?: string) => Entry | undefined;
+    resetEntityStore: (entityStore: EntityStoreBase) => void;
+}
+declare const inMemoryEntitiesStore: zustand.UseBoundStore<zustand.StoreApi<InMemoryEntitiesState>>;
+type InMemoryEntitiesStore = typeof inMemoryEntitiesStore;
+
+/**
+ * Resolves a link to its corresponding entry or asset if available.
+ *
+ * @note When using this function please ensure to explicitly handle `undefined` values in
+ * your component to protect against scenarios where the property was not yet bound to an
+ * entity inside the editor UI. The SDK will set the property to `undefined` in those cases.
+ * You can use the SDK helper functions `isLink`, `isLinkToEntry`, `isLinkToAsset`, or
+ * `isArrayOfLinks` for this purpose.
+ */
+declare function maybeResolveLink(maybeLink: UnresolvedLink<'Entry'>): Entry | undefined;
+declare function maybeResolveLink(maybeLink: UnresolvedLink<'Asset'>): Asset | undefined;
+declare function maybeResolveLink(maybeLink: UnresolvedLink<'Asset' | 'Entry'>): Asset | Entry | undefined;
+declare function maybeResolveLink(maybeLink: NonNullable<unknown>): Entry | Asset | undefined;
+declare function maybeResolveByAssetId(assetId: string): Asset | undefined;
+declare function maybeResolveByEntryId(entryId: string): Entry | undefined;
+declare function hasEntry(entryId: string): boolean;
+declare function hasAsset(assetId: string): boolean;
+declare function addEntities(entities: Array<Entry>): void;
+declare function addEntities(entities: Array<Asset>): void;
+declare function addEntities(entities: Array<Entry | Asset>): void;
+declare const inMemoryEntities: {
+    maybeResolveLink: typeof maybeResolveLink;
+    maybeResolveByAssetId: typeof maybeResolveByAssetId;
+    maybeResolveByEntryId: typeof maybeResolveByEntryId;
+    hasEntry: typeof hasEntry;
+    hasAsset: typeof hasAsset;
+    addEntities: typeof addEntities;
+};
+type InMemoryEntitiesPublicApi = typeof inMemoryEntities;
+declare const useInMemoryEntities: () => {
+    maybeResolveLink: typeof maybeResolveLink;
+    maybeResolveByAssetId: typeof maybeResolveByAssetId;
+    maybeResolveByEntryId: typeof maybeResolveByEntryId;
+    hasEntry: typeof hasEntry;
+    hasAsset: typeof hasAsset;
+    addEntities: typeof addEntities;
+};
+
+type ComponentDefinitionVariableTypeMap = {
+    Array: unknown[];
+    Boolean: boolean;
+    Date: string;
+    Hyperlink: string;
+    Link: Record<string, unknown>;
+    Location: {
+        lon: number;
+        lat: number;
+    };
+    Media: Record<string, unknown> | string;
+    Number: number;
+    Object: Record<string, unknown>;
+    RichText: string;
+    Text: string;
+};
+type ScrollStateKey = keyof typeof SCROLL_STATES;
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+type ScrollState = (typeof SCROLL_STATES)[ScrollStateKey];
+type OutgoingEventKey = keyof typeof OUTGOING_EVENTS;
+type OutgoingEvent = (typeof OUTGOING_EVENTS)[OutgoingEventKey];
+type IncomingEventKey = keyof typeof INCOMING_EVENTS;
+type IncomingEvent = (typeof INCOMING_EVENTS)[IncomingEventKey];
+type InternalEventKey = keyof typeof INTERNAL_EVENTS;
+type InternalEvent = (typeof INTERNAL_EVENTS)[InternalEventKey];
+interface Link<T extends string> {
+    sys: {
+        type: 'Link';
+        linkType: T;
+        id: string;
+    };
+}
+type VariableFormats = 'URL';
+type ValidationOption<T extends ComponentDefinitionPropertyType> = {
+    value: T extends 'Text' ? string : T extends 'Number' ? number : never;
+    displayName?: string;
+};
+type ComponentDefinitionVariableValidation<T extends ComponentDefinitionPropertyType> = {
+    required?: boolean;
+    in?: ValidationOption<T>[];
+    format?: VariableFormats;
+    /** Define the type of entity that can be bound to this variable. The provided list order defines
+     * the order of select options in the editor UI, i.e. the first item will be pre-selected by default. */
+    bindingSourceType?: BindingSourceTypeEnum;
+};
+interface ComponentDefinitionVariableBase<T extends ComponentDefinitionPropertyType> {
+    type: T;
+    validations?: ComponentDefinitionVariableValidation<T>;
+    group?: 'style' | 'content';
+    description?: string;
+    displayName?: string;
+    defaultValue?: ComponentDefinitionVariableTypeMap[T];
+}
+type ComponentDefinitionVariable<T extends ComponentDefinitionPropertyType = ComponentDefinitionPropertyType> = ComponentDefinitionVariableBase<T>;
+type ComponentDefinition<T extends ComponentDefinitionPropertyType = ComponentDefinitionPropertyType> = {
+    id: string;
+    name: string;
+    category?: string;
+    thumbnailUrl?: string;
+    thumbnailId?: string;
+    hyperlinkPattern?: string;
+    variables: Partial<DesignVariableMap> & Record<string, ComponentDefinitionVariable<T>>;
+    /** Render child components in specified slots. This is an advanced version of the `children`
+     * configuration. We don't recommend using both together, as it can lead to unexpected behavior. */
+    slots?: Record<string, {
+        displayName: string;
+    }>;
+    /**
+     * List of built-in styles that can be applied to the component.
+     *
+     * Note that the property 'cfVisibility' is enforced on every component to control its visibility.
+     * @example ['cfWidth', 'cfPadding']
+     * @default ['cfMargin']
+     */
+    builtInStyles?: Array<keyof Omit<StyleProps, 'cfHyperlink' | 'cfOpenInNewTab'>>;
+    /** Component allows passing child components inside it.
+     * @default false
+     */
+    children?: boolean;
+    tooltip?: {
+        imageUrl?: string;
+        description: string;
+    };
+};
+type ComponentRegistration = {
+    component: React.ElementType;
+    definition: ComponentDefinition;
+    options?: {
+        /**
+         * If true, the component receives the optional boolean property `isInExpEditorMode` to
+         * render different content between editor and delivery mode.
+         *
+         * @deprecated this will be replaced by enableEditorProperties in the next major version
+         */
+        enableCustomEditorView?: boolean;
+        /**
+         * If set, the specified properties are passed to the component when rendered in the editor.
+         */
+        enableEditorProperties?: {
+            /**
+             * Enable the property `isEditorMode` which will be `true` if being rendered inside the Studio editor.
+             */
+            isEditorMode?: boolean;
+            /**
+             * Enable the property `isEmpty` which will be `true` if the component has no children.
+             * This can be used to render a placeholder or label in the editor when the component is empty.
+             *
+             * @note This will be false if there are no direct children nor slot children.
+             */
+            isEmpty?: boolean;
+            /**
+             * Enable the string property `nodeBlockId` which is equal to the component ID
+             * passed during registration, i.e. `ComponentDefinition['id']`.
+             */
+            nodeBlockId?: boolean;
+        };
+        wrapComponent?: boolean;
+        wrapContainer?: keyof JSX.IntrinsicElements;
+        /**
+         * @deprecated This option is not supported anymore and will be fully removed in the
+         * next major release v4. */
+        wrapContainerWidth?: React.CSSProperties['width'];
+    };
+};
+/**
+ * Use this for type-safe access to editor properties in your custom components
+ * @example
+ * type MyCustomProps = { myValue: string }
+ * type MyComponentProps = EditorProperties<'isEmpty'> & MyCustomProps
+ */
+type EditorProperties<T extends EditorPropertyNames = EditorPropertyNames> = Pick<BaseEditorProperties, T>;
+type EditorPropertyNames = keyof BaseEditorProperties;
+type BaseEditorProperties = {
+    isEditorMode?: boolean;
+    isEmpty?: boolean;
+    nodeBlockId?: string;
+    /** @deprecated will be replaced by `isEditorMode` with the next major version of the SDK */
+    isInExpEditorMode?: boolean;
+};
+type ComponentRegistrationOptions = {
+    /**
+     * Restrict the list of built-in components to a defined set of IDs.
+     * @example ['contentful-container', 'contentful-button']
+     */
+    enabledBuiltInComponents?: string[];
+    experimentalComponents?: {
+        carousel?: boolean;
+    };
+    /**
+     * Originally, the persisted values for `cfTextAlign` were plainly rendered
+     * when generating the CSS code for a components styles. To enable right-to-left
+     * directions natively, the alignment values were recently switched from
+     * `left`/`right` to `start`/`end`. To save customers from manually replacing old
+     * with new alignment values in every experience, we're translating them automatically
+     * in the rendering logic as well. If this new behaviour introduces any issues,
+     * customers can opt-out by setting this flag.
+     * @deprecated This is a temporary solution and will be removed in a future major version.
+     */
+    __disableTextAlignmentTransform?: boolean;
+    /**
+     * If you need to adjust the built-in structural components (e.g. `container`),
+     * enable this flag. It is marked as *unsafe* since the logic of those components
+     * might evolve in future versions. By overwriting their implementation, you accept
+     * the risk of potential breaking changes and running out of sync with the original
+     * implementation.
+     */
+    __unsafe__enableBuiltInStructureOverwrites?: boolean;
+};
+type Binding = {
+    spaceId: string;
+    environmentId: string;
+    entityId: string;
+    entityType: 'Entry' | 'Asset' | 'ContentType';
+    path: string[];
+};
+type ComponentBinding = Record<string, Binding>;
+type BindingMap = Record<string, ComponentBinding>;
+type BindingMapByBlockId = Record<string, BindingMap>;
+type DataSourceEntryValueType = Link<'Entry' | 'Asset'>;
+/** Type of a single node of the experience tree exchanged via postMessage between the SDK and Contentful Web app */
+type ExperienceTreeNode = {
+    type: 'block' | 'root' | 'assembly' | 'assemblyBlock';
+    data: {
+        id: string;
+        blockId?: string;
+        slotId?: string;
+        displayName?: string;
+        props: Record<string, ComponentPropertyValue>;
+        dataSource: ExperienceDataSource;
+        unboundValues: ExperienceUnboundValues;
+        breakpoints: Breakpoint[];
+        parameters?: Record<string, Parameter>;
+        prebindingId?: string;
+        pattern?: {
+            id: string;
+            nodeId: string;
+            nodeLocation: string;
+            nodeIdOnPattern: string;
+            isVisibilityPropertyExposed: boolean;
+            variableNameToComponentValueKeyMap: Record<string, string>;
+        };
+    };
+    children: ExperienceTreeNode[];
+    parentId?: string;
+};
+/** Type of the tree data structure exchanged via postMessage between the SDK and Contentful Web app */
+type ExperienceTree = {
+    root: ExperienceTreeNode;
+};
+/**
+ * Internally defined style variables are prefix with `cf` to avoid
+ * collisions with user defined variables.
+ */
+type StyleProps = {
+    cfVisibility: boolean;
+    cfHorizontalAlignment: 'start' | 'end' | 'center' | 'stretch';
+    cfVerticalAlignment: 'start' | 'end' | 'center' | 'stretch';
+    cfMargin: string;
+    cfPadding: string;
+    cfBackgroundColor: string;
+    cfWidth: string;
+    cfMaxWidth: string;
+    cfHeight: string;
+    cfFlexDirection: 'row' | 'column';
+    cfFlexWrap: 'nowrap' | 'wrap';
+    cfFlexReverse: boolean;
+    cfBorder: string;
+    cfBorderRadius: string;
+    cfGap: string;
+    cfHyperlink: string;
+    cfImageAsset: OptimizedImageAsset | string;
+    cfImageOptions: ImageOptions;
+    cfBackgroundImageUrl: OptimizedBackgroundImageAsset | string;
+    cfBackgroundImageOptions: BackgroundImageOptions;
+    cfOpenInNewTab: boolean;
+    cfFontSize: string;
+    cfFontWeight: string;
+    cfLineHeight: string;
+    cfLetterSpacing: string;
+    cfTextColor: string;
+    cfTextAlign: 'start' | 'center' | 'end';
+    cfTextTransform: 'none' | 'capitalize' | 'uppercase' | 'lowercase';
+    cfTextBold: boolean;
+    cfTextItalic: boolean;
+    cfTextUnderline: boolean;
+    cfColumns: string;
+    cfColumnSpan: string;
+    cfColumnSpanLock: boolean;
+    cfWrapColumns: boolean;
+    cfWrapColumnsCount: string;
+};
+/**
+ * Internally defined style variables mapped to each variable type
+ */
+type DesignVariableTypes = {
+    cfVisibility: 'Boolean';
+    cfHorizontalAlignment: 'Text';
+    cfVerticalAlignment: 'Text';
+    cfMargin: 'Text';
+    cfPadding: 'Text';
+    cfBackgroundColor: 'Text';
+    cfWidth: 'Text';
+    cfMaxWidth: 'Text';
+    cfHeight: 'Text';
+    cfFlexDirection: 'Text';
+    cfFlexWrap: 'Text';
+    cfFlexReverse: 'Boolean';
+    cfBorder: 'Text';
+    cfBorderRadius: 'Text';
+    cfGap: 'Text';
+    cfHyperlink: 'Hyperlink';
+    cfImageAsset: 'Media';
+    cfImageOptions: 'Object';
+    cfBackgroundImageUrl: 'Media';
+    cfBackgroundImageOptions: 'Object';
+    cfOpenInNewTab: 'Boolean';
+    cfFontSize: 'Text';
+    cfFontWeight: 'Text';
+    cfLineHeight: 'Text';
+    cfLetterSpacing: 'Text';
+    cfTextColor: 'Text';
+    cfTextAlign: 'Text';
+    cfTextTransform: 'Text';
+    cfTextBold: 'Boolean';
+    cfTextItalic: 'Boolean';
+    cfTextUnderline: 'Boolean';
+    cfColumns: 'Text';
+    cfColumnSpan: 'Text';
+    cfColumnSpanLock: 'Boolean';
+    cfWrapColumns: 'Boolean';
+    cfWrapColumnsCount: 'Text';
+};
+type DesignVariableMap = {
+    [K in keyof DesignVariableTypes]: ComponentDefinitionVariable<DesignVariableTypes[K]>;
+};
+type CSSProperties = React.CSSProperties;
+type ContainerStyleVariableName = keyof StyleProps;
+type ExperienceFields = {
+    title: string;
+    slug: string;
+    componentTree: ExperienceComponentTree;
+    dataSource: ExperienceDataSource;
+    unboundValues: ExperienceUnboundValues;
+    usedComponents?: ExperienceUsedComponents | Array<ExperienceEntry>;
+    componentSettings?: ExperienceComponentSettings;
+};
+type RecursiveDesignTokenDefinition = {
+    [key: string]: string | RecursiveDesignTokenDefinition;
+};
+type DesignBorderTokenStyle = 'solid' | 'dashed' | 'dotted';
+/** We are currently in the process of implementing this feature. Do not use this field in your designTokenDefinition. **/
+type DesignTextTokenEmphasis = 'bold' | 'italic' | 'underline' | 'bold italic' | 'bold underline' | 'italic underline' | 'bold italic underline' | 'none';
+/** We are currently in the process of implementing this feature. Do not use this field in your designTokenDefinition. **/
+type DesignTextTokenCase = 'capitalize' | 'uppercase' | 'lowercase' | 'normal';
+type DesignTokensDefinition = {
+    spacing?: Record<string, string>;
+    sizing?: Record<string, string>;
+    color?: Record<string, string>;
+    border?: Record<string, {
+        width?: string;
+        style?: DesignBorderTokenStyle;
+        color?: string;
+    }>;
+    borderRadius?: Record<string, string>;
+    fontSize?: Record<string, string>;
+    lineHeight?: Record<string, string>;
+    letterSpacing?: Record<string, string>;
+    textColor?: Record<string, string>;
+    /** We are currently in the process of implementing this feature. Do not use this field in your designTokenDefinition. **/
+    text?: Record<string, {
+        emphasis?: DesignTextTokenEmphasis;
+        fontSize?: string;
+        case?: DesignTextTokenCase;
+        fontWeight?: string;
+        lineHeight?: string;
+        letterSpacing?: string;
+        color?: string;
+    }>;
+} & RecursiveDesignTokenDefinition;
+type SdkOptions = {
+    __disableTextAlignmentTransform?: ComponentRegistrationOptions['__disableTextAlignmentTransform'];
+    __unsafe__enableBuiltInStructureOverwrites?: ComponentRegistrationOptions['__unsafe__enableBuiltInStructureOverwrites'];
+};
+/** Type of experience entry JSON data structure as returned by CPA/CDA */
+type ExperienceEntry = {
+    sys: Entry['sys'];
+    fields: ExperienceFields;
+    metadata: Entry['metadata'];
+};
+interface RawCoordinates {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+interface Coordinates extends RawCoordinates {
+    childrenCoordinates: RawCoordinates[];
+}
+interface HoveredElement {
+    blockType: string | undefined;
+    nodeId: string | undefined;
+    blockId: string | undefined;
+}
+interface Experience<T extends EntityStore = EntityStore> {
+    hyperlinkPattern?: string;
+    entityStore?: T;
+}
+type ResolveDesignValueType = (valuesByBreakpoint: ValuesByBreakpoint | undefined, propertyName?: string) => PrimitiveValue;
+type ManagementEntity = (Entry | Asset) & {
+    sys: {
+        version: number;
+    };
+};
+type RequestEntitiesMessage = {
+    entityIds: string[];
+    entityType: 'Asset' | 'Entry';
+    locale: string;
+};
+type RequestedEntitiesMessage = {
+    entities: Array<Entry | Asset>;
+    missingEntityIds?: string[];
+};
+type BoundComponentPropertyTypes = string | number | boolean | AssetFile | Record<string, AssetFile | undefined> | Document | OptimizedBackgroundImageAsset | OptimizedImageAsset | Link<'Asset'> | Link<'Entry'> | Array<Link<'Asset' | 'Entry'>> | Entry | Asset | (string | Entry | Asset<ChainModifiers, string> | undefined)[] | undefined;
+type OptimizedImageAsset = {
+    url: string;
+    srcSet?: string[];
+    sizes?: string;
+    quality?: number;
+    format?: string;
+    file: AssetFile;
+    loading?: ImageLoadingOption;
+};
+type OptimizedBackgroundImageAsset = {
+    url: string;
+    srcSet?: string[];
+    file: AssetFile;
+};
+type ImageObjectFitOption = 'contain' | 'cover' | 'none';
+type ImageObjectPositionOption = 'left top' | 'left center' | 'left bottom' | 'right top' | 'right center' | 'right bottom' | 'center top' | 'center center' | 'center bottom';
+type ImageLoadingOption = 'lazy' | 'eager';
+type ImageOptions = {
+    format?: string;
+    width: string;
+    height: string;
+    loading?: ImageLoadingOption;
+    objectFit?: ImageObjectFitOption;
+    objectPosition?: ImageObjectPositionOption;
+    quality?: string;
+    targetSize: string;
+};
+type BackgroundImageScalingOption = 'fit' | 'fill' | 'tile';
+type BackgroundImageAlignmentOption = 'left top' | 'left center' | 'left bottom' | 'right top' | 'right center' | 'right bottom' | 'center top' | 'center center' | 'center bottom';
+type BackgroundImageOptions = {
+    format?: string;
+    scaling: BackgroundImageScalingOption;
+    alignment: BackgroundImageAlignmentOption;
+    quality?: string;
+    targetSize: string;
+};
+type ConnectedPayload = undefined | {
+    sdkVersion: string;
+    definitions: ComponentDefinition[];
+};
+type DesignTokensPayload = {
+    designTokens: DesignTokensDefinition;
+    resolvedCssVariables: Record<string, string>;
+};
+type RegisteredBreakpointsPayload = {
+    breakpoints: Breakpoint[];
+};
+type MouseMovePayload = {
+    clientX: number;
+    clientY: number;
+};
+type NewHoveredElementPayload = {
+    nodeId?: string;
+};
+type ComponentSelectedPayload = {
+    nodeId: string;
+    assembly?: {
+        id: string;
+        componentId: string;
+        nodeLocation: string | null;
+    };
+};
+type RegisteredComponentsPayload = {
+    definitions: ComponentDefinition[];
+};
+type RequestComponentTreeUpdatePayload = undefined;
+type ComponentDragCanceledPayload = undefined;
+type ComponentDroppedPayload = {
+    node: ExperienceTreeNode;
+    index: number;
+    parentNode: {
+        type?: ExperienceTreeNode['type'] | 'root';
+        data: {
+            blockId?: string;
+            id?: string;
+        };
+    };
+};
+type ComponentMovedPayload = {
+    nodeId: string;
+    sourceParentId: string;
+    destinationParentId: string;
+    sourceIndex: number;
+    destinationIndex: number;
+};
+type CanvasReloadPayload = undefined;
+type CanvasErrorPayload = Error;
+type UpdateSelectedComponentCoordinatesPayload = {
+    selectedNodeCoordinates: DOMRect;
+    selectedAssemblyChildCoordinates?: DOMRect;
+    parentCoordinates?: DOMRect;
+};
+type CanvasScrollPayload = (typeof SCROLL_STATES)[keyof typeof SCROLL_STATES];
+type ComponentMoveStartedPayload = undefined;
+type ComponentMoveEndedPayload = undefined;
+type OutsideCanvasClickPayload = {
+    outsideCanvasClick: boolean;
+};
+type SDKFeaturesPayload = Record<string, unknown>;
+type RequestEntitiesPayload = {
+    entityIds: string[];
+    entityType: 'Entry' | 'Asset';
+    locale: string;
+};
+type OUTGOING_EVENT_PAYLOADS = {
+    connected: ConnectedPayload;
+    registerDesignTokens: DesignTokensPayload;
+    registeredBreakpoints: RegisteredBreakpointsPayload;
+    mouseMove: MouseMovePayload;
+    newHoveredElement: NewHoveredElementPayload;
+    componentSelected: ComponentSelectedPayload;
+    registeredComponents: RegisteredComponentsPayload;
+    requestComponentTreeUpdate: RequestComponentTreeUpdatePayload;
+    componentDragCanceled: ComponentDragCanceledPayload;
+    componentDropped: ComponentDroppedPayload;
+    componentMoved: ComponentMovedPayload;
+    canvasReload: CanvasReloadPayload;
+    canvasError: CanvasErrorPayload;
+    updateSelectedComponentCoordinates: UpdateSelectedComponentCoordinatesPayload;
+    canvasScrolling: CanvasScrollPayload;
+    componentMoveStarted: ComponentMoveStartedPayload;
+    componentMoveEnded: ComponentMoveEndedPayload;
+    outsideCanvasClick: OutsideCanvasClickPayload;
+    sdkFeatures: SDKFeaturesPayload;
+    REQUEST_ENTITIES: RequestEntitiesPayload;
+    canvasGeometryUpdated: {
+        size: {
+            width: number;
+            height: number;
+        };
+        nodes: Record<string, {
+            coordinates: Pick<DOMRect, 'x' | 'y' | 'width' | 'height'>;
+        }>;
+        sourceEvent: CanvasGeometryUpdateSourceEvent;
+    };
+    canvasPan: {
+        ctrlKey: boolean;
+        metaKey: boolean;
+        clientX: number;
+        clientY: number;
+        deltaX: number;
+        deltaY: number;
+    };
+};
+type CanvasGeometryUpdateSourceEvent = 'resize' | 'mutation' | 'mediaResize';
+type SendMessageParams = <T extends OutgoingEvent>(eventType: T, data: OUTGOING_EVENT_PAYLOADS[T]) => void;
+type OutgoingMessage = {
+    [K in keyof OUTGOING_EVENT_PAYLOADS]: {
+        source: 'customer-app';
+        eventType: K;
+        payload: OUTGOING_EVENT_PAYLOADS[K];
+    };
+}[keyof OUTGOING_EVENT_PAYLOADS];
+type Filter<T, U> = T extends U ? T : never;
+type SelectedValueTypes = Filter<ComponentPropertyValue['type'], 'UnboundValue' | 'BoundValue'>;
+type RequestReadOnlyModePayload = undefined;
+type RequestEditorModePayload = undefined;
+type ExperienceUpdatedPayload = {
+    tree: ExperienceTree;
+    /** @deprecated not needed after `patternResolution` was introduced. Will be removed in the next major version. */
+    assemblies?: ExperienceUsedComponents;
+    locale: string;
+    changedNode?: ExperienceTreeNode;
+    changedValueType?: SelectedValueTypes;
+};
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+type ComponentDraggingChangedPayload = {
+    isDragging: boolean;
+};
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+type IncomingComponentDragCanceledPayload = undefined;
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+type ComponentDragStartedPayload = {
+    id: string;
+    isAssembly: boolean;
+};
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+type ComponentDragEndedPayload = undefined;
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+type IncomingComponentMoveEndedPayload = {
+    mouseX: number;
+    mouseY: number;
+};
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+type CanvasResizedPayload = {
+    selectedNodeId: string;
+};
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+type SelectComponentPayload = {
+    selectedNodeId: string;
+};
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+type HoverComponentPayload = {
+    hoveredNodeId: string;
+};
+type UpdatedEntityPayload = {
+    entity: ManagementEntity;
+    shouldRerender?: boolean;
+};
+type AssembliesAddedPayload = {
+    assembly: ManagementEntity;
+    assemblyDefinition: ComponentDefinition;
+};
+type AssembliesRegisteredPayload = {
+    assemblies: ComponentDefinition[];
+};
+/** @deprecated will be removed when dropping backward compatibility for old DND */
+type IncomingMouseMovePayload = {
+    mouseX: number;
+    mouseY: number;
+};
+type RequestedEntitiesPayload = {
+    entities: ManagementEntity[];
+};
+type INCOMING_EVENT_PAYLOADS = {
+    requestEditorMode: RequestEditorModePayload;
+    requestReadOnlyMode: RequestReadOnlyModePayload;
+    componentTreeUpdated: ExperienceUpdatedPayload;
+    componentDraggingChanged: ComponentDraggingChangedPayload;
+    componentDragCanceled: IncomingComponentDragCanceledPayload;
+    componentDragStarted: ComponentDragStartedPayload;
+    componentDragEnded: ComponentDragEndedPayload;
+    componentMoveEnded: IncomingComponentMoveEndedPayload;
+    canvasResized: CanvasResizedPayload;
+    selectComponent: SelectComponentPayload;
+    hoverComponent: HoverComponentPayload;
+    updatedEntity: UpdatedEntityPayload;
+    assembliesAdded: AssembliesAddedPayload;
+    assembliesRegistered: AssembliesRegisteredPayload;
+    mouseMove: IncomingMouseMovePayload;
+    REQUESTED_ENTITIES: RequestedEntitiesPayload;
+};
+type IncomingMessage = {
+    [K in keyof INCOMING_EVENT_PAYLOADS]: {
+        eventType: K;
+        payload: INCOMING_EVENT_PAYLOADS[K];
+    };
+}[keyof INCOMING_EVENT_PAYLOADS];
+
+declare const MEDIA_QUERY_REGEXP: RegExp;
+declare const mediaQueryMatcher: (breakpoints: Breakpoint[]) => [{
+    id: string;
+    signal: MediaQueryList;
+}[], Record<string, boolean>];
+declare const getActiveBreakpointIndex: (breakpoints: Breakpoint[], mediaQueryMatches: Record<string, boolean>, fallbackBreakpointIndex: number) => number;
+declare const getFallbackBreakpointIndex: (breakpoints: Breakpoint[]) => number;
+declare const isValidBreakpointValue: (value: PrimitiveValue) => value is Exclude<PrimitiveValue, undefined>;
+declare const getValueForBreakpoint: (valuesByBreakpoint: ValuesByBreakpoint | undefined, breakpoints: Breakpoint[], activeBreakpointIndex: number, fallbackBreakpointIndex: number, propertyName?: string, resolveDesignTokens?: boolean) => string | number | boolean | Record<any, any> | undefined;
+declare function mergeDesignValuesByBreakpoint(defaultValue: DesignValue, overwriteValue: DesignValue | undefined): DesignValue;
+declare function mergeDesignValuesByBreakpoint(defaultValue: DesignValue | undefined, overwriteValue: DesignValue): DesignValue;
+declare function mergeDesignValuesByBreakpoint(defaultValue: DesignValue | undefined, overwriteValue: DesignValue | undefined): DesignValue | undefined;
+declare const BREAKPOINTS_STRATEGY_DESKTOP_FIRST = "desktop-first";
+declare const BREAKPOINTS_STRATEGY_MOBILE_FIRST = "mobile-first";
+type BreakpointsStrategy = typeof BREAKPOINTS_STRATEGY_DESKTOP_FIRST | typeof BREAKPOINTS_STRATEGY_MOBILE_FIRST | undefined;
+/**
+ * Detects the breakpoint strategy based on the provided breakpoints.
+ *
+ * @param breakpoints The array of breakpoints to analyze.
+ * @returns The detected breakpoint strategy or undefined if not determinable.
+ */
+declare const detectBreakpointsStrategy: (breakpoints: Breakpoint[]) => BreakpointsStrategy;
+
+declare const DEBUG_LEVELS_HIERARCHY: readonly ["error", "warn", "log", "debug"];
+type DEBUG_LEVEL = (typeof DEBUG_LEVELS_HIERARCHY)[number];
+declare class DebugLogger {
+    private static instance;
+    private activeLevel;
+    constructor();
+    static getInstance(): DebugLogger;
+    getActiveLevel(): "error" | "warn" | "log" | "debug";
+    setActiveLevel(level: DEBUG_LEVEL): void;
+    private logger;
+    error: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    warn: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    log: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    debug: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+}
+declare const debug: DebugLogger;
+/** Set the logging level to `debug` */
+declare const enableDebug: () => void;
+/** Set the debug level to `warn` */
+declare const disableDebug: () => void;
+/** Set the debug level to the provided level */
+declare const setDebugLevel: (level: DEBUG_LEVEL) => void;
+
+type Rect = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+declare const findOutermostCoordinates: (first: Rect, second: Rect) => {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+declare const isElementHidden: (rect: DOMRect) => boolean;
+declare const getElementCoordinates: (element: Element) => DOMRect;
+
+declare const isLinkToAsset: (variable: unknown) => variable is Link<"Asset">;
+
+declare const isLinkToEntry: (variable: unknown) => variable is Link<"Entry">;
+
+declare function isLink(maybeLink: UnresolvedLink<'Entry'> | Entry | undefined): maybeLink is UnresolvedLink<'Entry'>;
+declare function isLink(maybeLink: UnresolvedLink<'Asset'> | Asset | undefined): maybeLink is UnresolvedLink<'Asset'>;
+declare function isLink(maybeLink: unknown): maybeLink is UnresolvedLink<'Entry' | 'Asset'>;
+
+/**
+ * Localizes the provided entry or asset to match the regular format of CDA/CPA entities.
+ * Note that this function does not apply a fallback to the default locale nor does it check
+ * the content type for the localization setting of each field.
+ * It will simply resolve each field to the requested locale. As using single and multiple
+ * reference fields is still considered an experimental feature, this function does not handle
+ * recursive localization of deeper referenced entities.
+ *
+ * If the entity is already localized, it will return the entity as is.
+ *
+ * Note that localization is later on determined by the existence of the `sys.locale` property (matching the API shape).
+ *
+ * @example
+ * ```
+ * const multiLocaleEntry = { fields: { title: { 'en-US': 'Hello' } } };
+ * const localizedEntry = localizeEntity(multiLocaleEntry, 'en-US');
+ * console.log(localizedEntry.fields.title); // 'Hello'
+ * ```
+ */
+declare function localizeEntity<T extends Asset | Entry>(entity: T, locale: string): T;
+
+/**
+ * This module encapsulates format of the path to a deep reference.
+ */
+
+type PreboundVariable = {
+    type: 'BoundValue';
+    path: string;
+    isPrebound: boolean;
+    pathsByContentType: Record<string, {
+        path: string;
+    }>;
+};
+declare const isPreboundProp: (variable: ComponentPropertyValue) => variable is PreboundVariable;
+type UnresolvedFieldset = Array<[null, string, string?]>;
+type Fieldset = Array<[Entry | Asset, string, string?]>;
+declare const parseDataSourcePathIntoFieldset: (path: string) => UnresolvedFieldset;
+/**
+ * Parse path into components, supports  L1 references (one reference follow) atm.
+ * @param path from data source. eg. `/uuid123/fields/image/~locale/fields/file/~locale`
+ *                               eg. `/uuid123/fields/file/~locale/fields/title/~locale`
+ * @returns
+ */
+declare const parseDataSourcePathWithL1DeepBindings: (path: string) => {
+    key: string;
+    field: string;
+    referentField: string;
+};
+/**
+ * Detects if paths is valid deep-path, like:
+ *  - /gV6yKXp61hfYrR7rEyKxY/fields/mainStory/~locale/fields/cover/~locale/fields/title/~locale
+ * or regular, like:
+ *  - /6J8eA60yXwdm5eyUh9fX6/fields/mainStory/~locale
+ * @returns
+ */
+declare const isDeepPath: (deepPathCandidate: string) => boolean;
+declare const isDeepPrebinding: (boundValueProperty: BoundValue) => boolean;
+declare const getPrebindingPathBySourceEntry: (preboundValueProperty: PreboundVariable, getHeadEntityByDataSourceKey: (id: string) => Entry | Asset | undefined) => string | undefined;
+declare const lastPathNamedSegmentEq: (path: string, expectedName: string) => boolean;
+
+declare const resolveHyperlinkPattern: (pattern: string, entry: Entry | null, locale: string | null) => string | null;
+declare function addLocale(str: string, locale: string): string;
+declare function getTemplateValue(ctx: {
+    entry: Entry;
+    locale: string;
+}, path: string): string | (() => string);
+declare function buildTemplate({ template, context, }: {
+    template: string;
+    context: {
+        entry: Entry;
+        locale: string;
+    };
+}): string;
+
+declare const sanitizeNodeProps: (nodeProps: Record<PropertyKey, PrimitiveValue>) => {
+    [k: string]: string | number | boolean | Record<any, any> | undefined;
+};
+
+declare const toCSSAttribute: (key: string) => string;
+/**
+ * Turns a list of CSSProperties into a joined CSS string that can be
+ * used for <style> tags. Per default it creates a minimized version.
+ * For editor mode, use the `useWhitespaces` flag to create a more readable version.
+ *
+ * @param cssProperties list of CSS properties
+ * @param useWhitespaces adds whitespaces and newlines between each rule
+ * @returns a string of CSS rules
+ */
+declare const stringifyCssProperties: (cssProperties: CSSProperties, useWhitespaces?: boolean) => string;
+declare const buildStyleTag: ({ styles, nodeId }: {
+    styles: CSSProperties;
+    nodeId?: string;
+}) => string[];
+/**
+ * Takes plain design values and transforms them into CSS properties. Undefined values will
+ * be filtered out.
+ *
+ * **Example Input**
+ * ```
+ * values = {
+ *   cfVisibility: 'visible',
+ *   cfMargin: '10px',
+ *   cfFlexReverse: true,
+ *   cfImageOptions: { objectFit: 'cover' },
+ *   // ...
+ * }
+ * ```
+ * **Example Output**
+ * ```
+ * cssProperties = {
+ *   margin: '10px',
+ *   flexDirection: 'row-reverse',
+ *   objectFit: 'cover',
+ *   // ...
+ * }
+ * ```
+ */
+declare const buildCfStyles: (values: Partial<StyleProps>) => CSSProperties;
+/**
+ * **Only meant to be used in editor mode!**
+ *
+ * If the node is an empty structure component with a relative height (e.g. '100%'),
+ * it might render with a zero height. In this case, add a min height of 80px to ensure
+ * that child nodes can be added via drag & drop.
+ */
+declare const addMinHeightForEmptyStructures: (cssProperties: CSSProperties, node: ComponentTreeNode) => react.CSSProperties;
+/**
+ * Container/section default behavior:
+ * Default height => height: EMPTY_CONTAINER_SIZE
+ * If a container component has children => height: 'fit-content'
+ */
+declare const calculateNodeDefaultHeight: ({ blockId, children, value, }: {
+    blockId?: string;
+    children: ExperienceTreeNode["children"];
+    value: PrimitiveValue;
+}) => string | number | boolean | Record<any, any> | undefined;
+
+type FlattenedDesignTokens = Record<string, string | {
+    width?: string;
+    style?: string;
+    color?: string;
+}>;
+declare const detachExperienceStyles: (experience: Experience) => string | undefined;
+declare const isCfStyleAttribute: (variableName: string) => variableName is keyof StyleProps;
+declare const maybePopulateDesignTokenValue: (variableName: string, variableValue: unknown, mapOfDesignVariableKeys: FlattenedDesignTokens) => unknown;
+declare const resolveBackgroundImageBinding: ({ variableData, getBoundEntityById, dataSource, unboundValues, componentVariablesOverwrites, componentSettings, options, width, }: {
+    variableData: ComponentPropertyValue;
+    getBoundEntityById: (id: string) => Entry$1 | Asset$1 | undefined;
+    unboundValues?: ExperienceUnboundValues;
+    dataSource?: ExperienceDataSource;
+    componentSettings?: ExperienceComponentSettings;
+    componentVariablesOverwrites?: Record<string, ComponentPropertyValue>;
+    options?: BackgroundImageOptions;
+    width?: string;
+}) => any;
+/**
+ * Takes the initial set of properties, filters only design properties that will be mapped to CSS and
+ * re-organizes them to be indexed by breakpoint ID ("breakpoint > variable > value"). It will
+ * also resolve the design/ component values to plain values.
+ *
+ * **Example Input**
+ * ```
+ * variables = {
+ *   cfMargin: { type: 'DesignValue', valuesByBreakpoint: { desktop: '1px', tablet: '2px' } },
+ *   cfPadding: { type: 'DesignValue', valuesByBreakpoint: { desktop: '3px', mobile: '4px' } }
+ * }
+ * ```
+ *
+ * **Example Output**
+ * ```
+ * variableValuesByBreakpoints = {
+ *   desktop: {
+ *     cfMargin: '1px',
+ *     cfPadding: '3px'
+ *   },
+ *   tablet: {
+ *     cfMargin: '2px'
+ *   },
+ *   mobile: {
+ *    cfPadding: '4px'
+ *   }
+ * }
+ * ```
+ *
+ * **Note**
+ * - The property cfBackgroundImageUrl is the only content property that gets mapped to CSS as well.
+ *   It will be solely stored on the default breakpoint.
+ * - For ComponentValues, it will either take the override from the pattern instance or fallback to
+ *   the defaultValue defined in variableDefinitions.
+ */
+declare const indexByBreakpoint: ({ variables, breakpointIds, getBoundEntityById, unboundValues, dataSource, componentVariablesOverwrites, componentSettings, }: {
+    variables: Record<string, ComponentPropertyValue>;
+    breakpointIds: string[];
+    getBoundEntityById: (id: string) => Entry$1 | Asset$1 | undefined;
+    unboundValues?: ExperienceUnboundValues;
+    dataSource?: ExperienceDataSource;
+    componentVariablesOverwrites?: Record<string, ComponentPropertyValue>;
+    componentSettings?: ExperienceComponentSettings;
+}) => Record<string, Record<string, string | number | boolean | Record<any, any>>>;
+/**
+ * Flattens the object from
+ * `{ color: { [key]: [value] } }`
+ * to
+ * `{ 'color.key': [value] }`
+ */
+declare const flattenDesignTokenRegistry: (designTokenRegistry: DesignTokensDefinition) => FlattenedDesignTokens;
+
+/**
+ * Create a single CSS string containing all class definitions for a given media query.
+ *
+ * @param cssByClassName map of class names to CSS strings containing all rules for each class
+ * @param condition e.g. "*", "<520px", ">520px"
+ * @param nextCondition optional next condition to create a disjunct media query that doesn't affect the next breakpoint
+ * @returns joined string of all CSS class definitions wrapped into media queries
+ */
+declare const toMediaQuery: ({ cssByClassName, condition, nextCondition, }: {
+    cssByClassName: Record<string, string>;
+    condition: string;
+    nextCondition?: string;
+}) => string;
+
+/** Turn the visibility value into a style object that can be used for inline styles in React */
+declare const transformVisibility: (value?: boolean) => CSSProperties;
+
+declare const transformBoundContentValue: (variables: ComponentTreeNode["variables"], entityStore: EntityStoreBase, binding: UnresolvedLink<"Entry" | "Asset">, resolveDesignValue: ResolveDesignValueType, variableName: string, variableType: ComponentDefinitionPropertyType, path: string) => BoundComponentPropertyTypes;
+
+type NodeWithChildren<T> = {
+    children: T[];
+};
+declare function treeVisit<T extends NodeWithChildren<T>>(initialNode: T, onNode: (node: T, index: number, depth: number) => void): void;
+/**
+ * Traverses all nodes of a tree and maps all of them.
+ * Intuitively works similarly to Array.map().
+ * When returning mapped object from the mapper function
+ * you _do not_ need to return about `.children[]` field.
+ * This field is automatically managed by the treeMap() function.
+ *
+ * You can map each node to whatever you want, but shouldn't
+ * modify the structure of the tree from the mapping function.
+ */
+declare function treeMap<T extends NodeWithChildren<T>, U>(node: T, onNode: (node: T) => Omit<U, 'children'>): U;
+
+declare const isExperienceEntry: (entry: ExperienceEntry | Entry) => entry is ExperienceEntry;
+declare const isPatternEntry: (entry: Entry | ExperienceEntry) => entry is ExperienceEntry;
+declare const isEntry: (value: unknown) => value is Entry;
+declare const isAsset: (value: unknown) => value is Asset;
+/**
+ * Checks if the values is an array of links.
+ * Note: we use convention where empty arrays are considered valid "arrays of links"
+ * as they don't contradict the type definition.
+ */
+declare const isArrayOfLinks: (value: unknown) => value is Array<UnresolvedLink<"Asset"> | UnresolvedLink<"Entry">>;
+
+declare const getDataFromTree: (tree: ExperienceTree) => {
+    dataSource: ExperienceDataSource;
+    unboundValues: ExperienceUnboundValues;
+};
+declare const generateRandomId: (letterCount: number) => string;
+declare const checkIsAssemblyNode: ({ componentId, usedComponents, }: {
+    componentId: string;
+    usedComponents: ExperienceEntry["fields"]["usedComponents"];
+}) => boolean;
+/**
+ * This check assumes that the entry is already ensured to be an experience, i.e. the
+ * content type of the entry is an experience type with the necessary annotations.
+ **/
+declare const checkIsAssemblyEntry: (entry: Entry) => boolean;
+declare const checkIsAssemblyDefinition: (component?: ComponentDefinition) => boolean;
+interface ParsedValue {
+    value: number;
+    unit: 'px' | 'em' | 'rem';
+}
+declare function parseCSSValue(input: string): ParsedValue | null;
+declare function getTargetValueInPixels(targetWidthObject: ParsedValue): number;
+/**
+ * Creates a component definition for an assembly. As all assemblies use the same definition in the SDK,
+ * all should be registered via this function.
+ */
+declare const createAssemblyDefinition: (definitionId: string) => ComponentDefinition;
+
+declare const doesMismatchMessageSchema: (event: MessageEvent) => false | string;
+declare const tryParseMessage: (event: MessageEvent) => IncomingMessage;
+declare const validateExperienceBuilderConfig: ({ locale, mode, }: {
+    locale: string;
+    mode: StudioCanvasMode;
+}) => void;
+
+/**
+ * Parses experience and extracts all leaf links that are referenced from the experience.
+ * PRECONDITION: Relies on the fact that entityStore is preloaded with all dataSource
+ * entries using include=2 (meaning that up to L3 entries are already preloaded into EntitStore).
+ *
+ * The function iterates over all entries in the entityStore (assuming they can be L1, L2, L3) and
+ * over all of their references. Any references that are NOT available in the entityStore are considered
+ * "leaf references" aka "leaf links" and are returned.
+ *
+ * The EntityStore happens to contain also entities representing patterns, which we do NOT consider
+ * as entries that point to leaf links. So we don't iterate over patterns only over entries which
+ * can be used for binding.
+ */
+declare const extractLeafLinksReferencedFromExperience: (experience: Experience) => {
+    assetLinks: Link<"Asset">[];
+    entryLinks: Link<"Entry">[];
+    assetIds: string[];
+    entryIds: string[];
+};
+
+type FnShouldFollowReferencesOfEntryField = (fieldName: string, entry: Entry) => boolean;
+declare const uniqueById: <T extends {
+    sys: {
+        id: string;
+    };
+}>(arr: Array<T>) => T[];
+/**
+ * Extracts all references from an entry.
+ * Handles both: reference and multi-reference fields.
+ * Returns unique array of references (even if they repeat within the entry).
+ */
+declare const referencesOf: (entry: Entry, fnShouldFollowReferencesOfEntryField?: FnShouldFollowReferencesOfEntryField) => UnresolvedLink<"Asset" | "Entry">[];
+declare function extractReferencesFromEntriesAsIds(entries: Array<Entry>): [string[], string[], string[]];
+declare function extractReferencesFromEntries(entries: Array<Entry>): [UnresolvedLink<'Entry'>[], UnresolvedLink<'Asset'>[], UnresolvedLink<'Entry' | 'Asset'>[]];
+
+declare const splitDirectAndSlotChildren: <T extends ExperienceTreeNode | ComponentTreeNode>(allChildNodes: T[], componentDefinition: ComponentRegistration["definition"]) => {
+    slotNodesMap: Record<string, T[] | null>;
+    directChildNodes: undefined;
+} | {
+    slotNodesMap: Record<string, T[] | null>;
+    directChildNodes: T[];
+};
+
+type PrebindingData = {
+    prebindingDefinitionId: string;
+    parameterIds: Array<string>;
+    nativeParameterId?: string;
+    parameterDefinitions: Record<string, ParameterDefinition>;
+    variableMappings?: Record<string, VariableMapping>;
+};
+declare const flattenNestedPatterns: (fetchedPatterns: Array<ExperienceEntry>) => ExperienceEntry[];
+/**
+ * Given a list of patterns, extract the prebinding data into a more digestable format indexed by the pattern entry id
+ * @param patterns a list of pattern entries
+ * @returns a map of pattern entry ids to their prebinding data
+ */
+declare const extractPrebindingDataByPatternId: (patterns: Array<ExperienceEntry>) => Record<string, PrebindingData>;
+declare const generateDefaultDataSourceForPrebindingDefinition: (prebindingDefinitions?: ExperienceComponentSettings["prebindingDefinitions"]) => {
+    dataSource: Record<string, {
+        sys: {
+            type: "Link";
+            id: string;
+            linkType: "Entry" | "Asset";
+        };
+    }>;
+    parameters: Record<string, {
+        path: string;
+        type: "BoundValue";
+    }>;
+};
+declare function getTargetPatternMappingsForParameter({ fetchedPatterns, prebindingDataByPatternId, patternNodeDefinitionId, parameterId, }: {
+    fetchedPatterns: Array<ExperienceEntry>;
+    prebindingDataByPatternId: Record<string, PrebindingData>;
+    patternNodeDefinitionId: string;
+    parameterId: string;
+}): {
+    [k: string]: {
+        type: "ContentTypeMapping";
+        parameterId: string;
+        pathsByContentType: Record<string, {
+            path: string;
+        }>;
+    };
+} | undefined;
+
+declare const builtInStyles: Partial<DesignVariableMap>;
+declare const optionalBuiltInStyles: Partial<DesignVariableMap>;
+declare const sectionBuiltInStyles: Partial<DesignVariableMap>;
+declare const containerBuiltInStyles: Partial<DesignVariableMap>;
+declare const dividerBuiltInStyles: Partial<DesignVariableMap>;
+declare const singleColumnBuiltInStyles: Partial<DesignVariableMap>;
+declare const columnsBuiltInStyles: Partial<DesignVariableMap>;
+
+declare const sendMessage: SendMessageParams;
+
+declare enum VisualEditorMode {
+    LazyLoad = "lazyLoad",
+    InjectScript = "injectScript"
+}
+
+type FetchBySlugParams = {
+    /** instantiated client from the Contentful SDK */
+    client: ContentfulClientApi<undefined>;
+    /** id of the content type associated with the experience */
+    experienceTypeId: string;
+    /** slug of the experience (defined in entry settings) */
+    slug: string;
+    /** locale code to fetch the experience */
+    localeCode: string;
+    /** if the experience is being loaded in the Contentful Studio editor or not. If true, this function is a noop. */
+    isEditorMode?: boolean;
+};
+/**
+ * Fetches an experience entry by its slug and additionally fetches all its references to return
+ * an initilized experience instance.
+ * @param {FetchBySlugParams} options - options to fetch the experience
+ */
+declare function fetchBySlug({ client, experienceTypeId, slug, localeCode, isEditorMode, }: FetchBySlugParams): Promise<Experience<EntityStore> | undefined>;
+
+type FetchByIdParams = {
+    /** instantiated client from the Contentful SDK */
+    client: ContentfulClientApi<undefined>;
+    /** id of the content type associated with the experience */
+    experienceTypeId: string;
+    /** id of the experience (defined in entry settings) */
+    id: string;
+    /** locale code to fetch the experience */
+    localeCode: string;
+    /** if the experience is being loaded in the Contentful Studio editor or not. If true, this function is a noop. */
+    isEditorMode?: boolean;
+};
+/**
+ * Fetches an experience entry by its id and additionally fetches all its references to return
+ * an initilized experience instance.
+ * @param {FetchByIdParams} options - options to fetch the experience
+ */
+declare function fetchById({ client, experienceTypeId, id, localeCode, isEditorMode, }: FetchByIdParams): Promise<Experience<EntityStore> | undefined>;
+
+type DeepReferenceOpts = {
+    path: string;
+    dataSource: ExperienceDataSource;
+};
+declare class DeepReference {
+    entityId: string;
+    entityLink: DataSourceEntryValueType;
+    field: string;
+    referentField: string;
+    originalPath: string;
+    constructor({ path, dataSource }: DeepReferenceOpts);
+    get headEntityId(): string;
+    /**
+     * Extracts referent from the path, using EntityStore as source of
+     * entities during the resolution path.
+     */
+    extractReferent(entityStore: EntityFromLink): Link<'Asset' | 'Entry'> | undefined;
+    static from(opt: DeepReferenceOpts): DeepReference;
+}
+declare function gatherDeepReferencesFromExperienceEntry(experienceEntry: ExperienceEntry): DeepReference[];
+declare function gatherDeepPrebindingReferencesFromExperienceEntry({ experienceEntry, fetchedPatterns, prebindingDataByPatternId, fetchedLevel1Entries, }: {
+    experienceEntry: ExperienceEntry;
+    fetchedPatterns: Array<ExperienceEntry>;
+    prebindingDataByPatternId: Record<string, PrebindingData>;
+    fetchedLevel1Entries: Array<Entry>;
+}): DeepReference[];
+declare function gatherDeepPrebindingReferencesFromPatternEntry({ patternEntry, fetchedPatterns, prebindingDataByPatternId, fetchedLevel1Entries, }: {
+    patternEntry: ExperienceEntry;
+    fetchedPatterns: Array<ExperienceEntry>;
+    prebindingDataByPatternId: Record<string, PrebindingData>;
+    fetchedLevel1Entries: Array<Entry>;
+}): DeepReference[];
+/**
+ * used in editor mode. for delivery mode see `gatherDeepReferencesFromExperienceEntry`
+ */
+declare function gatherDeepReferencesFromTree(startingNode: ExperienceTreeNode, dataSource: ExperienceDataSource, getEntityFromLink: EntityStoreBase['getEntityFromLink']): DeepReference[];
+
+type MinimalEntryCollection = {
+    items: Entry[];
+    includes: {
+        Entry: Entry[];
+        Asset: Asset[];
+    };
+};
+
+declare const fetchAllEntries: ({ client, ids, locale, skip, limit, responseItems, responseIncludes, }: {
+    client: ContentfulClientApi<undefined> | ContentfulClientApi<"WITH_ALL_LOCALES">;
+    ids: string[];
+    locale?: string;
+    skip?: number;
+    limit?: number;
+    responseItems?: Entry[];
+    responseIncludes?: MinimalEntryCollection["includes"];
+}) => Promise<{
+    items: Entry[];
+    includes: {
+        Entry: Entry[];
+        Asset: Asset[];
+    };
+}>;
+declare const fetchAllAssets: ({ client, ids, locale, skip, limit, responseItems, }: {
+    client: ContentfulClientApi<undefined> | ContentfulClientApi<"WITH_ALL_LOCALES">;
+    ids: string[];
+    locale?: string;
+    skip?: number;
+    limit?: number;
+    responseItems?: Asset[];
+}) => Promise<{
+    items: Asset[];
+}>;
+
+type CreateExperienceParams = {
+    experienceEntry: Entry;
+    referencedEntries: Array<Entry>;
+    referencedAssets: Array<Asset>;
+    locale: string;
+};
+/**
+ * Create an experience instance using a serialized version of the entity store for SSR purposes.
+ * @param {string} json - JSON representation of the experience
+ */
+declare function createExperience(json: string): Experience<EntityStore>;
+/**
+ * Create an experience instance using the already fetched entries and assets.
+ * @param options.experienceEntry - Localized experience entry which will be rendered
+ * @param options.referencedEntries - Array of localized entries which are referenced by the experience entry in its dataSource
+ * @param options.referencedAssets - Array of localized assets which are referenced by the experience entry in its dataSource
+ * @param options.locale - (Soon to be removed unused parameter)
+ */
+declare function createExperience(options: CreateExperienceParams): Experience<EntityStore>;
+
+type ClientAndLocaleParams$1 = {
+    client: ContentfulClientApi<undefined>;
+    locale?: string;
+} | {
+    client: ContentfulClientApi<'WITH_ALL_LOCALES'>;
+    /** When fetching all locales, this may not be defined */
+    locale?: undefined;
+};
+type FetchReferencedEntitiesArgs = {
+    experienceEntry: Entry | ExperienceEntry;
+} & ClientAndLocaleParams$1;
+/**
+ * Fetches all entries and assets from the `dataSource` of the given experience entry. This will
+ * also consider deep references that are not listed explicitly but linked through deep binding paths.
+ * @param options.client - Instantiated client from the Contentful SDK. If this is using the `withAllLocales` modifier, you may not provide a specific locale.
+ * @param options.experienceEntry - Localized experience entry. To localize a multi locale entry, use the `localizeEntity` function.
+ * @param options.locale - Retrieve a specific localized version of the referenced entities. Otherwise, it will fallback to the default locale.
+ * @returns object with a list of `entries` and a list of `assets`
+ */
+declare const fetchReferencedEntities: ({ client, experienceEntry, locale, }: FetchReferencedEntitiesArgs) => Promise<{
+    entries: Entry[];
+    assets: Asset[];
+}>;
+
+type ClientAndLocaleParams = {
+    client: ContentfulClientApi<undefined>;
+    locale?: string;
+} | {
+    client: ContentfulClientApi<'WITH_ALL_LOCALES'>;
+    /** When fetching all locales, this may not be defined */
+    locale?: undefined;
+};
+type FetchExperienceEntryParams = {
+    experienceTypeId: string;
+    identifier: {
+        slug: string;
+    } | {
+        id: string;
+    };
+} & ClientAndLocaleParams;
+/**
+ * Fetches an experience entry by its slug or id. Throws an error if there are multiple
+ * entries with the same slug. Additionally, it resolves all nested pattern entries inside `fields.usedComponents`.
+ * @param options.client - Instantiated client from the Contentful SDK. If this is using the `withAllLocales` modifier, you may not provide a specific locale.
+ * @param options.locale - Provide a locale if your experience contains custom localized fields. Otherwise, it will fallback to the default locale.
+ * @param options.experienceTypeId - id of the content type associated with the experience
+ * @param options.identifier - identifying condition to find the correct experience entry
+ *
+ */
+declare const fetchExperienceEntry: ({ client, experienceTypeId, locale, identifier, }: FetchExperienceEntryParams) => Promise<Entry | undefined>;
+
+declare let designTokensRegistry: DesignTokensDefinition;
+/**
+ * Register design tokens styling
+ * @param designTokenDefinition - {[key:string]: Record<string, string>}
+ * @returns void
+ */
+declare const defineDesignTokens: (designTokenDefinition: DesignTokensDefinition) => void;
+declare const getDesignTokenRegistration: (breakpointValue: string, variableName: string) => string;
+declare const resetDesignTokenRegistry: () => void;
+
+declare const breakpointsRegistry: Breakpoint[];
+/**
+ * Define custom breakpoints that should be used for all your experiences.
+ * A breakpoint consists of:
+ * - id: a unique identifier for this breakpoint
+ * - query: a media query string that defines when this breakpoint is active
+ * - previewSize: an optional fixed preview size to be used in the Studio editor when selecting this breakpoint
+ * - displayName: the name to be displayed in the Studio editor for this breakpoint
+ * - displayIcon: an optional icon to be displayed in the Studio editor for this breakpoint
+ *
+ * The first breakpoint must use a wildcard query (`*`) to match all sizes.
+ *
+ * Every subsequent breakpoint inherits the designs of the previous ones by default.
+ *
+ * The order of breakpoints must be either:
+ * - desktop first: from largest to smallest, using `<` operators
+ * - mobile first: from smallest to largest, using `>` operators
+ *
+ * @note changing breakpoints after you have created experiences may break those experiences
+ * @example
+ * defineBreakpoints([{
+ *    id: 'desktop',
+ *    query: '*',
+ *    displayName: 'Desktop',
+ *    displayIcon: 'desktop',
+ * }, {
+ *    id: 'tablet',
+ *    query: '<992px',
+ *    displayName: 'Tablet',
+ *    displayIcon: 'tablet',
+ * }, {
+ *    id: 'mobile',
+ *    query: '<576px',
+ *    displayName: 'Mobile',
+ *    displayIcon: 'mobile',
+ * }]);
+ */
+declare const defineBreakpoints: (breakpoints: Breakpoint[]) => void;
+declare const runBreakpointsValidation: () => void;
+
+declare const sdkOptionsRegistry: SdkOptions;
+/**
+ * Used inside defineComponents to forward registry arguments to this registry
+ * of SDK options.
+ */
+declare const defineSdkOptions: (options: typeof sdkOptionsRegistry) => void;
+declare const getSdkOptions: () => Readonly<typeof sdkOptionsRegistry>;
+
+export { type AssembliesAddedPayload, type AssembliesRegisteredPayload, BREAKPOINTS_STRATEGY_DESKTOP_FIRST, BREAKPOINTS_STRATEGY_MOBILE_FIRST, type BackgroundImageAlignmentOption, type BackgroundImageOptions, type BackgroundImageScalingOption, type Binding, type BindingMap, type BindingMapByBlockId, type BoundComponentPropertyTypes, type BreakpointsStrategy, type CSSProperties, type CanvasErrorPayload, type CanvasGeometryUpdateSourceEvent, type CanvasReloadPayload, type CanvasResizedPayload, type CanvasScrollPayload, type ComponentBinding, type ComponentDefinition, type ComponentDefinitionVariable, type ComponentDefinitionVariableBase, type ComponentDefinitionVariableTypeMap, type ComponentDefinitionVariableValidation, type ComponentDragCanceledPayload, type ComponentDragEndedPayload, type ComponentDragStartedPayload, type ComponentDraggingChangedPayload, type ComponentDroppedPayload, type ComponentMoveEndedPayload, type ComponentMoveStartedPayload, type ComponentMovedPayload, type ComponentRegistration, type ComponentRegistrationOptions, type ComponentSelectedPayload, type ConnectedPayload, type ContainerStyleVariableName, type Coordinates, type DataSourceEntryValueType, DebugLogger, DeepReference, type DesignTokensDefinition, type DesignTokensPayload, type DesignVariableMap, type DesignVariableTypes, EditorModeEntityStore, type EditorProperties, type EditorPropertyNames, type EntityFromLink, EntityStore, EntityStoreBase, type Experience, type ExperienceEntry, type ExperienceFields, type ExperienceTree, type ExperienceTreeNode, type ExperienceUpdatedPayload, type Fieldset, type FnShouldFollowReferencesOfEntryField, type HoverComponentPayload, type HoveredElement, type ImageLoadingOption, type ImageObjectFitOption, type ImageObjectPositionOption, type ImageOptions, type InMemoryEntitiesPublicApi as InMemoryEntitiesService, type InMemoryEntitiesStore, type IncomingComponentDragCanceledPayload, type IncomingComponentMoveEndedPayload, type IncomingEvent, type IncomingMessage, type IncomingMouseMovePayload, type InternalEvent, type Link, MEDIA_QUERY_REGEXP, type ManagementEntity, type MouseMovePayload, type NewHoveredElementPayload, type OptimizedBackgroundImageAsset, type OptimizedImageAsset, type OutgoingEvent, type OutgoingMessage, type OutsideCanvasClickPayload, type PrebindingData, type PreboundVariable, type RawCoordinates, type RecursiveDesignTokenDefinition, type RegisteredBreakpointsPayload, type RegisteredComponentsPayload, type RequestComponentTreeUpdatePayload, type RequestEditorModePayload, type RequestEntitiesMessage, type RequestEntitiesPayload, type RequestReadOnlyModePayload, type RequestedEntitiesMessage, type RequestedEntitiesPayload, type ResolveDesignValueType, type SDKFeaturesPayload, type ScrollState, type SdkOptions, type SelectComponentPayload, type SendMessageParams, type StyleProps, type UnresolvedFieldset, type UpdateSelectedComponentCoordinatesPayload, type UpdatedEntityPayload, type ValidationOption, type VariableFormats, VisualEditorMode, addLocale, addMinHeightForEmptyStructures, breakpointsRegistry, buildCfStyles, buildStyleTag, buildTemplate, builtInStyles, calculateNodeDefaultHeight, checkIsAssemblyDefinition, checkIsAssemblyEntry, checkIsAssemblyNode, columnsBuiltInStyles, containerBuiltInStyles, createAssemblyDefinition, createExperience, debug, defineBreakpoints, defineDesignTokens, defineSdkOptions, designTokensRegistry, detachExperienceStyles, detectBreakpointsStrategy, disableDebug, dividerBuiltInStyles, doesMismatchMessageSchema, enableDebug, extractLeafLinksReferencedFromExperience, extractPrebindingDataByPatternId, extractReferencesFromEntries, extractReferencesFromEntriesAsIds, fetchAllAssets, fetchAllEntries, fetchById, fetchBySlug, fetchExperienceEntry, fetchReferencedEntities, findOutermostCoordinates, flattenDesignTokenRegistry, flattenNestedPatterns, gatherDeepPrebindingReferencesFromExperienceEntry, gatherDeepPrebindingReferencesFromPatternEntry, gatherDeepReferencesFromExperienceEntry, gatherDeepReferencesFromTree, generateDefaultDataSourceForPrebindingDefinition, generateRandomId, getActiveBreakpointIndex, getDataFromTree, getDesignTokenRegistration, getElementCoordinates, getFallbackBreakpointIndex, getPrebindingPathBySourceEntry, getSdkOptions, getTargetPatternMappingsForParameter, getTargetValueInPixels, getTemplateValue, getValueForBreakpoint, inMemoryEntities, inMemoryEntitiesStore, indexByBreakpoint, isArrayOfLinks, isAsset, isCfStyleAttribute, isComponentAllowedOnRoot, isContentfulComponent, isContentfulStructureComponent, isDeepPath, isDeepPrebinding, isElementHidden, isEntry, isExperienceEntry, isLink, isLinkToAsset, isLinkToEntry, isPatternComponent, isPatternEntry, isPreboundProp, isStructureWithRelativeHeight, isValidBreakpointValue, lastPathNamedSegmentEq, localizeEntity, maybePopulateDesignTokenValue, mediaQueryMatcher, mergeDesignValuesByBreakpoint, optionalBuiltInStyles, parseCSSValue, parseDataSourcePathIntoFieldset, parseDataSourcePathWithL1DeepBindings, referencesOf, resetDesignTokenRegistry, resolveBackgroundImageBinding, resolveHyperlinkPattern, runBreakpointsValidation, sanitizeNodeProps, sdkOptionsRegistry, sectionBuiltInStyles, sendMessage, setDebugLevel, singleColumnBuiltInStyles, splitDirectAndSlotChildren, stringifyCssProperties, toCSSAttribute, toMediaQuery, transformBoundContentValue, transformVisibility, treeMap, treeVisit, tryParseMessage, uniqueById, useInMemoryEntities, validateExperienceBuilderConfig };