@contentful/experiences-core 3.8.2-dev-20251008T0828-a06681d.0 → 3.8.3-beta.0

package/dist/utils/debugLogger.d.ts

@@ -1,36 +0,0 @@
-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;
-
-export { DebugLogger, debug, disableDebug, enableDebug, setDebugLevel };

package/dist/utils/domValues.d.ts

@@ -1,16 +0,0 @@
-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;
-
-export { findOutermostCoordinates, getElementCoordinates, isElementHidden };

package/dist/utils/extractPrebindingData.d.ts

@@ -1,46 +0,0 @@
-import { ExperienceEntry } from '../types.js';
-import { ParameterDefinition, VariableMapping, ExperienceComponentSettings } from '@contentful/experiences-validators';
-
-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;
-
-export { type PrebindingData, extractPrebindingDataByPatternId, flattenNestedPatterns, generateDefaultDataSourceForPrebindingDefinition, getTargetPatternMappingsForParameter };

package/dist/utils/isLink.d.ts

@@ -1,7 +0,0 @@
-import { UnresolvedLink, Entry, Asset } from 'contentful';
-
-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'>;
-
-export { isLink };

package/dist/utils/isLinkToAsset.d.ts

@@ -1,5 +0,0 @@
-import { Link } from '../types.js';
-
-declare const isLinkToAsset: (variable: unknown) => variable is Link<"Asset">;
-
-export { isLinkToAsset };

package/dist/utils/isLinkToEntry.d.ts

@@ -1,5 +0,0 @@
-import { Link } from '../types.js';
-
-declare const isLinkToEntry: (variable: unknown) => variable is Link<"Entry">;
-
-export { isLinkToEntry };

package/dist/utils/localizeEntity.d.ts

@@ -1,24 +0,0 @@
-import { Asset, Entry } from 'contentful';
-
-/**
- * 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;
-
-export { localizeEntity };

package/dist/utils/pathSchema.d.ts

@@ -1,43 +0,0 @@
-import { ComponentPropertyValue, BoundValue } from '@contentful/experiences-validators';
-import { Entry, Asset } from 'contentful';
-
-/**
- * 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;
-
-export { type Fieldset, type PreboundVariable, type UnresolvedFieldset, getPrebindingPathBySourceEntry, isDeepPath, isDeepPrebinding, isPreboundProp, lastPathNamedSegmentEq, parseDataSourcePathIntoFieldset, parseDataSourcePathWithL1DeepBindings };

package/dist/utils/resolveHyperlinkPattern.d.ts

@@ -1,17 +0,0 @@
-import { Entry } from 'contentful';
-
-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;
-
-export { addLocale, buildTemplate, getTemplateValue, resolveHyperlinkPattern };

package/dist/utils/sanitizeNodeProps.d.ts

@@ -1,7 +0,0 @@
-import { PrimitiveValue } from '@contentful/experiences-validators';
-
-declare const sanitizeNodeProps: (nodeProps: Record<PropertyKey, PrimitiveValue>) => {
-    [k: string]: string | number | boolean | Record<any, any> | undefined;
-};
-
-export { sanitizeNodeProps };

package/dist/utils/schema/experienceSchema.d.ts

@@ -1,23 +0,0 @@
-import { Experience, Link } from '../../types.js';
-
-/**
- * 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[];
-};
-
-export { extractLeafLinksReferencedFromExperience };

package/dist/utils/schema/references.d.ts

@@ -1,18 +0,0 @@
-import { Entry, UnresolvedLink } from 'contentful';
-
-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'>[]];
-
-export { type FnShouldFollowReferencesOfEntryField, extractReferencesFromEntries, extractReferencesFromEntriesAsIds, referencesOf, uniqueById };

package/dist/utils/splitDirectAndSlotChildren.d.ts

@@ -1,12 +0,0 @@
-import { ExperienceTreeNode, ComponentRegistration } from '../types.js';
-import { ComponentTreeNode } from '@contentful/experiences-validators';
-
-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[];
-};
-
-export { splitDirectAndSlotChildren };

package/dist/utils/styleUtils/ssrStyles.d.ts

@@ -1,75 +0,0 @@
-import { Entry, Asset } from 'contentful/dist/types/types';
-import { ComponentPropertyValue, ExperienceUnboundValues, ExperienceDataSource, ExperienceComponentSettings } from '@contentful/experiences-validators';
-import { Experience, StyleProps, BackgroundImageOptions, DesignTokensDefinition } from '../../types.js';
-
-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 | Asset | 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 | Asset | 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;
-
-export { detachExperienceStyles, flattenDesignTokenRegistry, indexByBreakpoint, isCfStyleAttribute, maybePopulateDesignTokenValue, resolveBackgroundImageBinding };

package/dist/utils/styleUtils/styleTransformers.d.ts

@@ -1,6 +0,0 @@
-import { CSSProperties } from '../../types.js';
-
-/** Turn the visibility value into a style object that can be used for inline styles in React */
-declare const transformVisibility: (value?: boolean) => CSSProperties;
-
-export { transformVisibility };

