unlayer-types 0.0.0-dev-af8b1296

package/embed.d.ts

@@ -0,0 +1,3539 @@
+declare module "engine/config/editorSettings" {
+    export interface EditorSettings {
+        minHeaders?: number;
+        maxHeaders?: number;
+        minFooters?: number;
+        maxFooters?: number;
+        minRows?: number;
+        maxRows?: number;
+        contentType?: 'page' | 'block';
+        autoSelectOnDrop: boolean;
+        columns?: boolean;
+        confirmOnDelete?: boolean;
+        title?: string;
+    }
+    export function overrideEditorSettings(editorSettingsOverrides: EditorSettings): void;
+    export function getEditorSettings(): EditorSettings;
+}
+declare module "editor/components/editors/types" {
+    import { IconDefinition } from '@fortawesome/pro-regular-svg-icons';
+    import { AppearanceConfig, Device, DisplayMode, Location, UndoRedoBehavior, Variant } from "state/types/types";
+    export type LoadingState = 'not-loaded' | 'loading' | 'loaded' | 'error';
+    export type UpdatingState = 'updating' | undefined;
+    export type DeletionState = 'deleting' | 'failed' | undefined;
+    export interface EditorProps<Value, WidgetParams = object> {
+        value: Value | undefined;
+        defaultValue: Value | undefined;
+        updateValue: (newValue: Value | undefined, data?: object, options?: {
+            deviceOverride?: Device;
+            undoRedoBehavior?: UndoRedoBehavior;
+        }) => void;
+        name: string;
+        /** @deprecated Use widgetParams instead */
+        data?: WidgetParams;
+        disabled?: boolean;
+        isLocked?: boolean;
+        lockReason?: 'styleguide' | 'admin' | undefined;
+        widgetParams?: WidgetParams;
+        deviceName: Device;
+        displayMode: DisplayMode;
+        label?: string;
+        location: Location;
+        values: {
+            [key: string]: unknown;
+            containerPadding?: string;
+        };
+        rootValues: {
+            [key: string]: any;
+            _override?: {
+                [key: string]: any;
+            };
+        };
+        appearance: AppearanceConfig;
+        entitlements: {
+            audit?: boolean;
+            allowedDomains?: number;
+            branding?: boolean;
+            collaboration?: boolean;
+            displayConditions?: boolean;
+            customBlocks?: number;
+            customCSS?: boolean;
+            customFonts?: boolean;
+            customJS?: boolean;
+            customTools?: number;
+            customTabs?: number;
+            customThemes?: boolean;
+            imageEditor?: boolean;
+            selectImage?: boolean;
+            stockImages?: boolean;
+            userUploads?: boolean;
+            uploadMaxSize?: number;
+        };
+        item: {
+            id: string;
+            type?: string;
+            slug?: string;
+            location?: Location;
+            values?: Record<string, any>;
+        };
+        project: object;
+        onImageClick?: (url: string) => void;
+    }
+    export type HeadArguments = [
+        Record<string, any>,
+        Record<string, any>,
+        {
+            rowIndex: number | undefined;
+            rowCells: number[] | undefined;
+            rowValues: Record<string, any> | undefined;
+            columnIndex: number | undefined;
+            columnValues: Record<string, any> | undefined;
+            bodyValues: Record<string, any> | undefined;
+            displayMode: DisplayMode;
+            embeddedValues: Record<string, any>;
+            isViewer: boolean;
+            variant: Variant;
+            type?: string;
+        }
+    ];
+    export interface Head {
+        css?: (...args: HeadArguments) => string | void;
+        js?: (...args: HeadArguments) => string | void;
+        tags?: (...args: HeadArguments) => string[] | void;
+    }
+    export type CollaborationFilter = 'only_yours' | 'resolved';
+    export interface CollaborationFilterDetails {
+        label?: string;
+    }
+    export type CollaborationType = 'feedback' | 'idea' | 'question' | 'urgent';
+    export interface CollaborationTypeDetails {
+        label?: string;
+        icon: IconDefinition;
+        color: string | undefined;
+    }
+    export type CollaborationThreadStatus = 'open' | 'resolved';
+    export interface CollaborationThread {
+        id: number;
+        projectId: string | number;
+        designId: string;
+        user: CollaborationUser;
+        itemId: string;
+        type: CollaborationType;
+        status: CollaborationThreadStatus | null | undefined;
+        commentCount: number;
+        firstComment: CollaborationThreadComment;
+        createdAt: string;
+        updatedAt: string;
+    }
+    export interface CollaborationThreadComment {
+        id: number;
+        threadId: CollaborationThread['id'];
+        user: CollaborationUser;
+        text: string;
+        createdAt: string;
+        updatedAt: string;
+    }
+    export interface CollaborationUser {
+        id: string;
+        name: string | undefined;
+        avatar: string | undefined;
+    }
+    export type DeepPartial<T> = T extends object ? {
+        [P in keyof T]?: DeepPartial<T[P]>;
+    } : T;
+    export type LanguageOverride = {
+        [language: string]: {
+            [propertyName: string]: string;
+        };
+    };
+    export type LanguagesValue = {
+        _languages?: LanguageOverride;
+    };
+}
+declare module "state/types/RootState" {
+    import { StateType } from 'typesafe-actions';
+    import reducer from '../reducer';
+    export type RootState = StateType<typeof reducer>;
+}
+declare module "editor/themes/types" {
+    import { AppearanceConfig } from "state/types/types";
+    import { DeepPartial } from "editor/components/editors/types";
+    export type ThemeName = 'classic_light' | 'classic_dark' | 'modern_light' | 'modern_dark';
+    export type ThemeNamePlusLightDark = ThemeName | 'light' | 'dark';
+    export type Theme = {
+        name: ThemeName;
+        isCustom?: boolean;
+        isDark: boolean;
+        isClassic?: boolean;
+        mapping: {
+            [key: string]: Record<string, string>;
+            borderRadius: Record<BorderRadius, string>;
+            colors: Record<ThemeColor, string>;
+        };
+        components: {
+            textEditor: {
+                toolbar: {
+                    backgroundColor: ColorValue;
+                    borderColor: ColorValue;
+                    separatorColor: ColorValue;
+                    button: {
+                        backgroundColor: ColorValue;
+                        textColor: ColorValue;
+                        borderColor: ColorValue;
+                        ':hover'?: {
+                            backgroundColor?: ColorValue;
+                            textColor?: ColorValue;
+                            borderColor?: ColorValue;
+                        };
+                        ':active'?: {
+                            backgroundColor: ColorValue;
+                            textColor?: ColorValue;
+                            borderColor?: ColorValue;
+                        };
+                    };
+                };
+            };
+            actionBar?: (Partial<Theme['components']['bar']> & {
+                compact?: boolean;
+                defaultPlacement: NonNullable<AppearanceConfig['actionBar']>['placement'];
+            }) | undefined;
+            shimmerLoader: {
+                fromColor: ColorValue;
+                toColor: ColorValue;
+            };
+            audit: {
+                error: {
+                    backgroundColor: ColorValue;
+                    textColor: ColorValue;
+                    iconColor: ColorValue;
+                    borderColor: ColorValue;
+                    borderRadius: BorderRadiusValue;
+                    ':hover': {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                        iconColor?: ColorValue;
+                        borderColor?: ColorValue;
+                    };
+                };
+            };
+            bannerMessage: Record<BannerMessageVariant, {
+                backgroundColor: ColorValue;
+                textColor: ColorValue;
+                borderColor: ColorValue;
+                iconColor: ColorValue;
+            }> & {
+                borderRadius: BorderRadiusValue;
+            };
+            bar: {
+                backgroundColor: ColorValue;
+                textColor?: ColorValue;
+                borderColor?: ColorValue;
+                borderRadius?: BorderRadiusValue;
+                button: {
+                    backgroundColor: ColorValue;
+                    textColor?: ColorValue;
+                    borderColor?: ColorValue;
+                    borderRadius?: BorderRadiusValue;
+                    disabledTextColor?: string;
+                    ':hover': {
+                        backgroundColor: ColorValue;
+                        textColor?: ColorValue;
+                        borderColor?: ColorValue;
+                    };
+                    ':pressed': {
+                        backgroundColor: ColorValue;
+                        textColor?: ColorValue;
+                        borderColor?: ColorValue;
+                    };
+                    ':selected': {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                        borderColor?: ColorValue;
+                    };
+                    ':highlighted': {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                        borderColor?: ColorValue;
+                    };
+                    ':destructive': {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                    };
+                };
+                dropdown: {
+                    item: {
+                        backgroundColor: ColorValue | undefined;
+                        textColor: ColorValue | undefined;
+                        ':selected'?: {
+                            textColor?: ColorValue;
+                        };
+                    };
+                };
+                separator: {
+                    borderColor?: ColorValue;
+                };
+            };
+            badge: {
+                backgroundColor: ColorValue;
+                textColor?: ColorValue;
+                borderColor?: ColorValue;
+                borderRadius?: BorderRadiusValue;
+            };
+            buttons: Record<ThemeVariant, ButtonThemeObject & {
+                ':hover': Partial<ButtonThemeObject>;
+                ':pressed': Partial<ButtonThemeObject>;
+            }>;
+            checkbox: {
+                backgroundColor: ColorValue;
+                borderColor: ColorValue;
+                borderRadius: BorderRadiusValue;
+                checkColor?: ColorValue;
+                label: {
+                    textColor?: ColorValue;
+                };
+                ':checked': {
+                    backgroundColor: ColorValue;
+                    borderColor?: ColorValue;
+                    borderRadius?: BorderRadiusValue;
+                    checkColor?: ColorValue;
+                    label?: {
+                        textColor?: ColorValue;
+                    };
+                };
+            };
+            counter: {
+                button?: Theme['components']['buttons']['secondary'];
+                dropdown?: Partial<Theme['components']['dropdown']>;
+                input?: Theme['components']['input'];
+            };
+            dropdown: {
+                button: {
+                    backgroundColor: ColorValue;
+                    borderColor: ColorValue;
+                    borderRadius: BorderRadiusValue;
+                    textColor: ColorValue;
+                    ':disabled'?: {
+                        backgroundColor?: ColorValue;
+                        borderColor?: ColorValue;
+                        textColor?: ColorValue;
+                    };
+                    ':hover'?: {
+                        backgroundColor?: ColorValue;
+                        borderColor?: ColorValue;
+                        textColor?: ColorValue;
+                    };
+                    ':open'?: {
+                        backgroundColor?: ColorValue;
+                        borderColor?: ColorValue;
+                        borderRadius?: BorderRadiusValue;
+                        textColor?: ColorValue;
+                    };
+                };
+                popover: {
+                    backgroundColor: ColorValue;
+                    borderColor: ColorValue;
+                    boxShadowColor?: ColorValue;
+                    borderRadius: BorderRadiusValue;
+                    textColor: ColorValue;
+                };
+                item: {
+                    backgroundColor: ColorValue;
+                    textColor: ColorValue;
+                    ':hover'?: {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                    };
+                    ':selected'?: {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                    };
+                    ':highlighted'?: {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                    };
+                };
+                separator: {
+                    borderColor?: ColorValue;
+                };
+            };
+            input: {
+                backgroundColor?: ColorValue;
+                borderColor?: ColorValue;
+                borderRadius?: BorderRadiusValue;
+                textColor?: ColorValue;
+                placeholderColor?: ColorValue;
+                label?: {
+                    textColor?: ColorValue;
+                    backgroundColor?: ColorValue;
+                    borderColor?: ColorValue;
+                };
+                messages?: Record<'default' | 'info' | 'warning' | 'error' | 'success', {
+                    textColor: ColorValue;
+                }>;
+                ':hover'?: {
+                    backgroundColor?: ColorValue;
+                    borderColor?: ColorValue;
+                    borderRadius?: BorderRadiusValue;
+                    textColor?: ColorValue;
+                    placeholderColor?: ColorValue;
+                };
+                ':active'?: {
+                    backgroundColor?: ColorValue;
+                    borderColor?: ColorValue;
+                    borderRadius?: BorderRadiusValue;
+                    textColor?: ColorValue;
+                    placeholderColor?: ColorValue;
+                };
+                ':disabled'?: {
+                    backgroundColor?: ColorValue;
+                    borderColor?: ColorValue;
+                    textColor?: ColorValue;
+                    label?: {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                    };
+                };
+            };
+            previewBar?: Partial<Theme['components']['bar']> | undefined;
+            accordion: {
+                syncedBlocks: {
+                    backgroundColor: ColorValue;
+                    borderRadius: BorderRadiusValue;
+                    header: {
+                        backgroundColor: ColorValue;
+                        textColor: ColorValue;
+                        buttonColor: ColorValue;
+                        ':hover': {
+                            backgroundColor: ColorValue;
+                        };
+                    };
+                    content: {
+                        backgroundColor: ColorValue;
+                        textColor: ColorValue;
+                    };
+                    icon: {
+                        color: ColorValue;
+                    };
+                    title: {
+                        color: ColorValue;
+                    };
+                    subtext: {
+                        color: ColorValue;
+                    };
+                    dialog: {
+                        backgroundColor: ColorValue;
+                        overlayColor: ColorValue;
+                        borderRadius: BorderRadiusValue;
+                    };
+                    ':closed': {
+                        header: {
+                            backgroundColor: ColorValue;
+                            textColor: ColorValue;
+                            buttonColor: ColorValue;
+                        };
+                    };
+                };
+                backgroundColor: ColorValue;
+                borderColor: ColorValue;
+                header: {
+                    backgroundColor?: ColorValue;
+                    textColor?: ColorValue;
+                    buttonColor?: ColorValue;
+                    rightLabel: {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                    };
+                    ':hover'?: {
+                        backgroundColor?: ColorValue;
+                    };
+                };
+                content: {
+                    backgroundColor?: ColorValue;
+                    textColor?: ColorValue;
+                };
+                ':closed': {
+                    borderColor?: ColorValue;
+                    header?: {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                        buttonColor?: ColorValue;
+                    };
+                };
+                ai?: {
+                    backgroundColor?: ColorValue;
+                    header?: {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                        aiIconColor?: ColorValue;
+                        ':hover'?: {
+                            backgroundColor?: ColorValue;
+                        };
+                    };
+                    content?: {
+                        backgroundColor?: ColorValue;
+                        textColor?: ColorValue;
+                    };
+                    ':closed'?: {
+                        borderColor?: ColorValue;
+                        header?: {
+                            backgroundColor?: ColorValue;
+                            textColor?: ColorValue;
+                        };
+                    };
+                };
+            };
+            popover: {
+                backgroundColor: ColorValue;
+                textColor?: ColorValue;
+                borderColor?: ColorValue;
+                borderRadius?: BorderRadiusValue;
+                padding?: string;
+                offset?: number;
+                arrow?: {
+                    enabled?: boolean;
+                };
+            };
+            radio: {
+                backgroundColor: ColorValue;
+                borderColor: ColorValue;
+                thumbColor?: ColorValue;
+                label: {
+                    textColor?: ColorValue;
+                };
+                ':checked': {
+                    backgroundColor: ColorValue;
+                    borderColor?: ColorValue;
+                    thumbColor?: ColorValue;
+                    label?: {
+                        textColor?: ColorValue;
+                    };
+                };
+            };
+            segmentedControl: {
+                borderRadius: BorderRadiusValue;
+                item: {
+                    backgroundColor: ColorValue;
+                    textColor: ColorValue;
+                    borderColor: ColorValue;
+                    ':hover': {
+                        backgroundColor: ColorValue;
+                        textColor: ColorValue;
+                        borderColor: ColorValue;
+                    };
+                    ':pressed': {
+                        backgroundColor: ColorValue;
+                        textColor: ColorValue;
+                        borderColor: ColorValue;
+                    };
+                    ':selected': {
+                        backgroundColor: ColorValue;
+                        textColor: ColorValue;
+                        borderColor: ColorValue;
+                    };
+                };
+            };
+            tabs: {
+                backgroundColor: ColorValue;
+                borderRadius: BorderRadiusValue;
+                tab: {
+                    backgroundColor: ColorValue;
+                    textColor: ColorValue;
+                    borderColor: ColorValue;
+                    borderRadius: BorderRadiusValue;
+                    ':hover': {
+                        backgroundColor: ColorValue;
+                        textColor: ColorValue;
+                        borderColor: ColorValue;
+                    };
+                    ':pressed': {
+                        backgroundColor: ColorValue;
+                        textColor: ColorValue;
+                        borderColor: ColorValue;
+                    };
+                    ':selected': {
+                        backgroundColor: ColorValue;
+                        textColor: ColorValue;
+                        borderColor: ColorValue;
+                    };
+                };
+            };
+            toast: Record<ToastVariant, {
+                backgroundColor: ColorValue;
+                textColor: ColorValue;
+                borderColor: ColorValue;
+                iconColor: ColorValue;
+            }> & {
+                borderRadius: BorderRadiusValue;
+            };
+            toggle: {
+                backgroundColor: ColorValue;
+                textColor: ColorValue;
+                thumbColor: ColorValue;
+                ':checked': {
+                    backgroundColor: ColorValue;
+                    thumbColor: ColorValue;
+                };
+            };
+            tooltip: {
+                backgroundColor: ColorValue;
+                textColor?: ColorValue;
+                borderColor?: ColorValue;
+                borderRadius?: BorderRadiusValue;
+                padding?: string;
+                offset?: number;
+                arrow?: {
+                    enabled?: boolean;
+                };
+            };
+            modal: {
+                backgroundColor: ColorValue;
+                borderColor: ColorValue;
+                textColor?: ColorValue;
+            };
+            datePicker: {
+                border: ColorValue;
+                day: {
+                    current_month: {
+                        textColor: ColorValue;
+                        ':selected': {
+                            textColor?: ColorValue;
+                            backgroundColor?: ColorValue;
+                        };
+                    };
+                    outside_month: {
+                        textColor: ColorValue;
+                    };
+                };
+                month: {
+                    backgroundColor: ColorValue;
+                };
+                header: {
+                    backgroundColor: ColorValue;
+                };
+            };
+            avatar: {
+                backgroundColor: ColorValue;
+                textColor: ColorValue;
+                shadowColor: ColorValue;
+            };
+            placeholder: {
+                borderColor: ColorValue;
+                color: ColorValue;
+                backgroundColor: ColorValue;
+            };
+            inboxPreview: {
+                container: {
+                    borderColor: ColorValue;
+                };
+                leftPanel: {
+                    deviceHeader: {
+                        backgroundColor: ColorValue;
+                        borderColor: ColorValue;
+                    };
+                    preview: {
+                        backgroundColor: ColorValue;
+                        borderColor: ColorValue;
+                    };
+                    zoomControls: {
+                        backgroundColor: string;
+                        boxShadowColor: string;
+                        button: {
+                            backgroundColor: ColorValue;
+                            borderColor: ColorValue;
+                            textColor: ColorValue;
+                            ':hover': {
+                                backgroundColor: ColorValue;
+                            };
+                            ':active': {
+                                backgroundColor: ColorValue;
+                            };
+                        };
+                    };
+                    loading: {
+                        spinnerBorder: ColorValue;
+                        spinnerAccent: ColorValue;
+                        textColor: ColorValue;
+                    };
+                };
+                rightPanel: {
+                    title: {
+                        textColor: ColorValue;
+                    };
+                    syncButton: {
+                        textColor: ColorValue;
+                    };
+                    description: {
+                        textColor: ColorValue;
+                    };
+                    message: {
+                        error: {
+                            textColor: ColorValue;
+                        };
+                    };
+                    gallery: {
+                        tabs: {
+                            backgroundColor: ColorValue;
+                            borderColor: ColorValue;
+                            textColor: ColorValue;
+                            ':active': {
+                                backgroundColor: ColorValue;
+                                borderColor: ColorValue;
+                            };
+                        };
+                        preview: {
+                            card: {
+                                backgroundColor: ColorValue;
+                                borderColor: ColorValue;
+                                ':selected': {
+                                    borderColor: ColorValue;
+                                };
+                            };
+                            image: {
+                                ':selected': {
+                                    opacity: string;
+                                };
+                            };
+                            title: {
+                                textColor: ColorValue;
+                            };
+                            subtitle: {
+                                textColor: ColorValue;
+                            };
+                            icon: {
+                                default: ColorValue;
+                                selected: ColorValue;
+                            };
+                        };
+                    };
+                };
+            };
+            devTab: {
+                text: {
+                    color: ColorValue;
+                };
+                container: {
+                    backgroundColor: ColorValue;
+                    separator: {
+                        borderColor: ColorValue;
+                    };
+                    warning: {
+                        borderColor: ColorValue;
+                    };
+                };
+                taskItem: {
+                    backgroundColor: ColorValue;
+                    textColor: ColorValue;
+                    borderColor: ColorValue;
+                    ':hover': {
+                        backgroundColor: ColorValue;
+                    };
+                    complete: {
+                        textColor: ColorValue;
+                        backgroundColor: ColorValue;
+                        borderColor: ColorValue;
+                    };
+                };
+                header: {
+                    title: {
+                        textColor: ColorValue;
+                        fontSize: string;
+                        backgroundColor?: ColorValue;
+                    };
+                    subtitle: {
+                        textColor: ColorValue;
+                    };
+                };
+                description: {
+                    textColor: ColorValue;
+                    fontSize: string;
+                };
+                versionInfo: {
+                    textColor: ColorValue;
+                    fontSize: string;
+                };
+                link: {
+                    textColor: ColorValue;
+                    fontSize: string;
+                    ':hover': {
+                        textColor: ColorValue;
+                    };
+                };
+                icon: {
+                    color: ColorValue;
+                    help: {
+                        color: ColorValue;
+                        ':hover': {
+                            color: ColorValue;
+                        };
+                    };
+                    success: {
+                        color: ColorValue;
+                    };
+                    warning: {
+                        color: ColorValue;
+                    };
+                    error: {
+                        color: ColorValue;
+                    };
+                };
+                accordion: {
+                    button: {
+                        padding: string;
+                        borderColor: ColorValue;
+                    };
+                };
+                error: {
+                    backgroundColor: ColorValue;
+                    borderColor: ColorValue;
+                    textColor: ColorValue;
+                };
+                login: {
+                    textColor: ColorValue;
+                    fontSize: string;
+                    ':hover': {
+                        textColor: ColorValue;
+                    };
+                };
+                reload: {
+                    textColor: ColorValue;
+                    fontSize: string;
+                    heading: {
+                        textColor: ColorValue;
+                        fontSize: string;
+                    };
+                    description: {
+                        textColor: ColorValue;
+                        fontSize: string;
+                    };
+                    button: {
+                        textColor: ColorValue;
+                        fontSize: string;
+                        ':hover': {
+                            textColor: ColorValue;
+                        };
+                    };
+                };
+                success: {
+                    icon: {
+                        color: ColorValue;
+                        fontSize: string;
+                    };
+                    title: {
+                        textColor: ColorValue;
+                        fontSize: string;
+                    };
+                    description: {
+                        textColor: ColorValue;
+                        fontSize: string;
+                    };
+                };
+            };
+        };
+    };
+    export type ThemeVariant = 'primary' | 'secondary' | 'tertiary' | 'ai' | 'ai_outline' | 'danger' | 'synced_blocks';
+    export type BannerMessageVariant = 'success' | 'warning' | 'default' | 'danger';
+    export type ToastVariant = 'success' | 'warning' | 'default' | 'danger';
+    export type ThemeColor = 'accent_01' | 'accent_02' | 'accent_03' | 'accent_04' | 'accent_05' | 'ai_01' | 'ai_02' | 'ai_03' | 'ai_04' | 'ai_05' | 'amp_01' | 'black_00' | 'black_01' | 'black_02' | 'black_03' | 'black_04' | 'black_05' | 'black_06' | 'black_07' | 'black_08' | 'black_09' | 'black_10' | 'destructive_01' | 'destructive_02' | 'destructive_03' | 'destructive_04' | 'destructive_05' | 'destructive_06' | 'destructive_07' | 'destructive_08' | 'destructive_09' | 'primary_01' | 'primary_02' | 'primary_03' | 'primary_04' | 'primary_05' | 'primary_06' | 'primary_07' | 'primary_08' | 'primary_09' | 'primary_10' | 'primary_11' | 'red_01' | 'success_01' | 'success_02' | 'success_03' | 'success_04' | 'success_05' | 'success_06' | 'success_07' | 'success_08' | 'success_09' | 'sync_01' | 'sync_02' | 'sync_03' | 'sync_04' | 'sync_05' | 'transparent' | 'warning_01' | 'warning_02' | 'warning_03' | 'warning_04' | 'warning_05' | 'warning_06' | 'warning_07' | 'warning_08' | 'warning_09' | 'white_00' | 'white_01' | 'white_02' | 'white_03' | 'white_04' | 'white_05' | 'white_06' | 'white_07' | 'white_08' | 'white_09';
+    export type ThemeExtension = {
+        name: string;
+        extends: ThemeName;
+        isDark: boolean;
+        isClassic?: boolean;
+        mapping?: DeepPartial<Theme['mapping']>;
+        components?: DeepPartial<Theme['components']>;
+    };
+    export type BorderRadius = 'none' | 'min' | 'mid' | 'max' | 'full';
+    export type ButtonThemeObject = {
+        backgroundColor: ColorValue;
+        textColor: ColorValue;
+        borderColor: ColorValue;
+        borderRadius?: BorderRadiusValue;
+        outlineColor?: ColorValue;
+    };
+    export type BorderRadiusValue = `{${BorderRadius}}`;
+    export type ColorValue = `{${ThemeColor}}` | `darken(${number}%, {${ThemeColor}})` | `fade(${number}%, {${ThemeColor}})` | `lighten(${number}%, {${ThemeColor}})`;
+    export type DeprecatedTheme = {
+        name: string;
+        /** @deprecated */
+        preferences: {
+            width: string;
+            smWidth: string;
+            padding: string;
+            backgroundColor: string;
+            borderColor: string;
+            tabs: {
+                width: string;
+                smWidth?: string;
+                backgroundColor: string;
+                textColor: string;
+                activeTextColor: string;
+                activeBackgroundColor: string;
+                activeBorderColor: string;
+                hoverTextColor: string;
+                hoverBackgroundColor: string;
+                notificationBadgeBackgroundColor: string;
+                notificationBadgeTextColor: string;
+            };
+            tools: {
+                width: string;
+                height: string;
+                smWidth: string;
+                smHeight: string;
+                backgroundColor: string;
+                textColor: string;
+                iconColor: string;
+                borderSize: string;
+                borderColor: string;
+                hoverBorderColor: string;
+                hoverShadowColor: string;
+                draggingBorderColor: string;
+            };
+            alerts: {
+                notice: {
+                    backgroundColor: string;
+                    textColor: string;
+                    borderColor: string;
+                };
+            };
+            properties: {
+                header: {
+                    backgroundColor: string;
+                    fixedBackgroundColor: string;
+                    borderColor: string;
+                    title: {
+                        textColor: string;
+                    };
+                    badge: {
+                        backgroundColor: string;
+                        textColor: string;
+                    };
+                    icon: {
+                        color: string;
+                        borderColor: string;
+                        hoverBackgroundColor: string;
+                        hoverColor: string;
+                        destructiveHoverBackgroundColor: string;
+                        destructiveHoverColor: string;
+                    };
+                };
+                group: {
+                    header: {
+                        backgroundColor: string;
+                        textColor: string;
+                        iconColor: string;
+                        collapseIconColor: string;
+                        borderColor: string;
+                        ':closed': {
+                            backgroundColor: string;
+                            textColor: string;
+                            iconColor: string;
+                            collapseIconColor: string;
+                            borderColor: string;
+                        };
+                    };
+                    expandButton: {
+                        backgroundColor: string;
+                        textColor: string;
+                        hoverBackgroundColor: string;
+                        hoverTextColor: string;
+                    };
+                    embedded: {
+                        borderColor: string;
+                        activeBorderColor: string;
+                        hoverBorderColor: string;
+                        textColor: string;
+                        activeTextColor: string;
+                    };
+                };
+                editor: {
+                    label: {
+                        default: {
+                            textColor: string;
+                        };
+                        primary: {
+                            textColor: string;
+                            modified: {
+                                backgroundColor: string;
+                                textColor: string;
+                                ':hover': {
+                                    backgroundColor: string;
+                                    textColor: string;
+                                };
+                            };
+                        };
+                        subheader: {
+                            textColor: string;
+                        };
+                        secondary: {
+                            textColor: string;
+                        };
+                        tertiary: {
+                            textColor: string;
+                        };
+                    };
+                    hint: {
+                        textColor: string;
+                    };
+                    seperator: {
+                        color: string;
+                    };
+                    columns: {
+                        backgroundColor: string;
+                        borderColor: string;
+                        boxShadowColor: string;
+                        textColor: string;
+                        ':hover': {
+                            backgroundColor: string;
+                            borderColor: string;
+                        };
+                        ':selected': {
+                            backgroundColor: string;
+                            borderColor: string;
+                        };
+                    };
+                    button: {
+                        default: {
+                            backgroundColor: string;
+                            textColor: string;
+                            borderColor: string;
+                            iconColor?: string;
+                            hover: {
+                                backgroundColor?: string;
+                                textColor?: string;
+                                borderColor?: string;
+                                iconColor?: string;
+                            };
+                            active: {
+                                backgroundColor?: string;
+                                textColor?: string;
+                                borderColor?: string;
+                                iconColor?: string;
+                            };
+                            disabled: {
+                                backgroundColor?: string;
+                            };
+                        };
+                        primary: {
+                            backgroundColor: string;
+                            textColor: string;
+                            borderColor: string;
+                            hover: {
+                                backgroundColor?: string;
+                                textColor?: string;
+                                borderColor?: string;
+                            };
+                        };
+                        dashed: {
+                            textColor: string;
+                            borderColor: string;
+                            borderRadius: BorderRadiusValue;
+                            hover: {
+                                backgroundColor?: string;
+                                textColor?: string;
+                                borderColor?: string;
+                            };
+                        };
+                        secondary: {
+                            textColor: string;
+                            secondaryTextColor: string;
+                            backgroundColor: string;
+                            secondaryBackgroundColor: string;
+                            borderColor: string;
+                            secondaryBorderColor: string;
+                        };
+                    };
+                    input: {
+                        backgroundColor: string;
+                        textColor: string;
+                        borderColor: string;
+                        labelBackgroundColor: string;
+                        labelTextColor: string;
+                        labelBorderColor: string;
+                        errorBorderColor: string;
+                        errorShadowColor: string;
+                        placeholderTextColor: string;
+                        focus: {
+                            boxShadowColor?: string;
+                        };
+                        disabled: {
+                            backgroundColor?: string;
+                            textColor?: string;
+                            borderColor?: string;
+                        };
+                    };
+                    displayCondition: {
+                        backgroundColor: string;
+                        borderColor: string;
+                        titleColor: string;
+                        textColor: string;
+                    };
+                    card: {
+                        borderColor: string;
+                    };
+                    dropdown: {
+                        primary: {
+                            menu: {
+                                backgroundColor: string;
+                                borderColor: string;
+                            };
+                            item: {
+                                textColor: string;
+                                backgroundColor: string;
+                                focus: {
+                                    textColor: string;
+                                    backgroundColor: string;
+                                };
+                                hover: {
+                                    textColor: string;
+                                    backgroundColor: string;
+                                };
+                                active: {
+                                    textColor: string;
+                                    backgroundColor: string;
+                                    hover: {
+                                        textColor: string;
+                                        backgroundColor: string;
+                                    };
+                                };
+                            };
+                        };
+                        secondary: {
+                            menu: {
+                                backgroundColor: string;
+                                borderColor: string;
+                                hover: {
+                                    color: string;
+                                    backgroundColor: string;
+                                };
+                            };
+                            item: {
+                                textColor: string;
+                                backgroundColor: string;
+                                hover: {
+                                    textColor: string;
+                                    backgroundColor: string;
+                                };
+                                active: {
+                                    textColor: string;
+                                    backgroundColor: string;
+                                    hover: {
+                                        textColor: string;
+                                        backgroundColor: string;
+                                    };
+                                };
+                            };
+                            button: {
+                                textColor: string;
+                                backgroundColor: string;
+                                borderColor: string;
+                                active: {
+                                    borderColor: string;
+                                };
+                            };
+                            icon: {
+                                active: {
+                                    color: string;
+                                };
+                            };
+                        };
+                    };
+                    slider: {
+                        fillColor: string;
+                        emptyColor: string;
+                        handleColor: string;
+                        handleBorderColor: string;
+                        disabledColor: string;
+                    };
+                    colorpicker: {
+                        backgroundColor: string;
+                        borderColor: string;
+                        boxShadowColor: string;
+                        circleBorderColor: string;
+                        checkLightIconColor: string;
+                        checkDarkIconColor: string;
+                        transparentCircleBackgroundColor: string;
+                    };
+                    social: {
+                        textColor: ColorValue;
+                        backgroundColor: ColorValue;
+                        dotColor: ColorValue;
+                    };
+                };
+                card: {
+                    textColor: string;
+                    borderColor: string;
+                    backgroundColor: string;
+                    title: {
+                        textColor: string;
+                    };
+                    active: {
+                        textColor: string;
+                    };
+                };
+            };
+            close: {
+                backgroundColor: string;
+                iconColor: string;
+                borderColor: string;
+                ':hover': {
+                    backgroundColor: string;
+                    iconColor: string;
+                    borderColor: string;
+                };
+            };
+            branding: {
+                height: string;
+                backgroundColor: ColorValue;
+                textColor: ColorValue;
+                linkColor: ColorValue;
+                iconColor: ColorValue;
+                ':hover'?: {
+                    backgroundColor?: ColorValue;
+                    textColor?: ColorValue;
+                    linkColor?: ColorValue;
+                    iconColor?: ColorValue;
+                };
+            };
+        };
+        /** @deprecated */
+        actions: {
+            backgroundColor: string;
+            foregroundColor: string;
+            hoverForegroundColor: string;
+            selectedForegroundColor: string;
+            highlightBackgroundColor: string;
+            highlightForegroundColor: string;
+            separatorColor: string;
+            borderColor: string;
+            errorColor: string;
+        };
+        /** @deprecated */
+        canvas: {
+            backgroundColor: string;
+            borderColor: string;
+            backgroundCheckerColor: string;
+        };
+        /** @deprecated */
+        preview: {
+            padding: string;
+            paddingV?: string;
+            paddingH?: string;
+            backgroundColor: string;
+            borderColor: string;
+            titleColor: string;
+            dropdownValueColor: string;
+            dropdownBorderColor: string;
+            inboxPreviewButtonColor: string;
+            iconColor: string;
+            iconSelectedColor: string;
+            iconHoverColor: string;
+            iconHoverBorderColor: string;
+            previewModalBackground: string;
+            buttonBackgroundSelected: string;
+            buttonBackgroundDefault: string;
+            buttonDefaultColor: string;
+            buttonSelectedColor: string;
+            buttonDefaultBorder: string;
+            buttonHoverBorderColor: string;
+            buttonSelectedBorder: string;
+            buttonSecondaryBackground: string;
+            buttonSuccessBackground: string;
+            buttonLoadingBackground: string;
+            buttonErrorBackground: string;
+            buttonSecondaryColor: string;
+            buttonSuccessColor: string;
+            buttonErrorColor: string;
+            buttonLoadingColor: string;
+            deviceContainerBorderColor: string;
+            deviceHeaderBackgroundColor: string;
+            deviceBackgroundSelected: string;
+            deviceBackgroundDefault: string;
+            separatorColor: string;
+            darkModeBackgroundColor: string;
+            darkModeIconColor: string;
+            lightModeBackgroundColor: string;
+            lightModeIconColor: string;
+            galleryBackgroundColor: string;
+        };
+        /** @deprecated */
+        panel: {
+            backgroundColor: string;
+            textColor: string;
+            mutedColor: string;
+            input: {
+                backgroundColor: string;
+                placeholderTextColor: string;
+                textColor: string;
+            };
+        };
+        /** @deprecated */
+        list: {
+            separatorColor: string;
+            hoverBackgroundColor: string;
+        };
+        /** @deprecated */
+        suggestions: {
+            backgroundColor: string;
+            borderColor: string;
+            textColor: string;
+            titleColor: string;
+            subtitleColor: string;
+            textCard: {
+                backgroundColor: string;
+                textColor: string;
+                borderColor: string;
+                boxShadowColor: string;
+                number: {
+                    backgroundColor: string;
+                    textColor: string;
+                    borderColor: string;
+                };
+                hover: {
+                    backgroundColor: string;
+                    textColor: string;
+                    borderColor: string;
+                    boxShadowColor: string;
+                };
+            };
+            closeButton: {
+                iconColor: string;
+                hover: {
+                    iconColor: string;
+                };
+            };
+            loader: {
+                backgroundColor: string;
+                content: {
+                    backgroundColor: string;
+                    headingColor: string;
+                    textColor: string;
+                };
+                progressBar: {
+                    backgroundColor: string;
+                };
+            };
+        };
+    };
+}
+declare module "engine/constants" {
+    export const displayModes: readonly ["email", "web", "popup", "document"];
+    export const collections: readonly ["bodies", "columns", "contents", "footers", "headers", "pages", "rows"];
+    export const HTMLInputTypeAttributes: readonly ["button", "checkbox", "color", "date", "datetime-local", "email", "file", "hidden", "image", "month", "number", "password", "radio", "range", "reset", "search", "submit", "tel", "text", "time", "url", "week"];
+    export const IS_CYPRESS: boolean;
+    export const BROWSER: {
+        IS_IE: boolean;
+        IS_SAFARI: boolean;
+    };
+}
+declare module "engine/utils/zod/schemas" {
+    import { z } from 'zod/v4';
+    /**
+     * zod/v4 workaround for z.function support
+     * Not supported by z.toJSONSchema
+     * @see https://zod.dev/v4/changelog?id=zfunction
+     * @see https://github.com/colinhacks/zod/issues/4143#issuecomment-2845134912
+     */
+    export const functionSchema: <T extends z.core.$ZodFunction>(schema: T) => any;
+    export const createAsyncFunctionSchema: <T extends z.core.$ZodFunction>(schema: T) => any;
+    export const locationSchema: any;
+    export const DisplayConditionZodSchema: any;
+    export const FontWeightZodSchema: any;
+    export const FontZodSchema: any;
+    export const HintZodSchema: any;
+    export const PercentageZodSchema: any;
+    export const SinglePxZodSchema: any;
+    export const DoublePxZodSchema: any;
+    export const TriplePxZodSchema: any;
+    export const QuadruplePxZodSchema: any;
+    export const MultiplePxZodSchema: any;
+}
+declare module "state/types/types" {
+    import * as Ariakit from '@ariakit/react';
+    import { MutableRefObject, ReactInstance } from 'react';
+    import { z } from 'zod/v4';
+    import { State as Design } from '../reducer/design';
+    import { CollaborationThread } from "editor/components/editors/types";
+    import { RootState } from "state/types/RootState";
+    import { ThemeExtension, ThemeNamePlusLightDark } from "editor/themes/types";
+    import { collections, displayModes } from "engine/constants";
+    import { DisplayConditionZodSchema } from "engine/utils/zod/schemas";
+    import { AppDispatch } from '../store';
+    export type DesignMode = 'live' | 'edit';
+    export type Device = 'desktop' | 'mobile' | 'tablet';
+    export type Resolution = {
+        value: number;
+        name: string;
+    };
+    export type DisplayMode = ArrayItem<typeof displayModes>;
+    export type Variant = 'amp' | null;
+    export type Ui = 'none' | 'visual' | 'classic';
+    export type UndoRedoBehavior = 'save' | 'replace' | 'skip';
+    export interface MergeTag {
+        name: string;
+        value?: string;
+        sample?: string;
+        icon?: string;
+        mergeTags?: MergeTags;
+        rules?: {
+            [key: string]: {
+                name: string;
+                before: string;
+                after: string;
+                sample?: boolean | Array<Record<string, string>>;
+            };
+        };
+    }
+    export interface MergeTags {
+        [name: string]: MergeTag;
+    }
+    export type MergeTagsValues = Record<string, string | number | Record<string, boolean | Array<Record<string, string | number>>>>;
+    export interface MergeTagsConfig {
+        autocompleteTriggerChar?: string | null;
+        sort?: boolean;
+    }
+    export type DisplayCondition = z.infer<typeof DisplayConditionZodSchema>;
+    export type DisplayConditions = DisplayCondition[];
+    export type SpecialLink = {
+        name: string;
+        href: string;
+        target?: string;
+        specialLinks?: undefined;
+    } | {
+        name: string;
+        href?: undefined;
+        target?: undefined;
+        specialLinks: SpecialLinks;
+    };
+    export interface SpecialLinks {
+        [name: string]: SpecialLink;
+    }
+    export type LinkTypeFieldOption = {
+        value: string;
+        label: string;
+        enabled?: boolean;
+        highlight?: boolean;
+        onClick?: (_option: {
+            label?: string;
+            value: string;
+        }, _meta: object, done: (result: {
+            label?: string;
+            value: string;
+        }) => void) => void;
+    } | {
+        type: 'separator';
+    };
+    export interface LinkTypeField {
+        name: string;
+        label: string;
+        defaultValue?: string | LinkTypeFieldOption[] | undefined;
+        enabled?: boolean;
+        placeholderText?: string;
+        inputType?: Ariakit.FormInputProps['type'];
+        isClearable?: boolean;
+        isCreatable?: boolean;
+        isMulti?: boolean;
+        limit?: number;
+        limitMessage?: string;
+        validationRegex?: string;
+        options?: LinkTypeFieldOption[];
+        sortOptions?: boolean | (<Option extends {
+            label: string;
+        }>(options: Option[]) => Option[]);
+        onCreateOption?: (inputValue: string, meta: object, done: (newOption: LinkTypeFieldOption) => void) => void;
+    }
+    export interface LinkType {
+        name: string;
+        label: string;
+        enabled?: boolean;
+        attrs?: {
+            href?: string;
+            target?: string;
+            onClick?: string | Function;
+            class?: string;
+            download?: boolean;
+            [key: string]: any;
+        };
+        fields?: LinkTypeField[];
+    }
+    export type LinkTypes = LinkType[];
+    export type LinkTypesSharedConfig = Pick<LinkType, 'attrs' | 'fields'>;
+    export interface CustomFont {
+        label: string;
+        value: string;
+        url: string;
+        weights?: number[] | Array<{
+            label: string;
+            value: number;
+        } | number>;
+    }
+    export interface CustomFonts {
+        [label: string]: CustomFont;
+    }
+    export type DesignTag = string;
+    export interface DesignTags {
+        [name: string]: DesignTag;
+    }
+    export interface DesignTagsConfig {
+        delimiter: [string, string];
+    }
+    export type CustomCSS = string | string[] | undefined | null;
+    export type CustomJS = string | string[] | undefined | null;
+    export interface Translations {
+        [name: string]: object;
+    }
+    export type Collection = ArrayItem<typeof collections>;
+    export type Container = 'body' | 'row' | 'column' | 'content';
+    export type AICopilotDataType = 'template_block' | 'page_block' | 'body_block' | 'row_block' | 'header_block' | 'footer_block' | 'column_block' | 'content_block' | 'text';
+    export interface Location {
+        collection: Collection;
+        id: number | string;
+    }
+    export interface Selection {
+        active: boolean;
+        location: Location | null;
+        parent: Location | null;
+        threadId: CollaborationThread['id'] | null;
+        selectedAt: number | null;
+    }
+    export interface LayerGroup {
+        elementRef: MutableRefObject<ReactInstance | undefined> | null | undefined;
+        layerCollection: Location['collection'];
+        layerIndex?: Placeholder['index'];
+        parentCollection: Location['collection'];
+        parentId: Location['id'];
+        placeholders: Partial<Record<NonNullable<Placeholder['index']>, Placeholder | undefined>>;
+    }
+    export interface Placeholder {
+        elementRef: MutableRefObject<ReactInstance | undefined> | null | undefined;
+        active?: boolean;
+        index: number | 'first' | 'last' | undefined;
+        layerGroupParentLocation: Location | undefined;
+    }
+    export interface Tool {
+        active: boolean;
+        type: string | null;
+        slug?: string | null;
+    }
+    export interface Usage {
+        brandStyleGuide?: boolean;
+        collaboration?: boolean;
+        countdownTimer?: boolean;
+        customBlocks?: number;
+        customBlocksProvider?: boolean;
+        customCSS?: boolean;
+        customFileManager?: boolean;
+        customFonts?: number;
+        customImageLibrary?: boolean;
+        customJS?: boolean;
+        customPreview?: boolean;
+        customTabs?: number;
+        customTools?: number;
+        designMode?: DesignMode;
+        designTags?: number;
+        displayConditions?: number;
+        displayMode?: DisplayMode;
+        fileStorage?: boolean;
+        inboxPreviews?: boolean;
+        linkTypes?: number;
+        localization?: string;
+        mergeTags?: number;
+        projectId?: number;
+        premiumTools?: boolean;
+        sendTestEmail?: boolean;
+        specialLinks?: number;
+        theme?: string;
+    }
+    export type ImageSource = 'unsplash' | 'pixabay' | 'pexel' | 'user';
+    export interface Image {
+        id: number | string;
+        location: string;
+        filename?: string;
+        contentType: string;
+        size: number;
+        width: number | null;
+        height: number | null;
+        source: ImageSource | null;
+        optimistic?: boolean;
+    }
+    export type ArrayItem<T> = T extends (infer I)[] ? I : T extends readonly (infer I)[] ? I : unknown;
+    export type BodyItem = {
+        id: string;
+        cells: number[];
+        columns: Array<{
+            id: string;
+            contents: Array<Design['contents']['0']>;
+            values: Record<string, any>;
+        }>;
+        values: {
+            sync?: {
+                id: string;
+                enabled?: boolean;
+                updatedAt?: string;
+                dirty?: boolean;
+            };
+        } & Record<string, any>;
+    };
+    export type JSONTemplate = {
+        counters: Record<string, number>;
+        body: {
+            id: string | undefined;
+            rows: BodyItem[];
+            headers: BodyItem[];
+            footers: BodyItem[];
+            values: {};
+        };
+        schemaVersion?: number;
+    };
+    export type Fonts = {
+        showDefaultFonts?: boolean;
+        customFonts?: CustomFont[];
+    };
+    export type Icon = {
+        name?: string;
+        data?: string;
+        url?: string;
+    };
+    export type AuditTool = {
+        type: string;
+        name?: string;
+        slug?: string;
+        labelPath?: Rule['labelPath'];
+    };
+    export type Rule = {
+        id: string;
+        icon: string | string[] | undefined;
+        title: string;
+        description: string;
+        severity: 'ERROR' | 'WARNING';
+        dismissable?: boolean;
+        labelPath?: string | string[] | null;
+    };
+    export type Audit = {
+        location?: Location;
+        tool?: AuditTool;
+    } & Rule;
+    export type Validator = (info: {
+        [id: string]: unknown;
+        html?: string;
+        defaultErrors?: Audit[];
+    }) => Promise<Audit[]>;
+    export type AuditApiResult = {
+        status: 'FAIL' | 'PASS';
+        errors: Audit[];
+    };
+    export type Tabs = {
+        [tabName: string]: {
+            enabled?: boolean;
+            type?: string;
+            position?: number;
+            icon?: string;
+            active?: boolean;
+        };
+    };
+    export type AppearanceConfig = {
+        actionBar?: {
+            placement?: 'top' | 'bottom' | 'top_left' | 'top_right' | 'bottom_left' | 'bottom_right' | undefined;
+        };
+        /** @deprecated Use unlayer.init({ features: { ... }}) instead */
+        features?: object;
+        loader?: {
+            url?: string | undefined;
+            html?: string | undefined;
+            css?: string | undefined;
+        };
+        panels?: {
+            tools?: {
+                dock?: 'left' | 'right';
+                collapsible?: boolean;
+                forceUncollapseOnSelect?: boolean;
+                tabs?: {
+                    body?: {
+                        visible?: boolean;
+                    };
+                };
+            };
+        };
+        theme?: ThemeNamePlusLightDark | ThemeExtension;
+    };
+    export interface ToolConfig {
+        enabled?: boolean | undefined;
+        position?: number | undefined;
+        properties?: object | undefined;
+        sections?: object | undefined;
+        validator?: Validator;
+    }
+    export interface ToolsConfig {
+        [key: string]: ToolConfig;
+    }
+    export type User = {
+        id?: string | number;
+        name?: string | null | undefined;
+        avatar?: string | null | undefined;
+        email?: string;
+        signature?: string;
+    };
+    export type Language = {
+        label: string;
+        value: string;
+        rtl?: boolean;
+        default?: boolean;
+    };
+    export interface StyleGuideStyle {
+        label: string;
+        values: Record<string, any>;
+    }
+    export interface StyleGuideStyles {
+        [styleGuideId: string]: StyleGuideStyle | undefined;
+    }
+    export interface StyleGuideToolConfig {
+        styles?: StyleGuideStyles;
+    }
+    export interface StyleGuideConfig {
+        tools?: {
+            [toolId: string]: StyleGuideToolConfig | undefined;
+        };
+    }
+    export type InsertItemAsync = (collection: Collection, toParent: Location, data: {
+        [key: string]: any;
+        type: string;
+        values: {
+            [id: string]: unknown;
+        };
+    }, placeholder: string) => (dispatch: AppDispatch, getState: () => RootState) => Promise<void>;
+    export interface JSONSchema {
+    }
+    export interface SuggestedSelection {
+        parent?: Location | null;
+        location: Location | null;
+        table?: {
+            globalClickedCellId: string | null;
+        };
+    }
+    export type TableValue = {
+        headers: {
+            cells: {
+                id: string;
+                text: string;
+            }[];
+        }[];
+        rows: {
+            cells: {
+                id: string;
+                text: string;
+            }[];
+        }[];
+    };
+    export type ExporterName = DisplayMode | 'ampWeb' | 'ampEmail' | 'classic';
+    export type BodyContainerExporter = (innerHTML: string, bodyValues: Record<string, any>, // @deprecated use last param instead
+    meta: {
+        bodyValues: RootState['design']['bodies'][string]['values'];
+        type: string;
+        variant: Variant;
+    }) => string;
+    export type BodyContainerExporters = Partial<Record<ExporterName, BodyContainerExporter>>;
+    export type RowContainerExporter = (innerHTML: string, rowValues: RootState['design']['rows'][string]['values'], // @deprecated use last param instead
+    bodyValues: RootState['design']['bodies'][string]['values'], // @deprecated use last param instead
+    meta: {
+        rowIndex: number;
+        rowCells: number[];
+        rowValues: RootState['design']['rows'][string]['values'];
+        bodyValues: RootState['design']['bodies'][string]['values'];
+        variant: Variant | undefined;
+        language: string | undefined;
+        collection: Collection;
+    }) => string;
+    export type RowContainerExporters = Partial<Record<ExporterName, RowContainerExporter>>;
+    export type ColumnContainerExporter = (innerHTML: string, columnValues: Record<string, any>, // @deprecated use last param instead
+    columnIndex: number, // @deprecated use last param instead
+    rowCells: number[], // @deprecated use last param instead
+    bodyValues: RootState['design']['bodies'][string]['values'], // @deprecated use last param instead
+    rowValues: RootState['design']['rows'][string]['values'], // @deprecated use last param instead
+    meta: {
+        columnIndex: number;
+        columnValues: RootState['design']['columns'][string]['values'];
+        rowIndex: number;
+        rowCells: number[];
+        rowValues: RootState['design']['rows'][string]['values'];
+        bodyValues: RootState['design']['bodies'][string]['values'];
+        variant: Variant;
+        language: string;
+    }) => string;
+    export type ColumnContainerExporters = Partial<Record<ExporterName, ColumnContainerExporter>>;
+    export type ContentContainerExporter = (innerHTML: string, contentValues: Record<string, any>, // @deprecated use last param instead
+    bodyValues: RootState['design']['bodies'][string]['values'], // @deprecated use last param instead
+    meta: {
+        index: number;
+        columnIndex: number;
+        columnValues: RootState['design']['columns'][string]['values'];
+        rowIndex: number;
+        rowCells: number[];
+        rowValues: RootState['design']['rows'][string]['values'];
+        bodyValues: RootState['design']['bodies'][string]['values'];
+        variant: Variant | undefined;
+        language: string | undefined;
+        embeddedValues: Record<string, unknown>;
+        mergeTagState: {
+            mergeTagGroup: string;
+            mergeTagRule: string;
+            mergeTags: MergeTagsValues;
+        };
+    }) => string;
+    export type ContentContainerExporters = Partial<Record<ExporterName, ContentContainerExporter>>;
+    export type ItemExporter = (renderValues: Record<string, unknown>, index: number, // @deprecated use last param instead
+    columnIndex: number, // @deprecated use last param instead
+    rowCells: number[], // @deprecated use last param instead
+    bodyValues: RootState['design']['bodies'][string]['values'], // @deprecated use last param instead
+    rowValues: RootState['design']['rows'][string]['values'], // @deprecated use last param instead
+    embeddedValues: Record<string, unknown>, // @deprecated use last param instead
+    meta: {
+        index: number;
+        columnIndex: number;
+        columnValues: RootState['design']['columns'][string]['values'];
+        rowIndex: number;
+        rowCells: number[];
+        rowValues: RootState['design']['rows'][string]['values'];
+        bodyValues: RootState['design']['bodies'][string]['values'];
+        embeddedValues: Record<string, unknown>;
+        mergeTagState: {
+            mergeTagGroup: string;
+            mergeTagRule: string;
+            mergeTags: MergeTagsValues;
+        };
+    }) => string;
+    export type ItemExporters = Partial<Record<ExporterName, ItemExporter>>;
+}
+declare module "engine/utils/pruneObj" {
+    export function pruneObj<T extends Record<string, any>>(obj: T, options?: {
+        deep?: boolean;
+    }): Partial<T>;
+}
+declare module "engine/config/features" {
+    import { Resolution, Language } from "state/types/types";
+    export interface TextEditorCustomButton {
+        name: string;
+        icon: string;
+        text: string;
+        onSetup?: () => void;
+        onAction: (data: {
+            text: string;
+        }, callback: (text: string) => void) => void;
+    }
+    export type ColorGroup = {} & ({
+        id: 'brand_colors' | 'common_colors' | 'recent_colors' | 'template_colors' | (string & {});
+        label?: string;
+        colors?: string[];
+        default?: boolean;
+    } | {
+        id?: never;
+        label: string;
+        colors: string[];
+        default?: boolean;
+    });
+    export interface ColorPicker {
+        /** @deprecated Use colors: string[] or colors: [{ id: "common_colors", label: 'Common Colors', colors: string[] }] instead */
+        presets?: string[];
+        /** @deprecated Use colors: [{ id: "brand_colors", label: 'Brand Colors', colors: string[] }] instead */
+        brandColors?: string[];
+        colors?: string[] | ColorGroup[];
+        limit?: number;
+        recentColors?: boolean | null;
+    }
+    export interface Features {
+        audit?: boolean;
+        beta?: boolean | {
+            enabled?: boolean;
+            feedback?: boolean;
+        };
+        blocks?: boolean;
+        collaboration?: boolean;
+        preview?: boolean | {
+            enabled?: boolean;
+            cleanup?: boolean;
+            deviceResolutions?: {
+                showDefaultResolutions?: boolean;
+                customResolutions?: {
+                    desktop?: Resolution[];
+                    tablet?: Resolution[];
+                    mobile?: Resolution[];
+                };
+            };
+        };
+        imageEditor?: {
+            enabled: boolean;
+            tools?: {
+                resize?: boolean;
+            };
+        } | boolean;
+        preheaderText?: boolean;
+        headersAndFooters?: boolean;
+        stockImages?: {
+            enabled: true;
+            safeSearch: true;
+            defaultSearchTerm: string;
+        } | boolean;
+        userUploads?: boolean | {
+            enabled: boolean;
+            search?: boolean;
+        };
+        devTab?: boolean;
+        undoRedo?: boolean | {
+            enabled: boolean;
+            autoSelect?: boolean;
+            autoFocus?: boolean;
+        };
+        textEditor?: {
+            spellChecker?: boolean;
+            tables?: boolean;
+            cleanPaste?: boolean | 'basic' | 'confirm';
+            emojis?: boolean;
+            textDirection?: boolean | null;
+            inlineColorGroups?: string[];
+            inlineFontControls?: boolean;
+            defaultFontSize?: string;
+            customButtons?: TextEditorCustomButton[];
+        };
+        colorPicker?: ColorPicker;
+        legacy?: {
+            disableHoverButtonColors?: boolean;
+        };
+        inboxPreviews?: boolean;
+        pageAnchors?: boolean;
+        svgImageUpload?: boolean;
+        smartMergeTags?: boolean;
+        multiLanguage?: boolean | {
+            enabled: boolean;
+            languages?: Language[];
+        };
+        styleGuide?: boolean;
+        ai?: boolean | {
+            enabled?: boolean;
+            copilot?: boolean;
+            models?: boolean;
+            magicImage?: boolean;
+            smartButtons?: boolean;
+            smartHeadings?: boolean;
+            smartImageAltText?: boolean;
+            smartText?: boolean;
+            smartParagraph?: boolean;
+        };
+        sendTestEmail?: boolean;
+        syncedBlocks?: boolean;
+    }
+    export const betaFeatures: readonly ["ai.copilot"];
+    export const betaEntitlements: readonly ["copilot"];
+    export function setFeatures(newFeatures: Features): void;
+    export function getFeatureOverrides(): Features;
+    export function setOverrideFeatures(newOverrideFeatures: Features, options?: {
+        deepmerge?: boolean;
+    }): void;
+    export function getFeatures(): Features;
+    export function getFeature<Path extends keyof Features | [keyof Features, ...string[]]>(path: Path): Path extends keyof Features ? Features[Path] : any;
+    export function normalizeFeatureAsObject<Object extends Record<string, any>, Feature extends boolean | Object>(feature: Feature | undefined): Partial<Feature & object>;
+    export function getFeatureAsObject<Path extends keyof Features | [keyof Features, ...string[]]>(path: Path): Partial<(Path extends keyof Features ? Features[Path] : any) & object>;
+    export function hasFeature<Path extends keyof Features | [keyof Features, ...string[]]>(path: Path, checkEntitlement?: boolean | string): boolean;
+}
+declare module "engine/config/offline" {
+    export function enableOffline(): void;
+    export function isOffline(): boolean;
+}
+declare module "engine/config/callbacks" {
+    import { Handler } from 'mitt';
+    export type CallbackDoneFn = (result: any) => Promise<void> | void;
+    export type CallbackFn = (data?: any, done?: CallbackDoneFn) => Promise<void> | void;
+    export type CallbackMap = {
+        [name: string]: CallbackFn | undefined;
+    };
+    export function getCallback(type: string): CallbackFn;
+    export function hasCallback(type: string): boolean;
+    export function registerCallback(type: string, callback: CallbackFn | null | undefined): void;
+    export function unregisterCallback(type: string): void;
+    export function triggerCallback(type: string, ...args: [...any[], CallbackDoneFn | undefined]): void;
+    export function onRegisterCallback(handler: Handler<{
+        type: string;
+        callback: CallbackFn;
+    }>): {
+        remove: () => void;
+    };
+    export function onTriggerCallback(handler: Handler<{
+        type: string;
+        callback: CallbackFn;
+    }>): {
+        remove: () => void;
+    };
+    export function onUnregisterCallback(handler: Handler<{
+        type: string;
+    }>): {
+        remove: () => void;
+    };
+}
+declare module "engine/config/fonts" {
+    import { z } from 'zod/v4';
+    import { FontZodSchema } from "engine/utils/zod/schemas";
+    export type Font = z.infer<typeof FontZodSchema>;
+    export type FontList = Font[];
+    export interface FontConfig {
+        showDefaultFonts?: boolean;
+        customFonts?: FontList;
+    }
+    export interface FontOptions {
+        showCustomFonts?: boolean;
+        showGlobalFont?: boolean;
+    }
+    export function loadFontConfig(newFontConfig?: FontConfig): void;
+    export function disableBuiltinFonts(): void;
+    export function setFonts(newFonts?: FontList): void;
+    export function getFonts(options?: FontOptions): FontList;
+    export function getFontsVersion(): number;
+    export function getCustomFontsCount(): number;
+    export const defaultFontWeights: number[];
+}
+declare module "engine/config/safeHtml" {
+    import { Config } from 'dompurify';
+    export interface SafeHtmlOptions {
+        domPurifyOptions?: Config;
+    }
+    export function isSafeHtmlEnabled(): boolean;
+    export function enableSafeHtml(): void;
+    export function disableSafeHtml(): void;
+    export function setSafeHtmlOptions(options?: SafeHtmlOptions): void;
+    function _toSafeHtmlInternal(html: string, { allowOnClick, force }?: {
+        allowOnClick?: boolean;
+        force?: boolean;
+    }): string;
+    export const toSafeHtmlInternal: typeof _toSafeHtmlInternal & import("lodash").MemoizedFunction;
+    function _toSafeHtml(html: string, { allowOnClick, force, domPurifyOptions, }?: {
+        allowOnClick?: boolean;
+        force?: boolean;
+        domPurifyOptions?: SafeHtmlOptions['domPurifyOptions'];
+    }): TrustedHTML;
+    export const toSafeHtml: typeof _toSafeHtml & import("lodash").MemoizedFunction;
+}
+declare module "engine/translations/types" {
+    import stockTranslations from '.';
+    export type StockLocale = keyof typeof stockTranslations;
+}
+declare module "engine/config/intl" {
+    import { StockLocale } from "engine/translations/types";
+    export type Locale = StockLocale | 'en-US';
+    export type TextDirection = 'ltr' | 'rtl';
+    export const DEFAULT_LOCALE = "en-US";
+    export const RTL_COUNTRIES: string[];
+    export function getLocale(): Locale;
+    export function setLocale(locale: Locale | null): void;
+    export function getTextDirection(): TextDirection | undefined;
+    export function getTextDirectionForLocale(locale: Locale): TextDirection | undefined;
+    export function setTextDirection(textDirection: TextDirection | null): void;
+    export function isRTL(locale: Locale): boolean;
+}
+declare module "embed/Config" {
+    import { ValidationResult } from 'amphtml-validator';
+    import { EditorSettings } from "engine/config/editorSettings";
+    import { Features } from "engine/config/features";
+    import { FontList } from "engine/config/fonts";
+    import { SafeHtmlOptions } from "engine/config/safeHtml";
+    import { TextDirection } from "engine/config/intl";
+    import { AppearanceConfig, Audit, DesignTags, DesignTagsConfig, Device, DisplayConditions, DisplayMode, Fonts, JSONTemplate, LinkTypes, LinkTypesSharedConfig, MergeTags, MergeTagsConfig, MergeTagsValues, SpecialLinks, Tabs, ToolsConfig, User } from "state/types/types";
+    import { DeepPartial } from "editor/components/editors/types";
+    export interface Config {
+        id?: string;
+        className?: string;
+        version?: string;
+        source?: {
+            name: string;
+            version: string;
+        };
+        offline?: boolean;
+        render?: boolean;
+        amp?: boolean;
+        defaultDevice?: Device;
+        devices?: Device[];
+        designId?: string;
+        designMode?: string;
+        displayMode?: DisplayMode;
+        env?: Record<'API_V1_BASE_URL' | 'API_V2_BASE_URL' | 'API_V3_BASE_URL' | 'EVENTS_API_BASE_URL' | 'TOOLS_API_V1_BASE_URL' | 'TOOLS_CDN_BASE_URL' | 'CONSOLE_BASE_URL', string | undefined>;
+        projectId?: number | null;
+        user?: User;
+        templateId?: number;
+        stockTemplateId?: string;
+        loadTimeout?: number;
+        safeHtml?: boolean | SafeHtmlOptions;
+        /** @deprecated use safeHtml instead */
+        safeHTML?: boolean | SafeHtmlOptions;
+        options?: object;
+        tools?: ToolsConfig;
+        excludeTools?: string[];
+        blocks?: object[];
+        editor?: Partial<EditorSettings>;
+        fonts?: Fonts;
+        linkTypes?: LinkTypes;
+        linkTypesSharedConfig?: LinkTypesSharedConfig;
+        mergeTags?: MergeTags;
+        displayConditions?: DisplayConditions;
+        specialLinks?: SpecialLinks;
+        designTags?: DesignTags;
+        customCSS?: string | string[];
+        customJS?: string | string[];
+        locale?: string;
+        textDirection?: TextDirection;
+        translations?: Record<string, Record<string, string>>;
+        appearance?: DeepPartial<AppearanceConfig>;
+        features?: Features;
+        designTagsConfig?: DesignTagsConfig;
+        mergeTagsConfig?: MergeTagsConfig;
+        validator?: (info: {
+            html: ExportHtmlResult;
+            design: JSONTemplate;
+            defaultErrors: Audit[];
+        }) => Audit[] | Promise<Audit[]>;
+        tabs?: Tabs;
+    }
+    export interface SaveDesignOptions {
+    }
+    export interface ExportHtmlOptions {
+        amp?: boolean;
+        cleanup?: boolean;
+        inlineStyles?: boolean;
+        textDirection?: TextDirection;
+        isPreview?: boolean;
+        language?: string;
+        live?: boolean;
+        mergeTags?: MergeTagsValues;
+        minify?: boolean;
+        popupId?: string;
+        title?: string;
+        validateAmp?: boolean;
+        onlyHeader?: boolean;
+        onlyFooter?: boolean;
+    }
+    export interface ExportHtmlResult {
+        html: string;
+        amp: {
+            enabled: boolean;
+            format: 'AMP' | 'AMP4EMAIL';
+            html: string | undefined;
+            validation: ValidationResult;
+        };
+        chunks: ExportChunksResult;
+        design: JSONTemplate;
+    }
+    export interface ExportLiveHtmlOptions extends Omit<ExportHtmlOptions, 'live'> {
+    }
+    export interface ExportLiveHtmlResult extends ExportHtmlResult {
+    }
+    export interface ExportPlainTextOptions extends Omit<ExportHtmlOptions, 'cleanup' | 'minify'> {
+        ignorePreheader?: boolean;
+    }
+    export interface ExportPlainTextResult {
+        text: string;
+        design: JSONTemplate;
+    }
+    export interface HtmlToPlainTextOptions {
+        ignoreLinks?: boolean;
+        ignoreImages?: boolean;
+    }
+    export interface ExportChunksResult {
+        css: string;
+        js: string;
+        tags: string[];
+        fonts: FontList;
+        body: any;
+    }
+    export interface ExportPlainTextOptions {
+        ignoreLinks?: boolean;
+        ignoreImages?: boolean;
+        ignorePreheader?: boolean;
+        mergeTags?: Record<string, string>;
+    }
+    export interface ExportFromApiResult {
+        design: JSONTemplate;
+        url: string | null;
+        error?: string;
+    }
+    interface BaseExportFromApiOptions {
+        mergeTags?: Record<string, string>;
+        language?: string;
+    }
+    export interface ExportImageFromApiOptions extends BaseExportFromApiOptions {
+        width?: number;
+        height?: number;
+        fullPage?: boolean;
+        deviceScaleFactor?: number;
+    }
+    export interface ExportPdfFromApiOptions extends BaseExportFromApiOptions {
+    }
+    export interface ExportZipFromApiOptions extends BaseExportFromApiOptions {
+    }
+}
+declare module "engine/utils/findDeep" {
+    export function findDeep<T = any>(item: Record<string, T> | Array<T> | T, eq: ((item: T) => boolean) | unknown, { _path, _visited }?: {
+        _path?: string[];
+        _visited?: WeakMap<WeakKey, any>;
+    }): string[][];
+}
+declare module "embed/Frame" {
+    export type Message = object;
+    export interface MessageData {
+        action: string;
+        callbackId: number;
+        doneId: number;
+        result: unknown | undefined;
+        resultArgs: unknown[] | undefined;
+    }
+    export class Frame {
+        id: number;
+        ready: boolean;
+        iframe: HTMLIFrameElement | undefined;
+        messages: any[];
+        callbackId: number;
+        callbacks: {
+            [key: number]: Function | undefined;
+        };
+        constructor(src: string);
+        createIframe(src: string): HTMLIFrameElement;
+        destroy: () => void;
+        appendTo(el: Element): void;
+        onWindowMessage: (event: MessageEvent<any>) => void;
+        postMessage(action: string, message: Message): void;
+        withMessage(action: string, message: Message | undefined, callback?: Function): void;
+        _preprocessMessageFunctions(message: Message): Message;
+        preprocessMessage(message: Message): Message;
+        scheduleMessage(message: Message): void;
+        flushMessages(): void;
+        handleMessage({ action, callbackId, doneId, result: _result, resultArgs: _resultArgs, }: MessageData): void;
+        receiveMessage(event: any): void;
+    }
+    export const disableMultipleEditors: () => void;
+    export const disableOriginalFunctionReferences: () => void;
+    global {
+        interface Window {
+            __unlayer_lastFrameId: number;
+            __unlayer_multipleEditors: boolean;
+            __unlayer_originalFunctionReferences: boolean;
+        }
+    }
+}
+declare module "editor/components/common/Modal" {
+    import React from 'react';
+    import { Props as ReactModalProps } from 'react-modal';
+    export interface ModalProps extends Omit<ReactModalProps, 'style'> {
+        children: React.ReactNode;
+        className?: string;
+        contentStyle?: React.CSSProperties;
+        innerContentStyle?: React.CSSProperties;
+        overlayStyle?: React.CSSProperties;
+    }
+    export function Modal(props: ModalProps): React.JSX.Element;
+}
+declare module "editor/components/common/ConditionalWrap" {
+    import React from 'react';
+    export interface ConditionalWrapProps {
+        children: any;
+        condition: boolean;
+        wrap: (children: React.ReactElement<any>) => React.ReactNode;
+    }
+    export function ConditionalWrap(props: ConditionalWrapProps): any;
+}
+declare module "editor/components/common/Loader" {
+    import React from 'react';
+    export interface LoaderProps {
+        children?: React.ReactNode;
+        color?: boolean | string | ((props: {
+            theme: any;
+        }) => string);
+        fadeIn?: boolean;
+        loaded?: boolean;
+        loadedClassName?: string;
+        loadingClassName?: string;
+        size?: 'small' | 'normal';
+    }
+    export function Loader(props: LoaderProps): React.JSX.Element;
+}
+declare module "engine/utils/withHook" {
+    import React from 'react';
+    export function withHook<P extends object, C extends React.ComponentType<P>, HookName extends string, HookFn extends (props: P) => any>(Component: C, hookName: HookName, useHook: HookFn): React.MemoExoticComponent<React.ForwardRefExoticComponent<React.RefAttributes<unknown>>>;
+}
+declare module "editor/hooks/useForceRerender" {
+    export function useForceRerender({ debounce, throttle, }?: {
+        debounce?: boolean | number;
+        throttle?: boolean | number;
+    }): () => void;
+}
+declare module "editor/hooks/useConfig" {
+    import React from 'react';
+    export function useConfig(): any;
+    export function withConfig<C extends React.ComponentType>(Component: C): React.MemoExoticComponent<React.ForwardRefExoticComponent<React.RefAttributes<unknown>>>;
+}
+declare module "engine/utils/position" {
+    import { ArrayItem, DisplayMode } from "state/types/types";
+    export const ENABLE_BACKGROUND_POSITION_FOR_EMAILS = true;
+    export const positions: readonly ["top-left", "top-center", "top-right", "center-left", "center", "center-right", "bottom-left", "bottom-center", "bottom-right"];
+    export type Position = ArrayItem<typeof positions>;
+    export function positionToMarginArray(position: Position | undefined): string[] | readonly [0, "auto", "auto", 0] | readonly [0, "auto", "auto", "auto"] | readonly [0, 0, "auto", "auto"] | readonly ["auto", "auto", "auto", 0] | readonly ["auto"] | readonly ["auto", 0, "auto", "auto"] | readonly ["auto", "auto", 0, 0] | readonly ["auto", "auto", 0, "auto"] | readonly ["auto", 0, 0, "auto"];
+    export function positionToBackgroundPosition(position: Position | undefined): 'top left' | 'top center' | 'top right' | 'center left' | 'center center' | 'center right' | 'bottom left' | 'bottom center' | 'bottom right' | 'auto auto';
+    export function valuesToBackgroundPositionCSS(values: {
+        position: Position | 'custom' | undefined;
+        customPosition: [string, string] | undefined;
+    }, { displayMode }: {
+        displayMode: DisplayMode;
+    }): string;
+    export function positionToPercentages(position: Position | 'custom' | undefined): [x: string, y: string] | undefined;
+    export function normalizePosition(position: 'top' | 'top-left' | 'top-center' | 'top-right' | 'center' | 'center-left' | 'center-center' | 'center-right' | 'center-top' | 'center-bottom' | 'bottom' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'left' | 'left-top' | 'left-center' | 'left-bottom' | 'right' | 'right-top' | 'right-center' | 'right-bottom' | 'custom' | undefined): Position | undefined;
+}
+declare module "engine/utils/zod/zodSchemasToJsonSchemas" {
+    import { z } from 'zod/v4';
+    import { JSONSchema } from "state/types/types";
+    export function zodSchemasToJsonSchemas<K extends string>(zodSchemas: Partial<Record<K, z.ZodType | undefined>>): Record<K, JSONSchema>;
+}
+declare module "engine/utils/zod/propertyEditorSchemas" {
+    import { PropertyEditorZodSchemas } from '../../config';
+    export function propertyEditorZodSchemas<ValueSchema extends PropertyEditorZodSchemas['value']>(zodSchemas: Omit<PropertyEditorZodSchemas, 'value' | 'value__simple'> & {
+        value: ValueSchema;
+        value__simple: ((valueSchema: ValueSchema) => PropertyEditorZodSchemas['value__simple']) | PropertyEditorZodSchemas['value__simple'] | null | undefined;
+    }): {
+        zodSchemas: {
+            value__simple: any;
+            value: ValueSchema;
+        };
+        schemas: Record<"value" | "value__simple", import("state/types/types").JSONSchema>;
+    };
+}
+declare module "engine/utils/zod/types" {
+    import { z } from 'zod/v4';
+    import { EditorProps } from "editor/components/editors/types";
+    import { PropertyEditorZodSchemas } from '../../config';
+    export type EditorPropsFromZodSchemas<T extends Partial<PropertyEditorZodSchemas>> = EditorProps<z.infer<T['value']>, z.infer<T['widgetParams']>>;
+}
+declare module "editor/components/editors/PositionEditor" {
+    import React from 'react';
+    import { EditorPropsFromZodSchemas } from "engine/utils/zod/types";
+    export const schemas: Record<"value" | "value__simple", import("state/types/types").JSONSchema>, zodSchemas: {
+        value__simple: any;
+        value: any;
+    };
+    export type PositionEditorProps = EditorPropsFromZodSchemas<typeof zodSchemas>;
+    export function PositionEditor(props: PositionEditorProps): React.JSX.Element;
+    export function PositionEditorBase(props: Pick<PositionEditorProps, 'updateValue' | 'value' | 'widgetParams'> & {
+        className?: string;
+        itemSize?: number;
+        spacing?: number;
+        style?: React.CSSProperties;
+        valueLabelPosition?: 'left' | 'right' | 'none';
+    }): React.JSX.Element;
+}
+declare module "editor/hooks/useDynamicRef" {
+    export function useDynamicRef<T>(value: T): import("react").MutableRefObject<T>;
+}
+declare module "engine/utils/renderIcon" {
+    import React from 'react';
+    import * as config from '../../engine/config';
+    import { Icon } from "state/types/types";
+    import { IconDefinition } from '@fortawesome/pro-regular-svg-icons';
+    import { FontAwesomeIconProps } from '@fortawesome/react-fontawesome';
+    export function renderIcon(icon: Icon | Parameters<typeof config.normalizeIcon>[0] | undefined, { fallbackIcon, shouldShowFallbackIcon, size, divProps, }?: {
+        shouldShowFallbackIcon?: boolean;
+        fallbackIcon?: IconDefinition;
+        size?: FontAwesomeIconProps['size'];
+        divProps?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+    }): React.JSX.Element;
+}
+declare module "editor/design-system/components/Input" {
+    import React from 'react';
+    import * as Ariakit from '@ariakit/react';
+    import { IconDefinition } from '@fortawesome/pro-regular-svg-icons';
+    import { Icon } from "state/types/types";
+    export interface InputProps extends Omit<Ariakit.FormInputProps, 'as' | 'onSubmit' | 'onSubmitCapture'> {
+        containerStyle?: React.CSSProperties;
+        formStore?: Ariakit.FormStore<{
+            value: string;
+        }>;
+        icon?: Icon | IconDefinition;
+        inputFooter?: React.ReactNode;
+        inputHeader?: React.ReactNode;
+        inputStyle?: React.CSSProperties;
+        label?: React.ReactNode;
+        labelPosition?: 'top' | 'left' | 'right';
+        maxRows?: number;
+        minRows?: number;
+        name: string;
+        onClear?: () => void;
+        onSubmit: (value: string | number) => void;
+        placeholder?: string;
+        required?: boolean;
+        type?: Ariakit.FormInputProps['type'] | 'textarea';
+        validationDOMTarget?: HTMLDivElement | null;
+        validationMessage?: string;
+        validationStatus?: 'error' | 'warn' | 'success';
+        value: string | number;
+    }
+    export const Input: React.ForwardRefExoticComponent<Omit<InputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+    export const CSS: {
+        label: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
+    };
+    export const S: {
+        Form: import("styled-components").StyledComponent<any, any, any, any>;
+        FormInputGroup: import("styled-components").StyledComponent<any, any, any, any>;
+        FormLabel: import("styled-components").StyledComponent<any, any, any, any>;
+        FormInputWrapper: import("styled-components").StyledComponent<"div", any, {
+            className: "input-wrapper";
+        }, "className">;
+        FormInput: import("styled-components").StyledComponent<any, any, any, any>;
+        Message: import("styled-components").StyledComponent<"div", any, {}, never>;
+        ClearButton: import("styled-components").StyledComponent<any, any, any, any>;
+    };
+}
+declare module "editor/helpers/extractStringsFromReactNode" {
+    import React from 'react';
+    export function extractStringsFromReactNode(node: React.ReactNode): string;
+}
+declare module "editor/design-system/components/Tooltip" {
+    import React from 'react';
+    import * as Ariakit from '@ariakit/react';
+    export interface TooltipProps {
+        arrow?: boolean;
+        children?: Ariakit.TooltipAnchorProps['children'];
+        className?: string;
+        disabled?: boolean;
+        gutter?: Ariakit.TooltipProps['gutter'];
+        placement: Ariakit.TooltipStoreProps['placement'];
+        style?: React.CSSProperties;
+        timeout?: Ariakit.TooltipStoreProps['timeout'];
+        tooltip: Ariakit.TooltipProps['children'];
+        tooltipWrapper?: Ariakit.TooltipAnchorProps['render'];
+    }
+    export function Tooltip(props: TooltipProps): React.JSX.Element;
+}
+declare module "editor/design-system/components/Button" {
+    import React from 'react';
+    import * as Ariakit from '@ariakit/react';
+    import { IconProp } from '@fortawesome/fontawesome-svg-core';
+    import { Theme } from "editor/themes/types";
+    import { TooltipProps } from "editor/design-system/components/Tooltip";
+    export interface ButtonProps extends Ariakit.ButtonProps {
+        children?: React.ReactNode;
+        circle?: boolean;
+        className?: string;
+        contentAlign?: 'left' | 'center' | 'right';
+        danger?: boolean;
+        disabled?: boolean;
+        icon?: IconProp;
+        id?: string;
+        loading?: boolean;
+        onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+        rounded?: boolean;
+        size?: number | 'auto';
+        style?: React.CSSProperties;
+        tooltip?: string;
+        tooltipPlacement?: TooltipProps['placement'];
+        truncate?: boolean;
+        type?: Ariakit.ButtonProps['type'];
+        variant?: keyof Theme['components']['buttons'];
+    }
+    export const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<unknown>>;
+}
+declare module "editor/helpers/intl" {
+    import _ from 'lodash';
+    import { IntlShape } from 'react-intl';
+    function _getIntlLabel<Label extends any>(intl: IntlShape, label: string | Label): string | Label;
+    export const getIntlLabel: typeof _getIntlLabel & _.MemoizedFunction;
+}
+declare module "editor/design-system/components/Dropdown" {
+    import React from 'react';
+    import * as Ariakit from '@ariakit/react';
+    import { IconDefinition } from '@fortawesome/pro-regular-svg-icons';
+    import { TooltipProps } from "editor/design-system/components/Tooltip";
+    export interface SelectOption {
+        icon?: IconDefinition;
+        label: string;
+        value: any;
+        key?: string;
+        tooltip?: string;
+        tooltipPlacement?: TooltipProps['placement'];
+        meta?: Record<string, unknown>;
+        onClick?: (e: React.MouseEvent, selected: boolean) => void;
+        selected: boolean;
+        disabled?: boolean;
+        toggle?: boolean;
+        attrs?: Record<string, string | number | boolean | undefined>;
+    }
+    export interface SelectOptionGroup {
+        name?: string;
+        label?: string;
+        icon?: IconDefinition;
+        options: SelectOption[];
+        meta?: object;
+    }
+    export type DropdownProps = {
+        ariaLabel?: string;
+        asLink?: boolean;
+        badge?: number | boolean;
+        className?: string;
+        icon?: IconDefinition;
+        caret?: boolean;
+        disabled?: boolean;
+        fallbackLabel?: string;
+        id?: string;
+        label?: React.ReactNode;
+        multi?: boolean;
+        triggerLabel?: string | React.ReactNode;
+        placement?: Ariakit.PopoverStoreState['placement'];
+        onChange?: (option: SelectOption) => void;
+        onClose?: () => void;
+        onOpen?: () => void;
+        renderButton?: Ariakit.SelectProps['render'];
+        renderFooter?: () => React.ReactNode;
+        renderHeader?: () => React.ReactNode;
+        style?: React.CSSProperties;
+        customPopoverStyles?: React.CSSProperties;
+        tooltip?: string;
+        title?: string;
+        tooltipPlacement?: TooltipProps['placement'];
+    } & ({
+        renderOption?: (option: SelectOption) => React.ReactNode;
+        renderOptionLabel?: never;
+    } | {
+        renderOption?: never;
+        renderOptionLabel?: (option: SelectOption) => React.ReactNode;
+    }) & ({
+        options?: never;
+        groupedOptions?: Array<SelectOptionGroup | undefined>;
+        renderOptionGroupHeader?: (optionGroup: SelectOptionGroup) => React.ReactNode;
+    } | {
+        options?: Array<SelectOption | undefined>;
+        groupedOptions?: never;
+        renderOptionGroupHeader?: never;
+    });
+    export function Dropdown(props: DropdownProps): React.JSX.Element;
+}
+declare module "editor/themes/helpers" {
+    import { Theme, ThemeExtension } from "editor/themes/types";
+    export function extendTheme<TE extends ThemeExtension, BT extends Theme>(themeExtension: TE, baseTheme: BT): BT;
+    export function postprocessTheme<T extends Theme>(theme: T): T;
+    export function parseThemeValues<T extends Theme>(theme: T): T;
+}
+declare module "editor/themes/modern/light" {
+    import { DeprecatedTheme, Theme } from "editor/themes/types";
+    export const unparsedTheme: Theme & DeprecatedTheme;
+}
+declare module "editor/themes/classic/light" {
+    export const unparsedTheme: import("editor/themes/types").Theme & import("editor/themes/types").DeprecatedTheme;
+}
+declare module "editor/themes/modern/dark" {
+    import { DeprecatedTheme, Theme } from "editor/themes/types";
+    export const unparsedTheme: Theme & DeprecatedTheme;
+}
+declare module "editor/themes/classic/dark" {
+    export const unparsedTheme: import("editor/themes/types").Theme & import("editor/themes/types").DeprecatedTheme;
+}
+declare module "editor/themes/index" {
+    const themes: {
+        classic_light: import("editor/themes/types").Theme & import("editor/themes/types").DeprecatedTheme;
+        classic_dark: import("editor/themes/types").Theme & import("editor/themes/types").DeprecatedTheme;
+        modern_light: import("editor/themes/types").Theme & import("editor/themes/types").DeprecatedTheme;
+        modern_dark: import("editor/themes/types").Theme & import("editor/themes/types").DeprecatedTheme;
+    };
+    export default themes;
+}
+declare module "editor/hooks/useTheme" {
+    import React from 'react';
+    import { DeprecatedTheme, Theme } from "editor/themes/types";
+    export function ThemeProvider(props: React.PropsWithChildren): React.JSX.Element;
+    export function ThemeConsumer(props: {
+        children: React.ReactNode | ((params: {
+            theme: any;
+        }) => React.ReactNode);
+    }): React.ReactNode;
+    export function useThemeInternal(): Theme & DeprecatedTheme;
+    export function useTheme(): Theme & DeprecatedTheme;
+}
+declare module "editor/design-system/components/CounterInput" {
+    import React from 'react';
+    import { DisplayMode } from "state/types/types";
+    import { InputProps } from "editor/design-system/components/Input";
+    export interface CounterInputProps {
+        absoluteBaseValue?: number;
+        containerStyle?: React.CSSProperties;
+        defaultUnit?: string;
+        disabled?: boolean;
+        displayMode: DisplayMode;
+        inputStyle?: InputProps['style'];
+        mainContainerStyle?: React.CSSProperties;
+        maxValue?: number | null;
+        minValue?: number | null;
+        onChange: (value: number | string) => void;
+        shouldRenderIncrementDecrementButtons?: boolean;
+        step?: number;
+        units?: string[];
+        unitSupportedDisplayModes?: string[];
+        validationDOMTarget?: InputProps['validationDOMTarget'];
+        value: number | string;
+    }
+    export default function CounterInput(props: CounterInputProps): React.JSX.Element;
+}
+declare module "editor/components/editors/common/Counter" {
+    import React from 'react';
+    import { CounterInputProps } from "editor/design-system/components/CounterInput";
+    export interface CounterProps extends Omit<CounterInputProps, 'displayMode'> {
+        right?: boolean;
+    }
+    export default function Counter(props: CounterProps): React.JSX.Element;
+}
+declare module "engine/utils/sizeUtils" {
+    import { DisplayMode } from "state/types/types";
+    export const ENABLE_BACKGROUND_SIZE_FOR_EMAILS = false;
+    export function normalizeFloat(n: number | string | undefined, decimalsPlace?: number): number;
+    export function normalizeSize(size: number | string | undefined, { decimalsPlace }?: {
+        decimalsPlace?: number;
+    }): string;
+    export function calculateExactSize(size: number | string, maxSize: number | undefined, options?: {
+        decimalsPlace?: number;
+        ifNumberConsiderAsPercentage?: boolean;
+    }): number | undefined;
+    export function valuesToBackgroundSizeCSS(values: {
+        size: 'contain' | 'cover' | 'custom' | undefined;
+        customSize: [string, string];
+    }, { displayMode }: {
+        displayMode: DisplayMode;
+    }): string;
+}
+declare module "engine/config/mergeTags" {
+    import { MergeTags } from "state/types/types";
+    export function getMergeTags(): MergeTags;
+    export function getMergeTagsVersion(): number;
+    export function setMergeTags(_mergeTags: MergeTags): void;
+}
+declare module "engine/utils/htmlEntities" {
+    export function encodeHtmlEntities(str: string | undefined, { modes }?: {
+        modes?: Array<keyof typeof replacers>;
+    }): string;
+    const replacers: {
+        accents: (str: string | undefined) => string;
+        all: (str: string | undefined) => string;
+        others: (str: string | undefined) => string;
+        tags: (str: string | undefined) => string;
+    };
+}
+declare module "engine/utils/encodeMergeTag" {
+    export function encodeMergeTag(str: string | undefined): string;
+}
+declare module "engine/utils/escapeHtml" {
+    export function escapeHtml(str: string | undefined, { escapeAndOperator, // This was causing issues by changing & in links to &amp;
+    escapeLT, escapeGT, escapeDoubleQuotes, escapeSingleQuotes, }?: {
+        escapeAndOperator?: boolean;
+        escapeLT?: boolean;
+        escapeGT?: boolean;
+        escapeDoubleQuotes?: boolean;
+        escapeSingleQuotes?: boolean;
+    }): string;
+}
+declare module "engine/utils/escapeRegexString" {
+    export function escapeRegexString(str: string): string;
+}
+declare module "engine/utils/getNumberOrString" {
+    export function getNumberOrString(str: string | number): string | number;
+}
+declare module "engine/utils/flattenMergeTags" {
+    import { MergeTag, MergeTags, MergeTagsConfig } from "state/types/types";
+    export type MergeTagWithMeta = MergeTag & {
+        _meta: {
+            key: string;
+            tree: Array<Omit<MergeTag, 'mergeTags'> & {
+                _meta?: Omit<MergeTagWithMeta['_meta'], 'tree'>;
+            }>;
+        };
+    };
+    function _flattenMergeTags(mergeTags: Array<MergeTag | MergeTagWithMeta> | MergeTags, mergeTagsConfig?: Pick<MergeTagsConfig, 'sort'>, _internal?: Pick<MergeTagWithMeta['_meta'], 'tree'>): Array<MergeTagWithMeta>;
+    export const flattenMergeTags: typeof _flattenMergeTags & import("lodash").MemoizedFunction;
+    export function getMergeTagLabel(mergeTag: MergeTagWithMeta['_meta']['tree'][0] | undefined): string;
+    export function getMergeTagFlatLabel(mergeTag: MergeTagWithMeta | undefined): string;
+}
+declare module "engine/utils/testBrowserFeatures" {
+    export function supportsRegexLookAheadLookBehind(): boolean;
+    export function replaceWithLookBehind(str: string, lookbBehindStr: string, regex: RegExp, replacement: string): string;
+}
+declare module "engine/utils/applyMergeTagsToHtml" {
+    import { MergeTags, MergeTagsValues } from "state/types/types";
+    export function applyMergeTagsToHtml(html: string | undefined, { mergeTagsSchema, mergeTagsValues: _mergeTagsValues, _skipTags, _useRawValue, }: {
+        mergeTagsSchema: MergeTags | undefined;
+        mergeTagsValues: MergeTagsValues | undefined;
+        _skipTags?: boolean;
+        _useRawValue?: boolean;
+    }): string;
+}
+declare module "engine/utils/generateMergeTagHtml" {
+    import { Icon, MergeTag } from "state/types/types";
+    export function generateMergeTagHtml(mergeTag: Pick<MergeTag, 'name' | 'value' | 'sample'> & {
+        icon?: Icon | string;
+    }, tool?: 'paragraph' | 'text'): string;
+}
+declare module "engine/utils/applyMergeTagPreviewHtmlToText" {
+    function _applyMergeTagPreviewHtmlToText(text: string | undefined, { type, tool, }?: {
+        type?: 'smart' | 'raw';
+        tool?: 'paragraph' | 'text';
+    }): string;
+    export const applyMergeTagPreviewHtmlToText: typeof _applyMergeTagPreviewHtmlToText & import("lodash").MemoizedFunction;
+}
+declare module "editor/design-system/components/SegmentedControl" {
+    import React from 'react';
+    import { IconDefinition } from '@fortawesome/pro-regular-svg-icons';
+    export interface SegmentedControlItem {
+        key?: string;
+        icon?: IconDefinition;
+        label?: string;
+        onClick?: (e: React.MouseEvent) => void;
+        selected?: boolean;
+        disabled?: boolean;
+        tooltip?: string;
+        meta?: object;
+    }
+    export interface SegmentedControlProps {
+        autoFocus?: boolean;
+        className?: string;
+        disabled?: boolean;
+        items: SegmentedControlItem[];
+        renderLabel?: (item: SegmentedControlItem) => React.ReactNode;
+    }
+    export function SegmentedControl(props: SegmentedControlProps): React.JSX.Element;
+}
+declare module "engine/config/env" {
+    export const env: {
+        API_V1_BASE_URL: string;
+        API_V2_BASE_URL: string;
+        API_V3_BASE_URL: string;
+        EVENTS_API_BASE_URL: string;
+        TOOLS_API_V1_BASE_URL: string;
+        TOOLS_CDN_BASE_URL: string;
+        CONSOLE_BASE_URL: string;
+    };
+    export function setIsTest(isTest: boolean): void;
+    export function isTest(): boolean;
+    global {
+        interface Window {
+            Cypress?: unknown;
+        }
+    }
+}
+declare module "editor/helpers/image" {
+    import _ from 'lodash';
+    export function fetchImage(imageURL: string, { proxyURL, retryWithoutProxy, }?: {
+        proxyURL?: string;
+        retryWithoutProxy?: boolean;
+    }): Promise<{
+        blob: Blob;
+        url: string;
+    }>;
+    export function tryFetchImageBlob(imageURL: string, requestOptions?: RequestInit | HeadersInit, { cache }?: {
+        cache?: boolean;
+    }): Promise<Blob>;
+    export function getImageUrlWithProxy(imageURL: string, { proxyURL }?: {
+        proxyURL?: string;
+    }): string;
+    export function fetchImageViaProxy(imageURL: string, { proxyURL, retryWithoutProxy, }?: {
+        proxyURL?: string;
+        retryWithoutProxy?: boolean;
+    }): Promise<{
+        blob: Blob;
+        url: string;
+    }>;
+    export const tryLoadImageFromStringOrBlob: ((imageSrcOrBlob: string | Blob) => Promise<{
+        image: {
+            width: number;
+            height: number;
+            src: string;
+        };
+        imgElement: HTMLImageElement;
+    }>) & _.MemoizedFunction;
+    export function loadImageDimensions(imageSrcOrBlob: string | Blob): Promise<{
+        width: number | undefined;
+        height: number | undefined;
+        error?: string;
+    }>;
+    export function imageHasTransparency(imageSrcOrBlob: string | Blob, { minimumPercentageOfAlphaPixels, }?: {
+        minimumPercentageOfAlphaPixels?: number;
+    }): Promise<boolean | null>;
+}
+declare module "editor/hooks/useImageUploader" {
+    import { useStore } from 'react-redux';
+    import { ImageSource } from "state/types/types";
+    type Store = Pick<ReturnType<typeof useStore>, 'dispatch' | 'getState'>;
+    export interface Params {
+        maxSize?: number | null;
+        onErrorChange?: (error: Error | null) => void;
+        onImageSelect?: (image?: {
+            id?: string | number;
+            url: string;
+            width?: number;
+            height?: number;
+            size?: number;
+        }) => void;
+        onImageUpload?: (image: {
+            id?: string | number;
+            url: string;
+            width?: number;
+            height?: number;
+            optimistic?: boolean;
+        }) => void;
+        onUploadProgressChange?: (progress: number) => void;
+        onUploadStatusChange?: (isUploading: boolean) => void;
+        shouldReloadUserUploadsAfterUpload?: boolean;
+        shouldTriggerReduxOptimisticUpdate?: boolean;
+    }
+    export function useImageUploader(params: Params): {
+        error: Error;
+        isUploading: boolean;
+        startUploadFlow: (images: FileList | Array<File | Blob | string> | null, source: ImageSource) => void;
+        setError: import("react").Dispatch<import("react").SetStateAction<Error>>;
+        triggerSelectImageCallback: () => void;
+        uploadProgress: number;
+    };
+    function triggerImageUploadCallback(images: FileList | Array<File | Blob | string>, source: ImageSource, { maxSize, onErrorOrNull, onImageUpload, project, setIsUploading, setUploadProgress, shouldReloadUserUploadsAfterUpload, shouldTriggerReduxOptimisticUpdate, store, userId, }: {
+        maxSize?: Params['maxSize'];
+        onErrorOrNull?: (error: Error | null) => void;
+        onImageUpload?: Params['onImageUpload'];
+        project: {
+            id?: number;
+        } | null;
+        setIsUploading?: Params['onUploadStatusChange'];
+        setUploadProgress?: Params['onUploadProgressChange'];
+        shouldReloadUserUploadsAfterUpload?: Params['shouldReloadUserUploadsAfterUpload'];
+        shouldTriggerReduxOptimisticUpdate?: Params['shouldTriggerReduxOptimisticUpdate'];
+        store: Store;
+        userId: string;
+    }): Promise<void>;
+    function uploadFiles(images: FileList | Array<File | Blob | string>, source: ImageSource, { maxSize, onErrorOrNull, onImageUpload, project, setIsUploading, setUploadProgress, shouldReloadUserUploadsAfterUpload, shouldTriggerReduxOptimisticUpdate, store, userId, }: {
+        maxSize?: Params['maxSize'];
+        onErrorOrNull?: (error: Error | null) => void;
+        onImageUpload?: Params['onImageUpload'];
+        project: {
+            id?: number;
+            storage?: boolean;
+        } | null;
+        setIsUploading?: Params['onUploadStatusChange'];
+        setUploadProgress?: Params['onUploadProgressChange'];
+        shouldReloadUserUploadsAfterUpload?: Params['shouldReloadUserUploadsAfterUpload'];
+        shouldTriggerReduxOptimisticUpdate?: Params['shouldTriggerReduxOptimisticUpdate'];
+        store: Store;
+        userId: string;
+    }): Promise<void>;
+    export function startUploadFlow(images: FileList | Array<File | Blob | string> | null, source: ImageSource, params: Parameters<typeof triggerImageUploadCallback>[2] & Parameters<typeof uploadFiles>[2]): Promise<void>;
+    export function convertImagesToFileOrBlob(images: FileList | Array<File | Blob | string | undefined | null> | undefined | null): Promise<Array<File | Blob>>;
+    export class ImageMaxSizeExceededError extends Error {
+        maxSize: number;
+        size: number;
+        constructor({ size, maxSize }: {
+            size: number;
+            maxSize: number;
+        }, message?: string, ...params: any[]);
+    }
+}
+declare module "editor/components/common/ImageUploadButton" {
+    import React from 'react';
+    import { ImageSource } from "state/types/types";
+    import { ButtonProps } from "editor/design-system/components/Button";
+    export interface ImageUploadButtonInstance {
+        clearError: () => void;
+        openPicker: () => void;
+        startUploadFlow: (images: FileList | Array<File | Blob | string> | null, source: ImageSource) => void;
+    }
+    export interface ImageUploadButtonProps {
+        buttonProps?: ButtonProps;
+        disableProgressIndicator?: boolean;
+        disabled?: boolean;
+        maxSize?: number;
+        onErrorChange?: (error: Error | null) => void;
+        onImageSelect?: (image?: {
+            id?: string | number;
+            url: string;
+            width?: number;
+            height?: number;
+        }) => void;
+        onImageUpload?: (image: {
+            id?: string | number;
+            url: string;
+            width?: number;
+            height?: number;
+            optimistic?: boolean;
+        }) => void;
+        onUploadProgressChange?: (progress: number) => void;
+        onUploadStatusChange?: (isUploading: boolean) => void;
+        shouldReloadUserUploadsAfterUpload?: boolean;
+        shouldTriggerReduxOptimisticUpdate?: boolean;
+        showError?: boolean;
+    }
+    export const ImageUploadButton: React.ForwardRefExoticComponent<ImageUploadButtonProps & React.RefAttributes<ImageUploadButtonInstance>>;
+}
+declare module "editor/design-system/components/Progress" {
+    import React from 'react';
+    export interface ProgressBarProps {
+        progress: number;
+        className?: string;
+        color?: string;
+        backgroundColor?: string;
+        height?: string;
+        animationDuration?: number;
+    }
+    export function Progress(props: ProgressBarProps): React.JSX.Element;
+}
+declare module "engine/utils/explodePaddingsOrMargins" {
+    export function explodePaddingsOrMargins(value: number | string | undefined): {
+        top: number | undefined;
+        right: number | undefined;
+        bottom: number | undefined;
+        left: number | undefined;
+    };
+}
+declare module "editor/components/editors/common/WidgetLabel" {
+    import React from 'react';
+    import { Device, Location } from "state/types/types";
+    export type WidgetLabelProps = {
+        children?: React.ReactNode;
+        className?: string;
+        defaultValue?: any;
+        deviceName?: Device;
+        disabled?: boolean;
+        getValue?: (deviceName?: Device | undefined) => any;
+        infoTooltip?: string;
+        isLocked?: boolean;
+        lockReason?: 'styleguide' | 'admin' | undefined;
+        location?: Location;
+        name?: string;
+        onReset?: (data: {
+            value: any;
+            deviceName: Device | undefined;
+        }) => void;
+    };
+    export function WidgetLabel(props: WidgetLabelProps): React.JSX.Element;
+    export function getOptionModificationInfo({ defaultValue, deviceName, getValue, optionName, }: {
+        defaultValue: any;
+        deviceName: Device | null | undefined;
+        getValue: NonNullable<WidgetLabelProps['getValue']>;
+        optionName: string;
+    }): {
+        hasValue: boolean;
+        isOverride: boolean;
+        isSameValue: boolean;
+        showResetButton: boolean;
+    };
+}
+declare module "editor/design-system/components/ToggleSwitch" {
+    import React from 'react';
+    export interface ToggleSwitchProps {
+        children?: React.ReactNode;
+        className?: string;
+        disabled?: boolean;
+        isChecked: boolean;
+        left?: React.ReactNode;
+        onChange: (isChecked: boolean) => void;
+        right?: React.ReactNode;
+        toggleLeft?: React.ReactNode;
+        size?: number;
+        style?: React.CSSProperties;
+    }
+    export const ToggleSwitch: React.ForwardRefExoticComponent<ToggleSwitchProps & React.RefAttributes<HTMLLabelElement>>;
+}
+declare module "editor/components/editors/AutoWidthEditor" {
+    import * as React from 'react';
+    import { WidgetLabelProps } from "editor/components/editors/common/WidgetLabel";
+    import { Device } from "state/types/types";
+    import { EditorPropsFromZodSchemas } from "engine/utils/zod/types";
+    export const schemas: Record<"value" | "value__simple", import("state/types/types").JSONSchema>, zodSchemas: {
+        value__simple: any;
+        value: any;
+    };
+    export type AutoWidthEditorProps = EditorPropsFromZodSchemas<typeof zodSchemas>;
+    export interface AutoWidthEditorBaseProps extends Pick<AutoWidthEditorProps, 'value' | 'defaultValue' | 'disabled' | 'isLocked' | 'lockReason'> {
+        defaultWidthIsCalculated?: boolean;
+        deviceName?: Device;
+        widgetLabelProps: Omit<WidgetLabelProps, 'defaultValue' | 'onReset'>;
+        handlers: {
+            onToggleAutoWidth: (autoWidth: NonNullable<AutoWidthEditorProps['value']>['autoWidth']) => void;
+            onChangeWidth: (width: number) => void;
+            onReset: NonNullable<WidgetLabelProps['onReset']>;
+        };
+    }
+    export const AutoWidthEditorBase: (props: AutoWidthEditorBaseProps) => React.JSX.Element;
+}
+declare module "engine/utils/isUrl" {
+    export function isUrl(value: any): boolean;
+}
+declare module "editor/helpers/placeholders" {
+    export const DEFAULT_IMAGE_PLACEHOLDER = "https://cdn.tools.unlayer.com/image/placeholder.png";
+    export const DEFAULT_CAROUSEL_PLACEHOLDER = "https://cdn.tools.unlayer.com/carousel/placeholder.png";
+    type ToolType = 'image' | 'carousel';
+    export function getPlaceholderUrl(type: ToolType): string;
+}
+declare module "engine/utils/explodeBorder" {
+    export function explodeBorder(value: number | string | {
+        borderTopWidth?: string;
+        borderTopStyle?: string;
+        borderTopColor?: string;
+        borderLeftWidth?: string;
+        borderLeftStyle?: string;
+        borderLeftColor?: string;
+        borderRightWidth?: string;
+        borderRightStyle?: string;
+        borderRightColor?: string;
+        borderBottomWidth?: string;
+        borderBottomStyle?: string;
+        borderBottomColor?: string;
+    } | undefined): {
+        top: number | undefined;
+        right: number | undefined;
+        bottom: number | undefined;
+        left: number | undefined;
+    };
+}
+declare module "engine/utils/imageRendering" {
+    import { explodePaddingsOrMargins } from "engine/utils/explodePaddingsOrMargins";
+    import { explodeBorder } from "engine/utils/explodeBorder";
+    export function isFixedContentWidth(bodyValues?: {
+        contentWidth: number | string;
+    }): boolean;
+    export function getBodyAvailableWidth({ body, fallbackBodyContentWidth, }: {
+        body: {
+            values: {
+                contentWidth: number | string;
+                padding?: Parameters<typeof explodePaddingsOrMargins>[0];
+                border?: Parameters<typeof explodeBorder>[0];
+            };
+        };
+        fallbackBodyContentWidth?: number;
+    }): number;
+    export function getRowAvailableWidth({ body, row, }: {
+        body: Parameters<typeof getBodyAvailableWidth>[0]['body'];
+        row: {
+            values: {
+                padding: Parameters<typeof explodePaddingsOrMargins>[0];
+                border?: Parameters<typeof explodeBorder>[0];
+            };
+        };
+    }): number;
+    export function getColumnAvailableWidth({ body, row, column, }: {
+        body: Parameters<typeof getRowAvailableWidth>[0]['body'];
+        row: Parameters<typeof getRowAvailableWidth>[0]['row'] & {
+            cells: number[];
+        };
+        column: {
+            index: number;
+            values: {
+                padding: Parameters<typeof explodePaddingsOrMargins>[0];
+                border: Parameters<typeof explodeBorder>[0];
+            };
+        };
+    }): number;
+    export function getContentAvailableWidth({ body, row, column, item, }: {
+        body: Parameters<typeof getColumnAvailableWidth>[0]['body'];
+        row: Parameters<typeof getColumnAvailableWidth>[0]['row'];
+        column: Parameters<typeof getColumnAvailableWidth>[0]['column'];
+        item: {
+            values: {
+                containerPadding?: Parameters<typeof explodePaddingsOrMargins>[0];
+                border?: Parameters<typeof explodeBorder>[0];
+            };
+        };
+    }): number;
+    export function getAvailableWidth({ values, columnIndex, columnValues, rowCells, rowValues, bodyValues, }: {
+        values: Parameters<typeof getContentAvailableWidth>[0]['item']['values'];
+        columnIndex: Parameters<typeof getContentAvailableWidth>[0]['column']['index'];
+        columnValues: Parameters<typeof getContentAvailableWidth>[0]['column']['values'];
+        rowCells: Parameters<typeof getContentAvailableWidth>[0]['row']['cells'];
+        rowValues: Parameters<typeof getContentAvailableWidth>[0]['row']['values'];
+        bodyValues: Parameters<typeof getContentAvailableWidth>[0]['body']['values'];
+    }): number;
+    export function getImageWidthAndMaxWidth(widthValue: {
+        autoWidth?: boolean;
+        maxWidth?: number | string;
+        width?: number;
+    }, availableWidth?: number): {
+        width: string;
+        maxWidth: string;
+    };
+    export function getImageProperties(widthValue: {
+        autoWidth?: boolean;
+        maxWidth?: number | string;
+        width?: number;
+    }, availableWidth?: number, optionName?: string): {
+        imageCSSClassName: string;
+        imageStyleObj: {
+            width: string;
+            maxWidth: string;
+        };
+        imageCSSStyle: string;
+    };
+    export function getDynamicImageUrl(src: string | undefined, params: {
+        allowUpscale?: boolean;
+        dynamic?: boolean;
+        resizeWidth: number | string | undefined;
+        originalWidth: number | string | undefined;
+    }): string;
+}
+declare module "editor/components/editors/pixie/pixie.umd" {
+    const _exports: {
+        new (t: any): {
+            readonly state: any;
+            readonly defaultConfig: any;
+            open(t?: {}): Promise<any>;
+            close(): void;
+            setConfig(t: any): void;
+            uploadAndAddImage(): any;
+            uploadAndReplaceMainImage(): any;
+            uploadAndOpenStateFile(): any;
+            newCanvas(t: any, n: any, r: any): any;
+            getState(t: any): string;
+            setState(t: any): any;
+            setStateFromUrl(t: any): Promise<any>;
+            openTool(t: any): void;
+            applyChanges(): void;
+            cancelChanges(): void;
+            resetEditor(t: any): Promise<void>;
+            togglePanel(t: any, n: any): void;
+            on(t: any, n: any): void;
+            isDirty(): any;
+            get(t: any): any;
+            notify(t: any): void;
+        };
+        init(t: any): Promise<any>;
+    };
+    export = _exports;
+}
+declare module "editor/design-system/components/Popover" {
+    import React from 'react';
+    import * as Ariakit from '@ariakit/react';
+    export type PopoverProps = {
+        arrow?: boolean;
+        autoFocusOnHide?: boolean;
+        autoFocusOnShow?: boolean;
+        children: Ariakit.PopoverAnchorProps['children'];
+        className?: string;
+        content: Ariakit.PopoverProps['children'];
+        defaultOpen?: Ariakit.PopoverStoreProps['defaultOpen'];
+        destroyOnHide?: boolean;
+        disabled?: boolean;
+        forcedOpenState?: boolean;
+        gutter?: Ariakit.PopoverOptions['gutter'];
+        onHide?: () => void;
+        onShow?: () => void;
+        placement: Ariakit.PopoverStoreProps['placement'];
+        portal?: Ariakit.PopoverOptions['portal'];
+        portalParent?: 'body' | 'editor';
+        style?: React.CSSProperties;
+        wrapper?: Ariakit.PopoverAnchorProps['render'];
+    } & ({
+        showOnHover?: false;
+        hideTimeout?: never;
+        showTimeout?: never;
+        timeout?: never;
+    } | {
+        showOnHover?: true;
+        hideTimeout?: Ariakit.HovercardStoreProps['hideTimeout'];
+        showTimeout?: Ariakit.HovercardStoreProps['showTimeout'];
+        timeout?: Ariakit.HovercardStoreProps['timeout'];
+    });
+    export interface PopoverInstance {
+        isOpen: boolean;
+        show: () => void;
+        hide: () => void;
+    }
+    export const Popover: React.ForwardRefExoticComponent<PopoverProps & React.RefAttributes<PopoverInstance>>;
+    export const CSS: {
+        popover: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
+        anchor: import("styled-components").FlattenSimpleInterpolation;
+        arrow: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
+    };
+}
+declare module "editor/design-system/components/Bar" {
+    import React, { ReactNode } from 'react';
+    import { IconDefinition } from '@fortawesome/pro-regular-svg-icons';
+    import { TooltipProps } from "editor/design-system/components/Tooltip";
+    import { DropdownProps } from "editor/design-system/components/Dropdown";
+    import { PopoverProps } from "editor/design-system/components/Popover";
+    export const BAR_HEIGHT = 40;
+    export const BAR_ITEM_WIDTH = 50;
+    export const BAR_ITEM_COMPACT_WIDTH = 30;
+    export interface SelectOption {
+        icon?: IconDefinition;
+        label: string;
+        value: any;
+        tooltip?: string;
+        tooltipPlacement?: TooltipProps['placement'];
+        meta?: object;
+        onClick?: (e: React.MouseEvent, selected: boolean) => void;
+        selected?: boolean;
+        toggle?: boolean;
+    }
+    export interface SelectOptionGroup {
+        name?: string;
+        label?: string;
+        icon?: IconDefinition;
+        options: SelectOption[];
+        meta?: object;
+    }
+    export interface BarTitleItem {
+        key: string;
+        type: 'title';
+        level?: 1 | 2 | 3 | 4 | 5 | 6;
+        ai?: boolean;
+        icon?: IconDefinition;
+        text: string | React.ReactElement;
+        tooltip?: string;
+        tooltipPlacement?: TooltipProps['placement'];
+        badge?: number | boolean;
+        loading?: boolean;
+    }
+    export interface BarButtonItem {
+        key: string;
+        type: 'button';
+        ai?: boolean;
+        id?: string;
+        className?: string;
+        icon: IconDefinition | null | undefined;
+        label?: string;
+        tooltip?: string;
+        tooltipPlacement?: TooltipProps['placement'];
+        badge?: number | boolean;
+        onClick?: (e: React.MouseEvent) => void;
+        destructive?: boolean;
+        disabled?: boolean;
+        loading?: boolean;
+        selected?: boolean;
+        highlighted?: boolean;
+        autoFocus?: boolean;
+    }
+    export interface BarToggleItem {
+        key: string;
+        type: 'toggle';
+        icon: IconDefinition;
+        tooltip?: string;
+        tooltipPlacement?: TooltipProps['placement'];
+        label?: string;
+        badge?: number | boolean;
+        onClick?: (e: React.MouseEvent) => void;
+        onChange: (enabled: boolean) => void;
+        disabled?: boolean;
+        checked?: boolean;
+        selected?: boolean;
+        highlighted?: boolean;
+        autoFocus?: boolean;
+        error: ReactNode;
+    }
+    type BarDropdownItem = {
+        key: string;
+        className?: string;
+        type: 'dropdown';
+        ariaLabel?: string;
+        icon?: IconDefinition;
+        multi?: boolean;
+        renderOption?: (option: SelectOption) => React.ReactNode;
+        renderOptionLabel?: (option: SelectOption) => React.ReactNode;
+        onChange?: (option: SelectOption) => void;
+        badge?: number | boolean;
+        disabled?: boolean;
+        tooltip?: string;
+        tooltipPlacement?: TooltipProps['placement'];
+        dropdownProps?: DropdownProps;
+        triggerLabel?: string | React.ReactNode;
+        caret?: boolean;
+        renderHeader?: () => React.ReactNode;
+    } & ({
+        options?: never;
+        groupedOptions?: SelectOptionGroup[];
+        renderOptionGroupHeader?: (optionGroup: SelectOptionGroup) => React.ReactNode;
+    } | {
+        options?: SelectOption[];
+        groupedOptions?: never;
+        renderOptionGroupHeader?: never;
+    });
+    export interface BarPopoverItem {
+        key: string;
+        type: 'popover';
+        icon?: IconDefinition;
+        ai?: boolean;
+        label?: string;
+        tooltip?: string;
+        tooltipPlacement?: TooltipProps['placement'];
+        badge?: number | boolean;
+        onClick?: (e: React.MouseEvent) => void;
+        className?: string;
+        disabled?: boolean;
+        open?: boolean;
+        destructive?: boolean;
+        selected?: boolean;
+        highlighted?: boolean;
+        autoFocus?: boolean;
+        PopoverElement: React.ElementType;
+    }
+    export interface BarSeparatorItem {
+        type: 'separator';
+    }
+    export type BarItem = BarTitleItem | BarButtonItem | BarToggleItem | BarDropdownItem | BarPopoverItem | BarSeparatorItem | false | undefined;
+    export interface BarProps {
+        as?: any;
+        className?: string;
+        compact?: boolean;
+        leftItems?: BarItem[];
+        items?: BarItem[];
+        rightItems?: BarItem[];
+        style?: React.CSSProperties;
+        tooltipPlacement?: TooltipProps['placement'];
+        popoverPlacement?: PopoverProps['placement'];
+    }
+    export function Bar(props: BarProps): React.JSX.Element;
+}
+declare module "editor/components/editors/pixie/PixieImageEditor" {
+    import React from 'react';
+    type ImageBlob = {
+        lastModifiedDate?: Date;
+        name?: string;
+    } & Blob;
+    export interface PixieImageEditorProps {
+        imageUrl: string;
+        toggleModal: () => void;
+        onComplete: (blob: ImageBlob) => void;
+    }
+    const PixieImageEditor: (props: PixieImageEditorProps) => React.JSX.Element;
+    export default PixieImageEditor;
+}
+declare module "editor/components/editors/ImageEditor" {
+    import { EditorPropsFromZodSchemas } from "engine/utils/zod/types";
+    export const schemas: Record<"value" | "value__simple", import("state/types/types").JSONSchema>, zodSchemas: {
+        value__simple: any;
+        value: any;
+    };
+    export type ImageEditorProps = EditorPropsFromZodSchemas<typeof zodSchemas>;
+    export function isDefaultImage(imageUrl: string | undefined, widgetParamsUrl?: string): boolean;
+}
+declare module "editor/components/common/Dropzone" {
+    import React from 'react';
+    import { DropzoneOptions } from 'react-dropzone';
+    export interface DropzoneProps {
+        children?: React.ReactNode;
+        disabled?: boolean;
+        isUploading?: boolean;
+        maxSize?: number;
+        options?: DropzoneOptions;
+        uploadProgress?: number;
+        imageUrl?: string;
+        imageWidth?: number;
+        imageHeight?: number;
+        imageSize?: number;
+        imageName?: string;
+        isEditImageButtonDisabled?: boolean;
+        onEditImageClick?: () => void;
+        shouldRender?: {
+            dropzone?: boolean;
+            editImageButton?: boolean;
+            imageInfo?: boolean;
+        };
+    }
+    export function Dropzone(props: DropzoneProps): React.JSX.Element;
+}
+declare module "editor/components/common/ImageUploadErrorMessage" {
+    import React from 'react';
+    import { IntlShape } from 'react-intl';
+    export interface ImageUploadErrorMessageProps {
+        error: Error | boolean | null | undefined;
+        maxSize?: number;
+        onClick?: () => void;
+    }
+    export function getImageUploadErrorMessage(error: ImageUploadErrorMessageProps['error'], { maxSize, intl }: {
+        maxSize: number;
+        intl: IntlShape;
+    }): any;
+    export function ImageUploadErrorMessage(props: ImageUploadErrorMessageProps): React.JSX.Element;
+}
+declare module "editor/components/editors/ImageUploader" {
+    import React, { RefObject } from 'react';
+    import { DropEvent, FileRejection } from 'react-dropzone';
+    import { ImageUploadButtonInstance, ImageUploadButtonProps } from "editor/components/common/ImageUploadButton";
+    import { Location } from "state/types/types";
+    export interface ImageUploaderProps {
+        disabled?: boolean;
+        shouldRender: {
+            dropzone?: boolean;
+            editImageButton?: boolean;
+            /** @deprecated Use editImageButton instead */
+            effects?: boolean;
+            imageInfo?: boolean;
+            moreImages?: boolean;
+            stockImages?: boolean;
+            uploadButton?: boolean;
+            userUploads?: boolean;
+        };
+        label: string;
+        optionName: string;
+        location: Location;
+        maxSize: number;
+        intl: any;
+        onDropAccepted: (files: File[]) => void;
+        onDropRejected: (fileRejections: FileRejection[], event: DropEvent) => void;
+        isUploading?: boolean;
+        uploadProgress?: number;
+        imageUrl?: string;
+        imageWidth?: number;
+        imageHeight?: number;
+        imageSize?: number;
+        togglePixieModal: () => void;
+        imageExists?: boolean;
+        error: boolean | Error | null;
+        onImageSelect: ImageUploadButtonProps['onImageSelect'];
+        onImageUpload: ImageUploadButtonProps['onImageUpload'];
+        onUploadProgressChange: ImageUploadButtonProps['onUploadProgressChange'];
+        onUploadStatusChange: ImageUploadButtonProps['onUploadStatusChange'];
+        onErrorChange: (error: Error | null) => void;
+        imageUploadButtonRef: RefObject<ImageUploadButtonInstance>;
+        showError?: boolean;
+    }
+    export const ImageUploader: ({ disabled, shouldRender: _shouldRender, label, optionName, location, maxSize, intl, onDropAccepted, onDropRejected, isUploading, uploadProgress, imageUrl, imageWidth, imageHeight, imageSize, togglePixieModal, imageExists, error, onImageSelect, onImageUpload, onUploadProgressChange, onUploadStatusChange, onErrorChange, imageUploadButtonRef, showError, ...restProps }: ImageUploaderProps) => React.JSX.Element;
+}
+declare module "editor/components/editors/BackgroundImageEditor" {
+    import { EditorPropsFromZodSchemas } from "engine/utils/zod/types";
+    export const schemas: Record<"value" | "value__simple", import("state/types/types").JSONSchema>, zodSchemas: {
+        value__simple: any;
+        value: any;
+    };
+    export type BackgroundImageEditorProps = EditorPropsFromZodSchemas<typeof zodSchemas>;
+}
+declare module "engine/options/bodies" {
+    import { BackgroundImageEditorProps } from "editor/components/editors/BackgroundImageEditor";
+    export type BodyValues = {
+        backgroundColor: string;
+        backgroundImage: BackgroundImageEditorProps['value'];
+        contentWidth: string;
+        fontFamily: {
+            label: string;
+            value: string;
+        };
+        linkStyle: {
+            body: boolean;
+            linkColor: string;
+            linkHoverColor: string;
+            linkUnderline: boolean;
+            linkHoverUnderline: boolean;
+        };
+        preheaderText: string;
+        accessibilityTitle: string;
+    };
+}
+declare module "engine/utils/stringifyFunction" {
+    export function stringifyFunction(fn: Function): string;
+    export function stringifyFunctionsFromObject(obj: object): {};
+}
+declare module "engine/utils/normalizeLinkTypes" {
+    import { LinkType, LinkTypes, LinkTypesSharedConfig } from "state/types/types";
+    export function normalizeLinkTypeSharedConfig(linkType: LinkTypesSharedConfig | null | undefined): LinkTypesSharedConfig & {
+        attrs: {};
+    };
+    export function normalizeLinkType(linkType: LinkType): LinkTypesSharedConfig & {
+        attrs: {};
+    };
+    export function normalizeLinkTypes(linkTypes: LinkTypes): (LinkTypesSharedConfig & {
+        attrs: {};
+    })[];
+}
+declare module "engine/utils/makeClassMethodsEnumerable" {
+    export function makeClassMethodsEnumerable(instance: InstanceType<any>, ignoreList?: string[]): void;
+}
+declare module "embed/helpers" {
+    export function convertReturnFunctionToDoneCallback<Fn extends (...args: [any]) => any>(fn: Fn): (info: Parameters<Fn>[0], done: Function) => void;
+}
+declare module "embed/Editor" {
+    import { Frame } from "embed/Frame";
+    import { Config, ExportFromApiResult, ExportHtmlOptions, ExportHtmlResult, ExportPlainTextResult, ExportImageFromApiOptions, ExportLiveHtmlOptions, ExportPdfFromApiOptions, ExportPlainTextOptions, ExportZipFromApiOptions, SaveDesignOptions, ExportLiveHtmlResult } from "embed/Config";
+    import { AppearanceConfig, Audit, DesignMode, DesignTagsConfig, Device, DisplayConditions, DisplayMode, JSONTemplate, Language, LinkTypes, LinkTypesSharedConfig, MergeTags, MergeTagsConfig, SpecialLink, StyleGuideConfig, Tabs, Translations, User, Validator } from "state/types/types";
+    import { BodyValues } from "engine/options/bodies";
+    import { Locale, TextDirection } from "engine/config/intl";
+    import { DeepPartial } from "editor/components/editors/types";
+    import { ColorPicker } from "engine/config/features";
+    export const LATEST_VERSION: string;
+    export const STABLE_VERSION: string;
+    export const ENV_VERSION: string;
+    export class Editor {
+        frame: Frame | null;
+        constructor(config?: Config);
+        init(config?: Config): void;
+        destroy(): void;
+        versions: {
+            current: string | undefined;
+            latest: string;
+            stable: string;
+        };
+        get version(): string;
+        loadEditor(config: Config): void;
+        renderEditor(config: Config): void;
+        initEditor(config: Config): void;
+        registerColumns(cells: number[]): void;
+        registerCallback(type: string, callback: Function): void;
+        unregisterCallback(type: string): void;
+        registerProvider(type: string, callback: Function): void;
+        unregisterProvider(type: string): void;
+        reloadProvider(type: string): void;
+        addEventListener(type: string, callback: Function): void;
+        removeEventListener(type: string): void;
+        setDesignId(id: string | null): void;
+        setDesignMode(designMode: DesignMode | null): void;
+        setDisplayMode(displayMode: DisplayMode): void;
+        loadProject(projectId: number): void;
+        loadUser(user: User): void;
+        loadTemplate(templateId: number): void;
+        loadStockTemplate(stockTemplateId: string): void;
+        setLinkTypes(linkTypes: LinkTypes): void;
+        setLinkTypesSharedConfig(linkTypesSharedConfig: LinkTypesSharedConfig | null): void;
+        setMergeTags(mergeTags: MergeTags): void;
+        setSpecialLinks(specialLinks: SpecialLink[]): void;
+        setDisplayConditions(displayConditions: DisplayConditions): void;
+        setLocale(locale: Locale | null): void;
+        setTextDirection(textDirection: TextDirection | null): void;
+        setTranslations(translations: Translations): void;
+        loadBlank(bodyValues?: object): void;
+        loadDesign(design: JSONTemplate): void;
+        saveDesign(callback: Function, options?: SaveDesignOptions): void;
+        exportHtml(callback: (data: ExportHtmlResult) => void, options?: ExportHtmlOptions): void;
+        exportLiveHtml(callback: (data: ExportLiveHtmlResult) => void, options?: ExportLiveHtmlOptions): void;
+        exportPlainText(callback: (data: ExportPlainTextResult) => void, options?: ExportPlainTextOptions): void;
+        exportImage(callback: (data: ExportFromApiResult) => void, options?: ExportImageFromApiOptions): void;
+        exportPdf(callback: (data: ExportFromApiResult) => void, options?: ExportPdfFromApiOptions): void;
+        exportZip(callback: (data: ExportFromApiResult) => void, options?: ExportZipFromApiOptions): void;
+        setAppearance(appearance: DeepPartial<AppearanceConfig>): void;
+        setTheme(theme: AppearanceConfig['theme']): void;
+        setBodyValues(bodyValues: Partial<BodyValues>, bodyId?: number): void;
+        setStyleGuide(styleGuide: StyleGuideConfig): void;
+        setDesignTagsConfig(designTagsConfig: DesignTagsConfig): void;
+        setMergeTagsConfig(mergeTagsConfig: MergeTagsConfig): void;
+        showPreview(payload: {
+            device?: Device;
+            resolution?: number;
+        }): void;
+        hidePreview(): void;
+        canUndo(callback: (result: boolean) => void): void;
+        canRedo(callback: (result: boolean) => void): void;
+        undo(): void;
+        redo(): void;
+        audit(callback: (data: {
+            status: 'FAIL' | 'PASS';
+            errors: Audit[];
+        }) => void): void;
+        setValidator(validator: Validator | null): void;
+        setToolValidator(tool: string, validator: Validator | null): void;
+        updateTabs(tabs: Tabs): void;
+        clearValidators(): void;
+        setCurrentLanguage(language: string): void;
+        setLanguages(languages: Language[]): void;
+        setColorPickerConfig(colorPickerConfig: ColorPicker): void;
+        registerContainerExporter(): void;
+        registerItemExporter(): void;
+        registerTool(): void;
+        registerPropertyEditor(): void;
+        registerTab(): void;
+        createPanel(): void;
+        createViewer(): void;
+        createWidget(): void;
+    }
+}
+declare module "embed/index" {
+    import { Editor } from "embed/Editor";
+    import { Config } from "embed/Config";
+    class Embed extends Editor {
+        createEditor(config: Config): Editor;
+    }
+    const _default: Embed;
+    export default _default;
+}