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, Variant } from "state/types/types";
    export type LoadingState = 'not-loaded' | 'loading' | 'loaded';
    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;
            skipFromUndoRedo?: boolean;
        }) => 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>,
        {
            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: {
                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';
    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' | '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;
                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 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 BROWSER: {
        IS_IE: boolean;
        IS_SAFARI: boolean;
    };
}
declare module "engine/utils/zod/schemas" {
    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 { Dispatch } from 'redux';
    import { z } from 'zod';
    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 } from "engine/constants";
    import { DisplayConditionZodSchema } from "engine/utils/zod/schemas";
    export type DesignMode = 'live' | 'edit';
    export type Device = 'desktop' | 'mobile' | 'tablet';
    export type DisplayMode = 'web' | 'email' | 'popup' | 'document';
    export type Variant = 'amp' | null;
    export type Ui = 'none' | 'visual' | 'classic';
    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 interface Location {
        collection: Collection;
        id: number | string;
    }
    export interface Selection {
        active: boolean;
        location: Location | null;
        parent: Location | null;
        threadId: CollaborationThread['id'] | 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 = Array<{
        id: string;
        cells: number[];
        columns: Array<{
            id: string;
            contents: Array<Design['contents']['0']>;
            values: Record<string, any>;
        }>;
        values: 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;
                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: Dispatch, getState: () => RootState) => Promise<void>;
    export interface JSONSchema {
    }
    export type TableValue = {
        headers: {
            cells: {
                id: string;
                text: string;
            }[];
        }[];
        rows: {
            cells: {
                id: string;
                text: string;
            }[];
        }[];
    };
}
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 { 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';
        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;
        blocks?: boolean;
        collaboration?: boolean;
        preview?: boolean;
        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;
        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 | {
            smartHeadings?: boolean;
            smartButtons?: boolean;
            magicImage?: boolean;
            smartText?: boolean;
            smartImageAltText?: boolean;
        };
        sendTestEmail?: boolean;
    }
    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: string | string[]): any;
    export function hasFeature(path: string | string[], checkEntitlement?: boolean): 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';
    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 { ZodSchema } from 'zod';
    import { JSONSchema } from "state/types/types";
    export function zodSchemasToJsonSchemas<K extends string>(zodSchemas: Record<K, ZodSchema>): Record<K, JSONSchema>;
}
declare module "engine/utils/zod/propertyEditorSchemas" {
    import { PropertyEditorZodSchemas } from '../../config';
    export function propertyEditorZodSchemas<T extends PropertyEditorZodSchemas>(zodSchemas: T): {
        zodSchemas: T;
        schemas: Record<string, import("state/types/types").JSONSchema>;
    };
}
declare module "engine/utils/zod/types" {
    import { z } from 'zod';
    import { EditorProps } from "editor/components/editors/types";
    import { PropertyEditorZodSchemas } from '../../config';
    export type EditorPropsFromZodSchemas<T extends 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<string, import("state/types/types").JSONSchema>, zodSchemas: {
        value: any;
        widgetParams: 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'> {
        formStore?: Ariakit.FormStore<{
            value: string;
        }>;
        icon?: Icon | IconDefinition;
        label?: React.ReactNode;
        labelPosition?: 'top' | 'left' | 'right';
        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 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>;
        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/Button" {
    import React from 'react';
    import * as Ariakit from '@ariakit/react';
    import { Theme } from "editor/themes/types";
    export interface ButtonProps extends Ariakit.ButtonProps {
        children: React.ReactNode;
        circle?: boolean;
        className?: string;
        danger?: boolean;
        disabled?: boolean;
        loading?: boolean;
        onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
        size?: number | 'auto';
        style?: React.CSSProperties;
        variant?: keyof Theme['components']['buttons'];
        type?: Ariakit.ButtonProps['type'];
        id?: string;
    }
    export const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<unknown>>;
}
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;
        placement: Ariakit.TooltipStoreProps['placement'];
        style?: React.CSSProperties;
        timeout?: number;
        tooltip: Ariakit.TooltipProps['children'];
        tooltipWrapper?: Ariakit.TooltipAnchorProps['render'];
    }
    export function Tooltip(props: TooltipProps): React.JSX.Element;
}
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;
        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;
        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 getCurrentTheme(): Theme & DeprecatedTheme;
    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;
        }
    }
    export const enableLexical: () => void;
    export function showLexical(): boolean;
}
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, { 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<string, import("state/types/types").JSONSchema>, zodSchemas: {
        value: any;
        widgetParams: 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 "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 interface PopoverProps {
        arrow?: boolean;
        autoFocusOnShow?: boolean;
        autoFocusOnHide?: boolean;
        children: Ariakit.PopoverAnchorProps['children'];
        className?: string;
        content: Ariakit.PopoverProps['children'];
        destroyPopupOnHide?: boolean;
        disabled?: boolean;
        onHide?: () => void;
        onShow?: () => void;
        placement: Ariakit.PopoverStoreProps['placement'];
        popoverWrapper?: Ariakit.PopoverAnchorProps['render'];
        style?: React.CSSProperties;
        isOpen?: boolean;
        setIsOpen?: (open: boolean) => void;
    }
    export interface PopoverInstance {
        isOpen: boolean;
        show: () => void;
        hide: () => void;
    }
    export const Popover: React.ForwardRefExoticComponent<PopoverProps & React.RefAttributes<PopoverInstance>>;
}
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' | 'subtitle';
        icon?: IconDefinition;
        text: string | React.ReactElement;
        tooltip?: string;
        tooltipPlacement?: TooltipProps['placement'];
        badge?: number;
        loading?: boolean;
    }
    export interface BarButtonItem {
        key: string;
        type: 'button';
        id?: string;
        className?: string;
        icon: IconDefinition | undefined;
        label?: string;
        tooltip?: string;
        tooltipPlacement?: TooltipProps['placement'];
        badge?: number;
        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;
        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;
        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 BarSeparatorItem {
        type: 'separator';
    }
    export type BarItem = BarTitleItem | BarButtonItem | BarToggleItem | BarDropdownItem | 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<string, import("state/types/types").JSONSchema>, zodSchemas: {
        value: any;
        widgetParams: 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<string, import("state/types/types").JSONSchema>, zodSchemas: {
        value: any;
        widgetParams: 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;
    };
}
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;
}