package/dist/utils/styleUtils/stylesUtils.d.ts

@@ -1,64 +0,0 @@
-import * as react from 'react';
-import { CSSProperties, StyleProps, ExperienceTreeNode } from '../../types.js';
-import { ComponentTreeNode, PrimitiveValue } from '@contentful/experiences-validators';
-
-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;
-
-export { addMinHeightForEmptyStructures, buildCfStyles, buildStyleTag, calculateNodeDefaultHeight, stringifyCssProperties, toCSSAttribute };

package/dist/utils/styleUtils/toMediaQuery.d.ts

@@ -1,15 +0,0 @@
-/**
- * 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;
-
-export { toMediaQuery };

package/dist/utils/transformers/transformBoundContentValue.d.ts

@@ -1,8 +0,0 @@
-import { ResolveDesignValueType, BoundComponentPropertyTypes } from '../../types.js';
-import { UnresolvedLink } from 'contentful';
-import { EntityStoreBase } from '../../entity/EntityStoreBase.js';
-import { ComponentTreeNode, ComponentDefinitionPropertyType } from '@contentful/experiences-validators';
-
-declare const transformBoundContentValue: (variables: ComponentTreeNode["variables"], entityStore: EntityStoreBase, binding: UnresolvedLink<"Entry" | "Asset">, resolveDesignValue: ResolveDesignValueType, variableName: string, variableType: ComponentDefinitionPropertyType, path: string) => BoundComponentPropertyTypes;
-
-export { transformBoundContentValue };

package/dist/utils/treeTraversal.d.ts

@@ -1,17 +0,0 @@
-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;
-
-export { treeMap, treeVisit };

package/dist/utils/typeguards.d.ts

@@ -1,15 +0,0 @@
-import { ExperienceEntry } from '../types.js';
-import { Entry, Asset, UnresolvedLink } from 'contentful';
-
-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">>;
-
-export { isArrayOfLinks, isAsset, isEntry, isExperienceEntry, isPatternEntry };

package/dist/utils/utils.d.ts

@@ -1,32 +0,0 @@
-import { ExperienceTree, ExperienceEntry, ComponentDefinition } from '../types.js';
-import { Entry } from 'contentful';
-import { ExperienceDataSource, ExperienceUnboundValues } from '@contentful/experiences-validators';
-
-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;
-
-export { checkIsAssemblyDefinition, checkIsAssemblyEntry, checkIsAssemblyNode, createAssemblyDefinition, generateRandomId, getDataFromTree, getTargetValueInPixels, parseCSSValue };

package/dist/utils/validations.d.ts

@@ -1,11 +0,0 @@
-import { IncomingMessage } from '../types.js';
-import { StudioCanvasMode } from '../constants.js';
-
-declare const doesMismatchMessageSchema: (event: MessageEvent) => false | string;
-declare const tryParseMessage: (event: MessageEvent) => IncomingMessage;
-declare const validateExperienceBuilderConfig: ({ locale, mode, }: {
-    locale: string;
-    mode: StudioCanvasMode;
-}) => void;
-
-export { doesMismatchMessageSchema, tryParseMessage, validateExperienceBuilderConfig };