@builder.io/sdk-vue 0.7.1 → 0.7.2

package/vue3/lib/edge/components/block/block.vue.d.ts

@@ -0,0 +1,41 @@
+import type { BuilderContextInterface, RegisteredComponents } from "../../context/types.js";
+import type { BuilderBlock } from "../../types/builder-block.js";
+export type BlockProps = {
+    block: BuilderBlock;
+    context: BuilderContextInterface;
+    registeredComponents: RegisteredComponents;
+};
+declare const _default: import("vue").DefineComponent<Readonly<{
+    block?: any;
+    context?: any;
+    registeredComponents?: any;
+}>, unknown, {
+    childrenContext: any;
+    isEmptyHtmlElement: (tagName: unknown) => boolean;
+}, {
+    blockComponent(): import("../../context/types.js").RegisteredComponent | null | undefined;
+    repeatItem(): import("./types.js").RepeatData[] | undefined;
+    processedBlock(): any;
+    Tag(): any;
+    canShowBlock(): any;
+    childrenWithoutParentComponent(): any;
+    componentRefProps(): {
+        blockChildren: any;
+        componentRef: any;
+        componentOptions: any;
+        context: any;
+        registeredComponents: any;
+        builderBlock: any;
+        includeBlockProps: boolean;
+        isInteractive: boolean;
+    };
+}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    block?: any;
+    context?: any;
+    registeredComponents?: any;
+}>>>, {
+    readonly block?: any;
+    readonly context?: any;
+    readonly registeredComponents?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/block/components/block-styles.vue.d.ts

@@ -0,0 +1,22 @@
+import type { BuilderContextInterface } from "../../../context/types.js";
+import type { BuilderBlock } from "../../../types/builder-block.js";
+export type BlockStylesProps = {
+    block: BuilderBlock;
+    context: BuilderContextInterface;
+};
+declare const _default: import("vue").DefineComponent<Readonly<{
+    block?: any;
+    context?: any;
+}>, unknown, {
+    TARGET: import("../../../types/targets.js").Target;
+}, {
+    canShowBlock(): boolean;
+    css(): string;
+}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    block?: any;
+    context?: any;
+}>>>, {
+    readonly block?: any;
+    readonly context?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/block/components/block-wrapper.vue.d.ts

@@ -0,0 +1,29 @@
+import { getBlockActions } from "../../../functions/get-block-actions.js";
+import { getBlockProperties } from "../../../functions/get-block-properties.js";
+/**
+ * This component renders a block's wrapper HTML element (from the block's `tagName` property).
+ * It reuses the exact same logic as the `InteractiveElement` component, but we need to have 2 separate components for
+ * Svelte's sake, as it needs to know at compile-time whether to use:
+ *  - `<svelte:element>` (for HTML element) or
+ *  - `<svelte:component>` (for custom components)
+ */
+declare const _default: import("vue").DefineComponent<Readonly<{
+    block?: any;
+    context?: any;
+    Wrapper?: any;
+    hasChildren?: any;
+}>, unknown, {
+    getBlockActions: typeof getBlockActions;
+    getBlockProperties: typeof getBlockProperties;
+}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    block?: any;
+    context?: any;
+    Wrapper?: any;
+    hasChildren?: any;
+}>>>, {
+    readonly block?: any;
+    readonly context?: any;
+    readonly Wrapper?: any;
+    readonly hasChildren?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/block/components/component-ref/component-ref.helpers.d.ts

@@ -0,0 +1,30 @@
+import type { BuilderContextInterface, RegisteredComponents } from '../../../../context/types.js';
+import type { BuilderBlock } from '../../../../types/builder-block.js';
+import type { PropsWithBuilderData } from '../../../../types/builder-props.js';
+import type { InteractiveElementProps } from '../interactive-element.vue';
+type ComponentOptions = PropsWithBuilderData<{
+    [index: string]: any;
+    attributes?: {
+        [index: string]: any;
+    };
+}>;
+export interface ComponentProps {
+    componentRef: any;
+    componentOptions: ComponentOptions;
+    blockChildren: BuilderBlock[];
+    context: BuilderContextInterface;
+    registeredComponents: RegisteredComponents;
+    builderBlock: BuilderBlock;
+    includeBlockProps: boolean;
+    isInteractive: boolean | undefined;
+}
+export declare const getWrapperProps: ({ componentOptions, builderBlock, context, componentRef, includeBlockProps, isInteractive, contextValue }: Omit<ComponentProps, "registeredComponents" | "blockChildren"> & {
+    contextValue: BuilderContextInterface;
+}) => InteractiveElementProps | {
+    attributes?: BuilderBlock | {
+        [index: string]: any;
+    } | undefined;
+    builderBlock: BuilderBlock;
+    builderContext: BuilderContextInterface;
+};
+export {};

package/vue3/lib/edge/components/block/components/component-ref/component-ref.vue.d.ts

@@ -0,0 +1,41 @@
+import type { ComponentProps } from "./component-ref.helpers.js";
+declare const _default: import("vue").DefineComponent<Readonly<{
+    context?: any;
+    registeredComponents?: any;
+    blockChildren?: any;
+    componentRef?: any;
+    componentOptions?: any;
+    builderBlock?: any;
+    includeBlockProps?: any;
+    isInteractive?: any;
+}>, unknown, {
+    Wrapper: any;
+    getWrapperProps: ({ componentOptions, builderBlock, context, componentRef, includeBlockProps, isInteractive, contextValue }: Omit<ComponentProps, "registeredComponents" | "blockChildren"> & {
+        contextValue: import("../../../../context/types.js").BuilderContextInterface;
+    }) => import("../interactive-element.vue").InteractiveElementProps | {
+        attributes?: import("../../../../types/builder-block.js").BuilderBlock | {
+            [index: string]: any;
+        } | undefined;
+        builderBlock: import("../../../../types/builder-block.js").BuilderBlock;
+        builderContext: import("../../../../context/types.js").BuilderContextInterface;
+    };
+}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    context?: any;
+    registeredComponents?: any;
+    blockChildren?: any;
+    componentRef?: any;
+    componentOptions?: any;
+    builderBlock?: any;
+    includeBlockProps?: any;
+    isInteractive?: any;
+}>>>, {
+    readonly context?: any;
+    readonly registeredComponents?: any;
+    readonly blockChildren?: any;
+    readonly componentRef?: any;
+    readonly componentOptions?: any;
+    readonly builderBlock?: any;
+    readonly includeBlockProps?: any;
+    readonly isInteractive?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/block/components/interactive-element.vue.d.ts

@@ -0,0 +1,30 @@
+import type { BuilderContextInterface } from "../../../context/types.js";
+import { getBlockActions } from "../../../functions/get-block-actions.js";
+import { getBlockProperties } from "../../../functions/get-block-properties.js";
+import type { BuilderBlock } from "../../../types/builder-block.js";
+export type InteractiveElementProps = {
+    Wrapper: any;
+    block: BuilderBlock;
+    context: BuilderContextInterface;
+    wrapperProps: object;
+};
+declare const _default: import("vue").DefineComponent<Readonly<{
+    block?: any;
+    context?: any;
+    wrapperProps?: any;
+    Wrapper?: any;
+}>, unknown, {
+    getBlockActions: typeof getBlockActions;
+    getBlockProperties: typeof getBlockProperties;
+}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    block?: any;
+    context?: any;
+    wrapperProps?: any;
+    Wrapper?: any;
+}>>>, {
+    readonly block?: any;
+    readonly context?: any;
+    readonly wrapperProps?: any;
+    readonly Wrapper?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/block/components/repeated-block.vue.d.ts

@@ -0,0 +1,16 @@
+declare const _default: import("vue").DefineComponent<Readonly<{
+    block?: any;
+    registeredComponents?: any;
+    repeatContext?: any;
+}>, unknown, {
+    store: any;
+}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    block?: any;
+    registeredComponents?: any;
+    repeatContext?: any;
+}>>>, {
+    readonly block?: any;
+    readonly registeredComponents?: any;
+    readonly repeatContext?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/block/types.d.ts

@@ -0,0 +1,6 @@
+import type { BuilderContextInterface } from '../../context/types.js';
+import type { BuilderBlock } from '../../types/builder-block.js';
+export interface RepeatData {
+    block: BuilderBlock;
+    context: BuilderContextInterface;
+}

package/vue3/lib/edge/components/blocks/blocks-wrapper.vue.d.ts

@@ -0,0 +1,30 @@
+import type { BuilderBlock } from "../../types/builder-block.js";
+export type BlocksWrapperProps = {
+    blocks: BuilderBlock[] | undefined;
+    parent: string | undefined;
+    path: string | undefined;
+    styleProp: Record<string, any> | undefined;
+};
+declare const _default: import("vue").DefineComponent<Readonly<{
+    path?: any;
+    blocks?: any;
+    parent?: any;
+    styleProp?: any;
+}>, unknown, unknown, {
+    className(): string;
+}, {
+    onClick(): void;
+    onMouseEnter(): void;
+    _classStringToObject(str: string): Record<string, boolean>;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    path?: any;
+    blocks?: any;
+    parent?: any;
+    styleProp?: any;
+}>>>, {
+    readonly path?: any;
+    readonly blocks?: any;
+    readonly parent?: any;
+    readonly styleProp?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/blocks/blocks.vue.d.ts

@@ -0,0 +1,29 @@
+import type { BuilderContextInterface, RegisteredComponents } from "../../context/types.js";
+import type { BlocksWrapperProps } from "./blocks-wrapper.vue";
+export type BlocksProps = Partial<BlocksWrapperProps> & {
+    context?: BuilderContextInterface;
+    registeredComponents?: RegisteredComponents;
+};
+declare const _default: import("vue").DefineComponent<Readonly<{
+    path?: any;
+    blocks?: any;
+    context?: any;
+    registeredComponents?: any;
+    parent?: any;
+    styleProp?: any;
+}>, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    path?: any;
+    blocks?: any;
+    context?: any;
+    registeredComponents?: any;
+    parent?: any;
+    styleProp?: any;
+}>>>, {
+    readonly path?: any;
+    readonly blocks?: any;
+    readonly context?: any;
+    readonly registeredComponents?: any;
+    readonly parent?: any;
+    readonly styleProp?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/content/components/enable-editor.vue.d.ts

@@ -0,0 +1,91 @@
+import type { BuilderContent } from "../../../types/builder-content.js";
+declare const _default: import("vue").DefineComponent<Readonly<{
+    content?: any;
+    context?: any;
+    apiKey?: any;
+    canTrack?: any;
+    builderContextSignal?: any;
+    model?: any;
+    locale?: any;
+    includeRefs?: any;
+    enrich?: any;
+    showContent?: any;
+    classNameProp?: any;
+}>, unknown, {
+    forceReRenderCount: number;
+    lastUpdated: number;
+    shouldSendResetCookie: boolean;
+    httpReqsData: {};
+    clicked: boolean;
+    builderContext: {
+        Builder: {
+            content: null;
+            context: {};
+            localState: undefined;
+            rootSetState(): void;
+            rootState: {};
+            apiKey: null;
+            apiVersion: undefined;
+            componentInfos: {};
+            inheritedStyles: {};
+        };
+        key: symbol;
+    };
+}, {
+    onUpdateHook0(): {
+        0: any;
+    };
+    onUpdateHook1(): {
+        0: boolean;
+    };
+    onUpdateHook2(): {
+        0: any;
+        1: any;
+    };
+    onUpdateHook3(): {
+        0: any;
+    };
+    onUpdateHook4(): {
+        0: any;
+    };
+}, {
+    mergeNewContent(newContent: BuilderContent): void;
+    processMessage(event: MessageEvent): void;
+    evaluateJsCode(): void;
+    onClick(event: any): void;
+    evalExpression(expression: string): string;
+    handleRequest({ url, key }: {
+        key: string;
+        url: string;
+    }): void;
+    runHttpRequests(): void;
+    emitStateUpdate(): void;
+    elementRef_onIniteditingbldr(event: any): void;
+    elementRef_onInitpreviewingbldr(event: any): void;
+    _classStringToObject(str: string): Record<string, boolean>;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    content?: any;
+    context?: any;
+    apiKey?: any;
+    canTrack?: any;
+    builderContextSignal?: any;
+    model?: any;
+    locale?: any;
+    includeRefs?: any;
+    enrich?: any;
+    showContent?: any;
+    classNameProp?: any;
+}>>>, {
+    readonly content?: any;
+    readonly context?: any;
+    readonly apiKey?: any;
+    readonly canTrack?: any;
+    readonly builderContextSignal?: any;
+    readonly model?: any;
+    readonly locale?: any;
+    readonly includeRefs?: any;
+    readonly enrich?: any;
+    readonly showContent?: any;
+    readonly classNameProp?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/content/components/styles.helpers.d.ts

@@ -0,0 +1,15 @@
+export interface CustomFont {
+    family?: string;
+    kind?: string;
+    fileUrl?: string;
+    files?: {
+        [key: string]: string;
+    };
+}
+export declare const getFontCss: ({ customFonts }: {
+    customFonts?: CustomFont[] | undefined;
+}) => string;
+export declare const getCss: ({ cssCode, contentId }: {
+    cssCode?: string | undefined;
+    contentId?: string | undefined;
+}) => string;

package/vue3/lib/edge/components/content/components/styles.vue.d.ts

@@ -0,0 +1,16 @@
+declare const _default: import("vue").DefineComponent<Readonly<{
+    contentId?: any;
+    cssCode?: any;
+    customFonts?: any;
+}>, unknown, {
+    injectedStyles: string;
+}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    contentId?: any;
+    cssCode?: any;
+    customFonts?: any;
+}>>>, {
+    readonly contentId?: any;
+    readonly cssCode?: any;
+    readonly customFonts?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/content/content.helpers.d.ts

@@ -0,0 +1,7 @@
+import type { BuilderContent } from '../../types/builder-content.js';
+import type { Nullable } from '../../types/typescript.js';
+import type { ContentProps } from './content.types.js';
+export declare const getContextStateInitialValue: ({ content, data, locale }: Pick<ContentProps, 'content' | 'data' | 'locale'>) => {
+    [x: string]: unknown;
+};
+export declare const getContentInitialValue: ({ content, data }: Pick<ContentProps, 'content' | 'data'>) => Nullable<BuilderContent>;

package/vue3/lib/edge/components/content/content.types.d.ts

@@ -0,0 +1,24 @@
+import type { BuilderRenderState } from '../../context/types.js';
+import type { EnforcePartials } from '../../types/enforced-partials.js';
+import type { ContentVariantsPrps } from '../content-variants/content-variants.types.js';
+interface InternalRenderProps {
+    /**
+     * TO-DO: improve qwik generator to not remap this name for non-HTML tags, then name it `className`
+     */
+    classNameProp: string | undefined;
+    showContent: boolean;
+    isSsrAbTest: boolean;
+}
+export type ContentProps = InternalRenderProps & EnforcePartials<ContentVariantsPrps>;
+export interface BuilderComponentStateChange {
+    state: BuilderRenderState;
+    ref: {
+        name?: string;
+        props?: {
+            builderBlock?: {
+                id?: string;
+            };
+        };
+    };
+}
+export {};

package/vue3/lib/edge/components/content/content.vue.d.ts

@@ -0,0 +1,69 @@
+import type { BuilderRenderState, RegisteredComponents } from "../../context/types.js";
+import type { ComponentInfo } from "../../types/components.js";
+import type { Dictionary } from "../../types/typescript.js";
+declare const _default: import("vue").DefineComponent<Readonly<{
+    data?: any;
+    content?: any;
+    context?: any;
+    apiKey?: any;
+    apiVersion?: any;
+    canTrack?: any;
+    model?: any;
+    locale?: any;
+    includeRefs?: any;
+    enrich?: any;
+    showContent?: any;
+    classNameProp?: any;
+    customComponents?: any;
+    isSsrAbTest?: any;
+}>, unknown, {
+    scriptStr: string;
+    registeredComponents: RegisteredComponents;
+    builderContextSignal: {
+        content: import("../../types/typescript.js").Nullable<import("../../types/builder-content.js").BuilderContent>;
+        localState: undefined;
+        rootState: {
+            [x: string]: unknown;
+        };
+        rootSetState: Function;
+        context: any;
+        apiKey: any;
+        apiVersion: any;
+        componentInfos: Dictionary<ComponentInfo>;
+        inheritedStyles: {};
+    };
+    TARGET: import("../../types/targets.js").Target;
+}, {}, {
+    contentSetState(newRootState: BuilderRenderState): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    data?: any;
+    content?: any;
+    context?: any;
+    apiKey?: any;
+    apiVersion?: any;
+    canTrack?: any;
+    model?: any;
+    locale?: any;
+    includeRefs?: any;
+    enrich?: any;
+    showContent?: any;
+    classNameProp?: any;
+    customComponents?: any;
+    isSsrAbTest?: any;
+}>>>, {
+    readonly data?: any;
+    readonly content?: any;
+    readonly context?: any;
+    readonly apiKey?: any;
+    readonly apiVersion?: any;
+    readonly canTrack?: any;
+    readonly model?: any;
+    readonly locale?: any;
+    readonly includeRefs?: any;
+    readonly enrich?: any;
+    readonly showContent?: any;
+    readonly classNameProp?: any;
+    readonly customComponents?: any;
+    readonly isSsrAbTest?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/content/index.d.ts

@@ -0,0 +1 @@
+export { default } from './content.vue';

package/vue3/lib/edge/components/content/wrap-component-ref.d.ts

@@ -0,0 +1,6 @@
+import { markRaw } from 'vue';
+/**
+ * Wrap a component ref to prevent it from being observed by Vue.
+ * This reduces overhead and improves performance.
+ */
+export declare const wrapComponentRef: typeof markRaw;

package/vue3/lib/edge/components/content-variants/content-variants.types.d.ts

@@ -0,0 +1,20 @@
+import type { BuilderRenderContext, RegisteredComponent } from '../../context/types.js';
+import type { ApiVersion } from '../../types/api-version.js';
+import type { BuilderContent } from '../../types/builder-content.js';
+import type { Nullable } from '../../types/typescript.js';
+export interface ContentVariantsPrps {
+    content?: Nullable<BuilderContent>;
+    model?: string;
+    data?: {
+        [key: string]: any;
+    };
+    context?: BuilderRenderContext;
+    apiKey: string;
+    apiVersion?: ApiVersion;
+    customComponents?: RegisteredComponent[];
+    canTrack?: boolean;
+    locale?: string;
+    /** @deprecated use `enrich` instead **/
+    includeRefs?: boolean;
+    enrich?: boolean;
+}

package/vue3/lib/edge/components/content-variants/content-variants.vue.d.ts

@@ -0,0 +1,75 @@
+declare const _default: import("vue").DefineComponent<Readonly<{
+    data?: any;
+    content?: any;
+    context?: any;
+    apiKey?: any;
+    apiVersion?: any;
+    canTrack?: any;
+    model?: any;
+    locale?: any;
+    includeRefs?: any;
+    enrich?: any;
+    customComponents?: any;
+    __isNestedRender?: any;
+}>, unknown, {
+    shouldRenderVariants: boolean;
+    TARGET: import("../../types/targets.js").Target;
+    getScriptString: () => string;
+    getVariants: (content: import("../../helpers/nullable.js").Nullable<import("../../types/builder-content.js").BuilderContent>) => {
+        testVariationId: string | undefined;
+        id: string | undefined;
+        data?: {
+            [key: string]: any;
+            title?: string | undefined;
+            blocks?: import("../../types/builder-block.js").BuilderBlock[] | undefined;
+            inputs?: import("../../types/input.js").Input[] | undefined;
+            state?: {
+                [key: string]: any;
+            } | undefined;
+            jsCode?: string | undefined;
+            tsCode?: string | undefined;
+            httpRequests?: {
+                [key: string]: string;
+            } | undefined;
+        } | undefined;
+        name?: string | undefined;
+        testRatio?: number | undefined;
+        meta?: {
+            [key: string]: any;
+            breakpoints?: import("../../types/typescript.js").Nullable<import("../../types/builder-content.js").Breakpoints>;
+        } | undefined; /**
+         * For internal use only. Do not provide this prop.
+         */
+    }[];
+}, {
+    variantScriptStr(): string;
+    hideVariantsStyleString(): string;
+    defaultContent(): any;
+}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Readonly<{
+    data?: any;
+    content?: any;
+    context?: any;
+    apiKey?: any;
+    apiVersion?: any;
+    canTrack?: any;
+    model?: any;
+    locale?: any;
+    includeRefs?: any;
+    enrich?: any;
+    customComponents?: any;
+    __isNestedRender?: any;
+}>>>, {
+    readonly data?: any;
+    readonly content?: any;
+    readonly context?: any;
+    readonly apiKey?: any;
+    readonly apiVersion?: any;
+    readonly canTrack?: any;
+    readonly model?: any;
+    readonly locale?: any;
+    readonly includeRefs?: any;
+    readonly enrich?: any;
+    readonly customComponents?: any;
+    readonly __isNestedRender?: any;
+}, {}>;
+export default _default;

package/vue3/lib/edge/components/content-variants/helpers.d.ts

@@ -0,0 +1,41 @@
+import type { Nullable } from '../../helpers/nullable.js';
+import type { BuilderContent } from '../../types/builder-content.js';
+export declare const getVariants: (content: Nullable<BuilderContent>) => {
+    testVariationId: string | undefined;
+    id: string | undefined;
+    data?: {
+        [key: string]: any;
+        title?: string | undefined;
+        blocks?: import("../../types/builder-block.js").BuilderBlock[] | undefined;
+        inputs?: import("../../types/input.js").Input[] | undefined;
+        state?: {
+            [key: string]: any;
+        } | undefined;
+        jsCode?: string | undefined;
+        tsCode?: string | undefined;
+        httpRequests?: {
+            [key: string]: string;
+        } | undefined;
+    } | undefined;
+    name?: string | undefined;
+    testRatio?: number | undefined;
+    meta?: {
+        [key: string]: any;
+        breakpoints?: import("../../types/typescript.js").Nullable<import("../../types/builder-content.js").Breakpoints>;
+    } | undefined;
+}[];
+export declare const checkShouldRunVariants: ({ canTrack, content }: {
+    canTrack: Nullable<boolean>;
+    content: Nullable<BuilderContent>;
+}) => boolean;
+type VariantData = {
+    id: string;
+    testRatio?: number;
+};
+export declare const getScriptString: () => string;
+export declare const getVariantsScriptString: (variants: VariantData[], contentId: string) => string;
+export declare const getRenderContentScriptString: ({ contentId, variationId }: {
+    variationId: string;
+    contentId: string;
+}) => string;
+export {};