unlayer-types 1.386.0 → 1.388.0

package/embed.d.ts

@@ -1391,8 +1391,10 @@ declare module "packages/editor/src/state/types/types" {
     import { z } from 'zod';
     import type { AICopilotDataType } from '@libs/ai/types/types';
     import { DisplayConditionZodSchema } from '@libs/schemas/common/schemas';
-    import { ContentValues } from '@libs/schemas/options/containers/contents';
-    import { State as Design } from '../reducer/design';
+    import type { BodyValues } from '@libs/schemas/options/containers/bodies';
+    import type { ColumnValues } from '@libs/schemas/options/containers/columns';
+    import type { ContentValues } from '@libs/schemas/options/containers/contents';
+    import type { RowValues } from '@libs/schemas/options/containers/rows';
     import { CollaborationThread } from "packages/editor/src/editor/components/editors/types";
     import { RootState } from "packages/editor/src/state/types/RootState";
     import { ThemeExtension, ThemeNamePlusLightDark } from "packages/editor/src/editor/themes/types";
@@ -1489,7 +1491,7 @@ declare module "packages/editor/src/state/types/types" {
         attrs?: {
             href?: string;
             target?: string;
-            onClick?: string | Function;
+            onClick?: string | ((...args: any[]) => void);
             class?: string;
             download?: boolean;
             [key: string]: any;
@@ -1596,34 +1598,7 @@ declare module "packages/editor/src/state/types/types" {
         optimistic?: boolean;
     }
     export type ArrayItem<T> = T extends (infer I)[] ? I : T extends readonly (infer I)[] ? I : unknown;
-    export type BodyItem = {
-        id: string;
-        cells: number[];
-        columns: Array<{
-            id: string;
-            contents: Array<Design['contents']['0']>;
-            values: Record<string, any>;
-        }>;
-        values: {
-            sync?: {
-                id: string;
-                enabled?: boolean;
-                updatedAt?: string;
-                dirty?: boolean;
-            };
-        } & Record<string, any>;
-    };
-    export type JSONTemplate = {
-        counters: Record<string, number>;
-        body: {
-            id: string | undefined;
-            rows: BodyItem[];
-            headers: BodyItem[];
-            footers: BodyItem[];
-            values: {};
-        };
-        schemaVersion?: number;
-    };
+    export type { DesignBody, DesignContentItem, DesignContentType, DesignColumn, DesignRow, JSONTemplate, } from '@libs/schemas/design/exported-types';
     export type { OptionGroup, OptionItem } from "packages/editor/src/engine/config/optionGroups";
     export type FontGroup = import("packages/editor/src/engine/config/optionGroups").OptionGroup<CustomFont>;
     export type FontItem = import("packages/editor/src/engine/config/optionGroups").OptionItem<CustomFont>;
@@ -1769,18 +1744,18 @@ declare module "packages/editor/src/state/types/types" {
     export type ExporterName = DisplayMode | 'ampWeb' | 'ampEmail' | 'classic';
     export type BodyContainerExporter = (innerHTML: string, bodyValues: Record<string, any>, // @deprecated use last param instead
     meta: {
-        bodyValues: RootState['design']['bodies'][string]['values'];
+        bodyValues: BodyValues;
         type: string;
         variant: Variant;
     }) => string;
     export type BodyContainerExporters = Partial<Record<ExporterName, BodyContainerExporter>>;
-    export type RowContainerExporter = (innerHTML: string, rowValues: RootState['design']['rows'][string]['values'], // @deprecated use last param instead
-    bodyValues: RootState['design']['bodies'][string]['values'], // @deprecated use last param instead
+    export type RowContainerExporter = (innerHTML: string, rowValues: RowValues, // @deprecated use last param instead
+    bodyValues: BodyValues, // @deprecated use last param instead
     meta: {
         rowIndex: number;
         rowCells: number[];
-        rowValues: RootState['design']['rows'][string]['values'];
-        bodyValues: RootState['design']['bodies'][string]['values'];
+        rowValues: RowValues;
+        bodyValues: BodyValues;
         variant: Variant | undefined;
         language: string | undefined;
         collection: Collection;
@@ -1789,29 +1764,29 @@ declare module "packages/editor/src/state/types/types" {
     export type ColumnContainerExporter = (innerHTML: string, columnValues: Record<string, any>, // @deprecated use last param instead
     columnIndex: number, // @deprecated use last param instead
     rowCells: number[], // @deprecated use last param instead
-    bodyValues: RootState['design']['bodies'][string]['values'], // @deprecated use last param instead
-    rowValues: RootState['design']['rows'][string]['values'], // @deprecated use last param instead
+    bodyValues: BodyValues, // @deprecated use last param instead
+    rowValues: RowValues, // @deprecated use last param instead
     meta: {
         columnIndex: number;
-        columnValues: RootState['design']['columns'][string]['values'];
+        columnValues: ColumnValues;
         rowIndex: number;
         rowCells: number[];
-        rowValues: RootState['design']['rows'][string]['values'];
-        bodyValues: RootState['design']['bodies'][string]['values'];
+        rowValues: RowValues;
+        bodyValues: BodyValues;
         variant: Variant;
         language: string;
     }) => string;
     export type ColumnContainerExporters = Partial<Record<ExporterName, ColumnContainerExporter>>;
     export type ContentContainerExporter = (innerHTML: string, contentValues: Record<string, any>, // @deprecated use last param instead
-    bodyValues: RootState['design']['bodies'][string]['values'], // @deprecated use last param instead
+    bodyValues: BodyValues, // @deprecated use last param instead
     meta: {
         index: number;
         columnIndex: number;
-        columnValues: RootState['design']['columns'][string]['values'];
+        columnValues: ColumnValues;
         rowIndex: number;
         rowCells: number[];
-        rowValues: RootState['design']['rows'][string]['values'];
-        bodyValues: RootState['design']['bodies'][string]['values'];
+        rowValues: RowValues;
+        bodyValues: BodyValues;
         variant: Variant | undefined;
         language: string | undefined;
         embeddedValues: Record<string, unknown>;
@@ -1825,17 +1800,17 @@ declare module "packages/editor/src/state/types/types" {
     export type ItemExporter<TValues extends Record<string, unknown>> = (renderValues: TValues, index: number, // @deprecated use last param instead
     columnIndex: number, // @deprecated use last param instead
     rowCells: number[], // @deprecated use last param instead
-    bodyValues: RootState['design']['bodies'][string]['values'], // @deprecated use last param instead
-    rowValues: RootState['design']['rows'][string]['values'], // @deprecated use last param instead
+    bodyValues: BodyValues, // @deprecated use last param instead
+    rowValues: RowValues, // @deprecated use last param instead
     embeddedValues: Record<string, unknown>, // @deprecated use last param instead
     meta: {
         index: number;
         columnIndex: number;
-        columnValues: RootState['design']['columns'][string]['values'];
+        columnValues: ColumnValues;
         rowIndex: number;
         rowCells: number[];
-        rowValues: RootState['design']['rows'][string]['values'];
-        bodyValues: RootState['design']['bodies'][string]['values'];
+        rowValues: RowValues;
+        bodyValues: BodyValues;
         embeddedValues: Record<string, unknown>;
         mergeTagState: {
             mergeTagGroup: string;
@@ -2050,9 +2025,9 @@ declare module "packages/editor/src/engine/config/fonts" {
     export function getGroupedFonts(options?: FontOptions): FontGroup[] | null;
 }
 declare module "packages/editor/src/engine/config/safeHtml" {
-    import { Config } from 'dompurify';
+    import { Config as DOMPurifyConfig } from 'dompurify';
     export interface SafeHtmlOptions {
-        domPurifyOptions?: Config;
+        domPurifyOptions?: DOMPurifyConfig;
     }
     export function isSafeHtmlEnabled(): boolean;
     export function enableSafeHtml(): void;
@@ -2088,14 +2063,14 @@ declare module "packages/editor/src/engine/config/intl" {
     export function isRTL(locale: Locale): boolean;
 }
 declare module "packages/editor/src/embed/Config" {
-    import { ValidationResult } from 'amphtml-validator';
-    import { EditorSettings } from "packages/editor/src/engine/config/editorSettings";
-    import { Features } from "packages/editor/src/engine/config/features";
-    import { FontList } from "packages/editor/src/engine/config/fonts";
-    import { SafeHtmlOptions } from "packages/editor/src/engine/config/safeHtml";
-    import { TextDirection } from "packages/editor/src/engine/config/intl";
-    import { AppearanceConfig, Audit, DesignTags, DesignTagsConfig, Device, DisplayConditions, DisplayMode, Fonts, JSONTemplate, LinkTypes, LinkTypesSharedConfig, MergeTags, MergeTagsConfig, MergeTagsValues, SpecialLinks, Tabs, ToolsConfig, User } from "packages/editor/src/state/types/types";
-    import { DeepPartial } from "packages/editor/src/editor/components/editors/types";
+    import type { ValidationResult } from 'amphtml-validator';
+    import type { EditorSettings } from "packages/editor/src/engine/config/editorSettings";
+    import type { Features } from "packages/editor/src/engine/config/features";
+    import type { FontList } from "packages/editor/src/engine/config/fonts";
+    import type { SafeHtmlOptions } from "packages/editor/src/engine/config/safeHtml";
+    import type { TextDirection } from "packages/editor/src/engine/config/intl";
+    import type { AppearanceConfig, Audit, DesignTags, DesignTagsConfig, Device, DisplayConditions, DisplayMode, Fonts, JSONTemplate, LinkTypes, LinkTypesSharedConfig, MergeTags, MergeTagsConfig, MergeTagsValues, SpecialLinks, Tabs, ToolsConfig, User } from "packages/editor/src/state/types/types";
+    import type { DeepPartial } from "packages/editor/src/editor/components/editors/types";
     export interface Config {
         id?: string;
         className?: string;
@@ -2167,7 +2142,7 @@ declare module "packages/editor/src/embed/Config" {
         onlyHeader?: boolean;
         onlyFooter?: boolean;
     }
-    export interface ExportHtmlResult {
+    export interface ExportHtmlResult<TDisplayMode extends DisplayMode | undefined = undefined> {
         html: string;
         amp: {
             enabled: boolean;
@@ -2176,18 +2151,18 @@ declare module "packages/editor/src/embed/Config" {
             validation: ValidationResult;
         };
         chunks: ExportChunksResult;
-        design: JSONTemplate;
+        design: JSONTemplate<TDisplayMode>;
     }
     export interface ExportLiveHtmlOptions extends Omit<ExportHtmlOptions, 'live'> {
     }
-    export interface ExportLiveHtmlResult extends ExportHtmlResult {
+    export interface ExportLiveHtmlResult<TDisplayMode extends DisplayMode | undefined = undefined> extends ExportHtmlResult<TDisplayMode> {
     }
     export interface ExportPlainTextOptions extends Omit<ExportHtmlOptions, 'cleanup' | 'minify'> {
         ignorePreheader?: boolean;
     }
-    export interface ExportPlainTextResult {
+    export interface ExportPlainTextResult<TDisplayMode extends DisplayMode | undefined = undefined> {
         text: string;
-        design: JSONTemplate;
+        design: JSONTemplate<TDisplayMode>;
     }
     export interface HtmlToPlainTextOptions {
         ignoreLinks?: boolean;
@@ -2206,8 +2181,8 @@ declare module "packages/editor/src/embed/Config" {
         ignorePreheader?: boolean;
         mergeTags?: Record<string, string>;
     }
-    export interface ExportFromApiResult {
-        design: JSONTemplate;
+    export interface ExportFromApiResult<TDisplayMode extends DisplayMode | undefined = undefined> {
+        design: JSONTemplate<TDisplayMode>;
         url: string | null;
         error?: string;
     }
@@ -2248,7 +2223,7 @@ declare module "packages/editor/src/embed/Frame" {
         messages: any[];
         callbackId: number;
         callbacks: {
-            [key: number]: Function | undefined;
+            [key: number]: ((...args: any[]) => any) | undefined;
         };
         constructor(src: string);
         createIframe(src: string): HTMLIFrameElement;
@@ -2256,7 +2231,7 @@ declare module "packages/editor/src/embed/Frame" {
         appendTo(el: Element): void;
         onWindowMessage: (event: MessageEvent<any>) => void;
         postMessage(action: string, message: Message): void;
-        withMessage(action: string, message: Message | undefined, callback?: Function): void;
+        withMessage(action: string, message: Message | undefined, callback?: (...args: any[]) => any): void;
         _preprocessMessageFunctions(message: Message): Message;
         preprocessMessage(message: Message): Message;
         scheduleMessage(message: Message): void;
@@ -2274,6 +2249,688 @@ declare module "packages/editor/src/embed/Frame" {
         }
     }
 }
+declare module "packages/editor/src/engine/config/exporters" {
+    import { Container } from "packages/editor/src/state/types/types";
+    export type ExporterFn = () => void;
+    export function getCustomContainerExporter(name: Container): ExporterFn | undefined;
+    export function registerCustomContainerExporter(name: Container, exporter: ExporterFn | null | undefined): void;
+    export function unregisterCustomContainerExporter(name: Container): void;
+    export function getCustomItemExporter(name: string): ExporterFn | undefined;
+    export function registerCustomItemExporter(name: string, exporter: ExporterFn | null | undefined): void;
+    export function unregisterCustomItemExporter(name: string): void;
+}
+declare module "packages/editor/src/engine/utils/auditUtils" {
+    import { Audit, Validator } from "packages/editor/src/state/types/types";
+    export function getPlainTextAndHtml(value: string): {
+        html: string;
+        text: string;
+    };
+    export function parseValidatorFunction(validatorFn: Validator | string): Validator;
+    export function removeFunctionsFromAudit(rule: Audit): Audit;
+}
+declare module "packages/editor/src/editor/helpers/multiLanguage" {
+    import { ValueMap } from '../../engine/config';
+    export function getValuesForLanguage(values: ValueMap | undefined, language: string | undefined): any;
+}
+declare module "packages/editor/src/engine/config/env" {
+    export const env: {
+        API_V1_BASE_URL: string;
+        API_V2_BASE_URL: string;
+        API_V3_BASE_URL: string;
+        EVENTS_API_BASE_URL: string;
+        TOOLS_API_V1_BASE_URL: string;
+        TOOLS_CDN_BASE_URL: string;
+        CONSOLE_BASE_URL: string;
+    };
+    export function setIsTest(isTest: boolean): void;
+    export function isTest(): boolean;
+    global {
+        interface Window {
+            Cypress?: unknown;
+        }
+    }
+}
+declare module "packages/editor/src/engine/config/entitlements" {
+    import { Entitlements } from '@libs/entitlements';
+    export function setEntitlements(newEntitlements: Entitlements): void;
+    export function getEntitlements(): Entitlements;
+}
+declare module "packages/editor/src/engine/config/amp" {
+    export function enableAMP(): void;
+    export function isAMP(): boolean;
+}
+declare module "packages/editor/src/editor/helpers/sortArrayByPosition" {
+    export function sortArrayByPosition<T extends {
+        position?: number;
+    }>(arr: T[]): T[];
+}
+declare module "packages/editor/src/engine/config/tools" {
+    import Mustache from 'mustache';
+    import { Entitlements } from '@libs/entitlements';
+    import type { PropertyEditorJSONSchemas, PropertyEditorZodSchemas } from '@libs/schemas/types/property_editor';
+    import type { OptionConfig } from '@libs/schemas/types/options';
+    import type { Option } from '@libs/schemas/types/options';
+    import { DisplayMode, DesignTags, Collection, Location, Device, Variant, DesignMode, Validator, DisplayConditions, Container, ItemExporter, ContentContainerExporter, BodyContainerExporter, ColumnContainerExporter, RowContainerExporter } from "packages/editor/src/state/types/types";
+    import { RootState } from "packages/editor/src/state/types/RootState";
+    import { DeepPartial, EditorProps, LanguagesValue } from "packages/editor/src/editor/components/editors/types";
+    export interface PropertyEditorConfig<Props extends EditorProps<any> = any> {
+        id?: string;
+        name: string;
+        Widget: React.ComponentType<Props>;
+        description?: string;
+        schemas: Partial<PropertyEditorJSONSchemas> | undefined;
+        zodSchemas: Partial<PropertyEditorZodSchemas> | undefined;
+        layout?: 'right' | 'bottom';
+        styleGuideLock?: boolean;
+        renderValue?: (value: any) => any;
+        deviceStyles?: (value: Props['value'], extra: {
+            collection: Collection;
+            device: Device;
+            displayMode: DisplayMode;
+            getDefaultSelectorForCSSProperty: (cssProperty: string | undefined) => string | undefined;
+            htmlID: string;
+            optionName: string;
+            bodyValues: {
+                [name: string]: any;
+            };
+            rootValue: Props['value'];
+        }) => {
+            _css?: string;
+            [key: string]: string | undefined;
+        };
+    }
+    export type PropertyEditorConfigMap = {
+        [id: string]: PropertyEditorConfig;
+    };
+    export type OptionConfigMap<Values extends ValueMap = ValueMap> = {
+        [K in keyof Values]: Option;
+    };
+    export type OptionGroupEmbeddedConfig<Values extends ValueMap = ValueMap> = {
+        collection: Collection;
+        type: string;
+        source: string;
+        tabLabel: string;
+        insertCount?: number;
+        optionGroups?: Record<string, {
+            optionsOverride?: OptionConfigMap<Partial<Values>>;
+        }>;
+    };
+    export type OptionGroupConfig<Values extends ValueMap = ValueMap> = {
+        rightLabel?: string;
+        title: string | null;
+        icon?: string | string[];
+        position?: number;
+        supportedDesignModes?: DesignMode[];
+        supportedByAI?: boolean;
+        enabled?: boolean;
+        hideOnOfflineMode?: boolean;
+        noContentPadding?: boolean;
+        ai?: boolean;
+        widgetParams?: {
+            [id: string]: unknown;
+        };
+    } & {
+        embedded?: OptionGroupEmbeddedConfig<Values>;
+        options?: OptionConfigMap<Partial<Values>>;
+    };
+    export type OptionGroupConfigMap<Values extends ValueMap = ValueMap> = {
+        [id: string]: OptionGroupConfig<Values>;
+    };
+    export type ToolOptionGroupConfigMap = {
+        [id: string]: OptionGroupConfigMap;
+    };
+    export type ValueMap = {
+        [id: string]: unknown;
+    } & LanguagesValue;
+    export interface ToolOverride<Values extends ValueMap = ValueMap> extends DeepPartial<ToolConfig<Values>> {
+        sections?: Record<string, {
+            editor: Pick<OptionGroupConfig<Values>, 'enabled'>;
+        }>;
+        properties?: Record<string, {
+            editor?: OptionConfigMap<Partial<Values>>;
+            value?: unknown;
+        }>;
+    }
+    export interface ToolConfig<Values extends ValueMap = ValueMap, T = Validator> {
+        id?: string;
+        name?: string;
+        type?: string;
+        slug?: string;
+        label?: string;
+        icon?: string | string[];
+        classicIcon?: string | string[];
+        category?: Collection;
+        cells?: number[];
+        options: OptionGroupConfigMap;
+        data?: Partial<Values>;
+        values?: Partial<Values>;
+        css?: string;
+        renderer?: object | ((...args: any[]) => any);
+        supportedByAI?: boolean;
+        supportedDisplayModes?: DisplayMode[];
+        supportedVariants?: Variant[];
+        usageLimit?: number;
+        transformer?: (values: Partial<Values>, source: {
+            name: string;
+            value: unknown;
+        }) => Partial<Values>;
+        hasDeprecatedFontControls?: boolean;
+        syncMetadata?: {
+            id: string | number;
+            lastUpdatedAt: string | number;
+            enabled?: boolean;
+        };
+        applyDesignTags?: (values: Values, designTags: DesignTags, template: typeof Mustache.render) => Values;
+        propertyStates?: (values: Partial<Values>, context: {
+            type: string;
+            hasDeprecatedFontControls?: boolean;
+        }) => Record<string, object> | undefined;
+        isSupported?: (context: {
+            displayMode: DisplayMode;
+            variant: string | null;
+        }) => boolean;
+        premium?: boolean;
+        editable?: boolean;
+        classic?: boolean;
+        enabled?: boolean;
+        position?: number;
+        location?: Location;
+        validator?: T;
+        hidden?: boolean;
+    }
+    export type ToolConfigMap<T = Validator> = {
+        [id: string]: ToolConfig<ValueMap, T>;
+    };
+    export interface PremiumToolConfig {
+        enabled?: boolean;
+    }
+    export type PremiumToolConfigMap = {
+        [id: string]: PremiumToolConfig;
+    };
+    export type ViewerMap = {
+        [id: string]: unknown;
+    };
+    export type ExportersMap = {
+        [id: string]: Record<string, Function> | undefined;
+    };
+    export type HeadsMap = {
+        [id: string]: unknown;
+    };
+    export type ValidatorsMap = {
+        [id: string]: Validator;
+    };
+    export function loadOptions(newOptions: ToolOptionGroupConfigMap): void;
+    export function overrideOptions(newOverrideOptions: ToolOptionGroupConfigMap): void;
+    export function getOptionOverrides(): {
+        [x: string]: {
+            [x: string]: {
+                rightLabel?: string;
+                title?: string | null;
+                icon?: string | string[];
+                position?: number;
+                supportedDesignModes?: DesignMode[];
+                supportedByAI?: boolean;
+                enabled?: boolean;
+                hideOnOfflineMode?: boolean;
+                noContentPadding?: boolean;
+                ai?: boolean;
+                widgetParams?: {
+                    [x: string]: unknown;
+                };
+                embedded?: {
+                    collection?: Collection;
+                    type?: string;
+                    source?: string;
+                    tabLabel?: string;
+                    insertCount?: number;
+                    optionGroups?: {
+                        [x: string]: {
+                            optionsOverride?: {
+                                [x: string]: any;
+                                _languages?: any;
+                            };
+                        };
+                    };
+                };
+                options?: {
+                    [x: string]: any;
+                    _languages?: any;
+                };
+            };
+        };
+    };
+    export function getOptionGroups(collection: Collection, config?: Parameters<typeof getOptionId>[0], device?: Device | undefined, { designMode }?: {
+        designMode?: DesignMode;
+    }): OptionGroupConfigMap;
+    export function getOptions(collection: Collection | undefined, config?: OptionConfig | undefined, device?: Device | undefined): OptionConfigMap;
+    export function getInitialValues(collection: Collection, config?: Parameters<typeof getOptionGroups>[1], device?: Device | undefined): {
+        [id: string]: unknown;
+    };
+    export function getInitialValuesFromOptionGroup(optionGroup: {
+        options?: OptionConfigMap;
+    } | undefined): Record<string, unknown>;
+    export function loadTools(newTools: ToolConfigMap): void;
+    export function overrideTools(newOverrideTools: Record<string, ToolOverride>): void;
+    export function getOverrideToolById(id: string): {
+        id?: string;
+        name?: string;
+        type?: string;
+        slug?: string;
+        label?: string;
+        icon?: string | string[];
+        classicIcon?: string | string[];
+        category?: Collection;
+        cells?: number[];
+        options?: {
+            [x: string]: {
+                rightLabel?: string;
+                title?: string | null;
+                icon?: string | string[];
+                position?: number;
+                supportedDesignModes?: DesignMode[];
+                supportedByAI?: boolean;
+                enabled?: boolean;
+                hideOnOfflineMode?: boolean;
+                noContentPadding?: boolean;
+                ai?: boolean;
+                widgetParams?: {
+                    [x: string]: unknown;
+                };
+                embedded?: {
+                    collection?: Collection;
+                    type?: string;
+                    source?: string;
+                    tabLabel?: string;
+                    insertCount?: number;
+                    optionGroups?: {
+                        [x: string]: {
+                            optionsOverride?: {
+                                [x: string]: any;
+                                _languages?: any;
+                            };
+                        };
+                    };
+                };
+                options?: {
+                    [x: string]: any;
+                    _languages?: any;
+                };
+            };
+        };
+        data?: {
+            [x: string]: unknown;
+            _languages?: {
+                [x: string]: {
+                    [x: string]: string;
+                };
+            };
+        };
+        values?: {
+            [x: string]: unknown;
+            _languages?: {
+                [x: string]: {
+                    [x: string]: string;
+                };
+            };
+        };
+        css?: string;
+        renderer?: object | {};
+        supportedByAI?: boolean;
+        supportedDisplayModes?: any;
+        supportedVariants?: Variant[];
+        usageLimit?: number;
+        transformer?: {};
+        hasDeprecatedFontControls?: boolean;
+        syncMetadata?: {
+            id?: string | number;
+            lastUpdatedAt?: string | number;
+            enabled?: boolean;
+        };
+        applyDesignTags?: {};
+        propertyStates?: {};
+        isSupported?: {};
+        premium?: boolean;
+        editable?: boolean;
+        classic?: boolean;
+        enabled?: boolean;
+        position?: number;
+        location?: {
+            collection?: Collection;
+            id?: number | string;
+        };
+        validator?: string;
+        hidden?: boolean;
+    };
+    export function isRowToolEnabled(): boolean;
+    export function getTool(toolItem: ToolItem): ToolConfig<ValueMap, Validator>;
+    export function getAllTools(): any[];
+    export function getTools(collection?: Collection): any[];
+    export function getCustomToolsCount(): number;
+    export function getToolsCSS(category: string, items: ToolConfig[]): string;
+    export function excludeTools(types: string[]): void;
+    export function registerTool<Values extends ValueMap>(config: ToolConfig<Values, Validator>): void;
+    export function clearValidator(toolName: string): void;
+    export function clearValidators(): void;
+    export function setValidator(toolName: string, validator: Validator | null): void;
+    export function setDefaultDesignValidator(validator: Validator): void;
+    export function setDesignValidator(validator: Validator): void;
+    export function enablePremiumTool(config: ToolConfig): void;
+    export function disablePremiumTool(config: ToolConfig): void;
+    export function registerOptions(config: OptionConfig & {
+        category?: string;
+    }): void;
+    export function registerPropertyEditor<Props extends EditorProps<any>>(config: PropertyEditorConfig<Props>): void;
+    export function getPropertyEditor(config: {
+        id: PropertyEditorConfig['id'];
+        name?: PropertyEditorConfig['name'];
+    } | {
+        id?: PropertyEditorConfig['id'];
+        name: PropertyEditorConfig['name'];
+    }): PropertyEditorConfig | undefined;
+    export function getViewer(config: ToolConfig): any;
+    export function getHead(config: ToolConfig): any;
+    export function getDefaultValidator(config: ToolConfig | string): Validator | undefined;
+    export function getValidator(config: ToolConfig | string, { fallbackToDefault }?: {
+        fallbackToDefault?: boolean;
+    }): Validator | undefined;
+    export function getToolData(config: ToolConfig): any;
+    export function getToolTransformer(config: Pick<ToolConfig, 'slug' | 'type'>): {};
+    export function getToolPropertyStates(config: ToolConfig): {};
+    export function rowPropertyStates(values: object, snapshot: {
+        designMode: DesignMode;
+        displayConditions: DisplayConditions | undefined;
+        entitlements: any;
+    }): {
+        columns: {
+            enabled: boolean;
+        };
+        displayCondition: {
+            enabled: boolean;
+        };
+    } | {
+        columns: {
+            enabled: boolean;
+        };
+        displayCondition?: undefined;
+    };
+    export function columnPropertyStates(_values: any, snapshot: {
+        designMode: DesignMode;
+        displayConditions: DisplayConditions | undefined;
+        entitlements: any;
+    }, { rowValues, }?: {
+        rowValues?: {
+            deletable?: boolean;
+        };
+    }): {
+        deletable: {
+            disabled: boolean;
+            enabled: boolean;
+        };
+    };
+    export function contentPropertyStates(_values: any, snapshot: {
+        displayConditions: DisplayConditions | undefined;
+        entitlements: any;
+    }): {
+        displayCondition: {
+            enabled: boolean;
+        };
+    } | {
+        displayCondition?: undefined;
+    };
+    export function isToolEditable(config: ToolConfig): boolean;
+    export function getToolSupportedDisplayModes(config: Parameters<typeof getToolId>[0]): any[];
+    export function isToolSupportedAtThisDisplayMode(config: Parameters<typeof getToolSupportedDisplayModes>[0], displayMode: DisplayMode): boolean | null;
+    export function getToolApplyDesignTags(config: ToolConfig): (values: ValueMap, designTags: DesignTags, template: typeof Mustache.render) => ValueMap;
+    export type ToolItem = Pick<ToolConfig, 'location' | 'type' | 'values'> & {
+        [key: string]: any;
+    };
+    export function getRenderValues(toolItem: ToolItem, values?: object, { device, }?: {
+        device?: Device | undefined;
+    }): Record<string, object>;
+    export function getEmbeddedValues(design: RootState['design'], toolItem: ToolItem, { device, language, renderValues, }?: {
+        device?: Device;
+        language?: string;
+        renderValues?: boolean;
+    }): {};
+    export function getEmbeddedInitialValues(toolItem: ToolItem, { designMode, deviceName, }: {
+        designMode: DesignMode;
+        deviceName: Device;
+    }): Record<string, Record<string, unknown>>;
+    export function getEmbeddedOptionsConfig(toolItem: ToolItem): Record<string, OptionGroupEmbeddedConfig<ValueMap>>;
+    export function getEmbeddedOptionGroups(embedded: OptionGroupEmbeddedConfig, { designMode, deviceName }: {
+        designMode: DesignMode;
+        deviceName: Device;
+    }): OptionGroupConfigMap<ValueMap>;
+    export function getMergedEmbeddedOptionGroup(embedded: OptionGroupEmbeddedConfig, { designMode, deviceName }: {
+        designMode: DesignMode;
+        deviceName: Device;
+    }): Partial<Pick<OptionGroupConfig<ValueMap>, "title" | "options">>;
+    export function getItemExporter(config: ToolConfig, displayMode: DisplayMode, variant?: Variant): ItemExporter;
+    export function getContainerExporter<C extends Container>(type: C, displayMode: DisplayMode, variant?: Variant): C extends 'content' ? ContentContainerExporter : C extends 'column' ? ColumnContainerExporter : C extends 'row' ? RowContainerExporter : C extends 'body' ? BodyContainerExporter : Function;
+    export function getToolId<Values extends ValueMap>(config: Pick<ToolConfig<Values>, 'slug' | 'type'> | string): string;
+    export function getToolIdForStyleGuide(item: Parameters<typeof getToolId>[0] & Pick<ToolConfig<Values>, 'location'>): string | undefined;
+    export function getOptionId(config: Pick<ToolConfig, 'slug' | 'type'> | string | undefined): string | undefined;
+    export function getPropertyEditorId(config: {
+        name?: PropertyEditorConfig['name'];
+    } | string): string;
+    export function registerColumns(cells: number[]): void;
+    export function getEmptyRow(type: string): {
+        type: string;
+        slug: any;
+        cells: number[];
+        values: {
+            [id: string]: unknown;
+        };
+        columns: {
+            contents: any[];
+            values: {
+                [id: string]: unknown;
+            };
+        }[];
+    };
+    export function supportedDisplayModesFilter<Object extends {
+        supportedDisplayModes?: DisplayMode[];
+    }>(item: Object, { displayMode }: {
+        displayMode: DisplayMode;
+    }): boolean;
+    export function isSupportedFilter(tool: ToolConfig, { displayMode }: {
+        displayMode: DisplayMode;
+    }): boolean;
+    export function hiddenFilter(tool: ToolConfig): boolean;
+    export function variantFilter(tool: ToolConfig): boolean;
+    export function getAvailableTools({ displayMode, entitlements, }: {
+        displayMode: DisplayMode;
+        entitlements: Entitlements;
+    }): {
+        availableTools: any[];
+        availableToolsWithDefaultRow: any[];
+        classicTools: any[];
+    };
+}
+declare module "packages/editor/src/engine/config/tabs" {
+    import { DisplayMode, Location, Tabs, Variant } from "packages/editor/src/state/types/types";
+    type ValueMap = {
+        [id: string]: unknown;
+    };
+    export interface TabConfig<Values extends ValueMap = ValueMap> {
+        id?: string;
+        name: string;
+        type?: string;
+        slug?: string;
+        label?: string;
+        icon?: string | string[];
+        renderer?: {
+            Panel: any;
+        };
+        supportedDisplayModes?: DisplayMode[];
+        supportedVariants?: Variant[];
+        classic?: boolean;
+        enabled?: boolean;
+        position?: number;
+        location?: Location;
+    }
+    export type TabConfigMap = {
+        [id: string]: TabConfig;
+    };
+    export type PanelMap = {
+        [id: string]: unknown;
+    };
+    export function getTabs(): TabConfig<ValueMap>[];
+    export function registerTab<Values extends ValueMap>(config: TabConfig<Values>): void;
+    export function getTabId<Values extends ValueMap>(config: TabConfig<Values> | string): string;
+    export function getCustomTabsCount(): number;
+    export function updateTabs(_tabs: Tabs): void;
+}
+declare module "packages/editor/src/engine/config/createPanel" {
+    import React, { RefObject } from 'react';
+    export type PanelMountFn = (node: RefObject<HTMLDivElement> | null) => void;
+    export type PanelRenderFn = () => string;
+    export interface PanelConfig {
+        mount: PanelMountFn;
+        render: PanelRenderFn;
+    }
+    export interface PanelProps {
+        values: unknown;
+        bodyValues: unknown;
+    }
+    export function createPanel(config: PanelConfig): () => React.JSX.Element;
+}
+declare module "packages/editor/src/engine/config/createViewer" {
+    import React from 'react';
+    export type ViewerMountFn = (node: HTMLDivElement | null, values: unknown) => void;
+    export type ViewerRenderFn = (values: object, bodyValues: object, info: {
+        columnIndex: number;
+        rowCells: number[];
+    }) => string;
+    export interface ViewerConfig {
+        mount: ViewerMountFn;
+        render: ViewerRenderFn;
+    }
+    export interface ViewerProps {
+        bodyValues: object;
+        columnIndex: number;
+        rowCells: number[];
+        values: object;
+    }
+    export function createViewer(config: ViewerConfig): {
+        new (props: ViewerProps): {
+            ref: HTMLDivElement | null;
+            componentDidMount(): void;
+            shouldComponentUpdate(nextProps: ViewerProps): boolean;
+            componentDidUpdate(prevProps: ViewerProps): void;
+            getRenderArgs(props?: ViewerProps): Parameters<ViewerRenderFn>;
+            render(): React.JSX.Element;
+            context: unknown;
+            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ViewerProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+            forceUpdate(callback?: () => void): void;
+            readonly props: Readonly<ViewerProps>;
+            state: Readonly<{}>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            componentWillUnmount?(): void;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<ViewerProps>, prevState: Readonly<{}>): any;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<ViewerProps>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ViewerProps>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<ViewerProps>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<ViewerProps>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        new (props: ViewerProps, context: any): {
+            ref: HTMLDivElement | null;
+            componentDidMount(): void;
+            shouldComponentUpdate(nextProps: ViewerProps): boolean;
+            componentDidUpdate(prevProps: ViewerProps): void;
+            getRenderArgs(props?: ViewerProps): Parameters<ViewerRenderFn>;
+            render(): React.JSX.Element;
+            context: unknown;
+            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ViewerProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+            forceUpdate(callback?: () => void): void;
+            readonly props: Readonly<ViewerProps>;
+            state: Readonly<{}>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            componentWillUnmount?(): void;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<ViewerProps>, prevState: Readonly<{}>): any;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<ViewerProps>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ViewerProps>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<ViewerProps>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<ViewerProps>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        contextType?: React.Context<any> | undefined;
+    };
+}
+declare module "packages/editor/src/engine/config/createWidget" {
+    import React from 'react';
+    export type WidgetMountFn = (node: HTMLDivElement | null, value: unknown, updateValue: unknown, data: unknown) => void;
+    export type WidgetRenderFn = (value: unknown, updateValue: unknown, data: unknown) => string;
+    export interface WidgetConfig {
+        mount: WidgetMountFn;
+        render: WidgetRenderFn;
+    }
+    export interface WidgetProps {
+        value: unknown;
+        updateValue: unknown;
+        data: unknown;
+    }
+    export function createWidget(config: WidgetConfig): {
+        new (props: WidgetProps): {
+            ref: HTMLDivElement | null;
+            componentDidMount(): void;
+            shouldComponentUpdate(nextProps: WidgetProps): boolean;
+            componentDidUpdate(prevProps: WidgetProps): void;
+            render(): React.JSX.Element;
+            context: unknown;
+            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<WidgetProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+            forceUpdate(callback?: () => void): void;
+            readonly props: Readonly<WidgetProps>;
+            state: Readonly<{}>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            componentWillUnmount?(): void;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<WidgetProps>, prevState: Readonly<{}>): any;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<WidgetProps>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<WidgetProps>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<WidgetProps>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<WidgetProps>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        new (props: WidgetProps, context: any): {
+            ref: HTMLDivElement | null;
+            componentDidMount(): void;
+            shouldComponentUpdate(nextProps: WidgetProps): boolean;
+            componentDidUpdate(prevProps: WidgetProps): void;
+            render(): React.JSX.Element;
+            context: unknown;
+            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<WidgetProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+            forceUpdate(callback?: () => void): void;
+            readonly props: Readonly<WidgetProps>;
+            state: Readonly<{}>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            componentWillUnmount?(): void;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<WidgetProps>, prevState: Readonly<{}>): any;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<WidgetProps>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<WidgetProps>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<WidgetProps>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<WidgetProps>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        contextType?: React.Context<any> | undefined;
+    };
+}
 declare module "packages/editor/src/engine/options/bodies" {
     export type { BodyValues } from '@libs/schemas/options/containers/bodies';
 }
@@ -2299,18 +2956,196 @@ declare module "packages/editor/src/engine/utils/makeClassMethodsEnumerable" {
 declare module "packages/editor/src/embed/helpers" {
     export function convertReturnFunctionToDoneCallback<Fn extends (...args: [any]) => any>(fn: Fn): (info: Parameters<Fn>[0], done: Function) => void;
 }
+declare module "packages/editor/src/state/types/callbacks" {
+    import type { DisplayMode, JSONTemplate, MergeTags } from "packages/editor/src/state/types/types";
+    export interface CallbackContext {
+        item: {
+            type: string;
+            id: string | number;
+        };
+        column?: {
+            id: string | number;
+        };
+        row?: {
+            id: string | number;
+        };
+    }
+    export interface CallbackTypeMap<TDisplayMode extends DisplayMode | undefined = undefined> {
+        'editor:ready': () => void;
+        'textEditor:ready': () => void;
+        'design:loaded': (data: {
+            design: JSONTemplate<TDisplayMode>;
+        }) => void;
+        /** @deprecated Use design:loaded instead */
+        onDesignLoad: (data: {
+            design: JSONTemplate<TDisplayMode>;
+        }) => void;
+        'design:updated': (data: {
+            type: string;
+            item?: Record<string, any>;
+            changes?: Record<string, any>;
+        }) => void;
+        'image:uploaded': (data: {
+            image: {
+                url: string;
+                width?: number;
+                height?: number;
+            };
+        }) => void;
+        /** @deprecated Use image:uploaded instead */
+        onImageUpload: (data: {
+            image: {
+                url: string;
+                width?: number;
+                height?: number;
+            };
+        }) => void;
+        'item:selected': (data: {
+            item: Record<string, any>;
+            active: boolean;
+        }) => void;
+        'page:added': (data: {
+            page: Record<string, any>;
+        }) => void;
+        'page:removed': (data: {
+            page: Record<string, any>;
+        }) => void;
+        'body:added': (data: {
+            body: Record<string, any>;
+        }) => void;
+        'body:removed': (data: {
+            body: Record<string, any>;
+        }) => void;
+        'row:added': (data: {
+            row: Record<string, any>;
+        }) => void;
+        'row:removed': (data: {
+            row: Record<string, any>;
+        }) => void;
+        'row:moved': (data: {
+            row: Record<string, any>;
+        }) => void;
+        'header:added': (data: {
+            header: Record<string, any>;
+        }) => void;
+        'header:removed': (data: {
+            header: Record<string, any>;
+        }) => void;
+        'footer:added': (data: {
+            footer: Record<string, any>;
+        }) => void;
+        'footer:removed': (data: {
+            footer: Record<string, any>;
+        }) => void;
+        'column:added': (data: {
+            column: Record<string, any>;
+        }) => void;
+        'column:removed': (data: {
+            column: Record<string, any>;
+        }) => void;
+        'content:added': (data: {
+            content: Record<string, any>;
+        }) => void;
+        'content:removed': (data: {
+            content: Record<string, any>;
+        }) => void;
+        'content:moved': (data: {
+            content: Record<string, any>;
+        }) => void;
+        image: (data: {
+            accepted: File[];
+            attachments: File[];
+        }, done: (result: {
+            progress?: number;
+            url?: string;
+            width?: number;
+            height?: number;
+            id?: number | string;
+            filename?: string;
+        }) => void) => void;
+        selectImage: (data: Record<string, any>, done: (result: {
+            url: string;
+            width?: number;
+            height?: number;
+            size?: number;
+            id?: string | number;
+        }) => void) => void;
+        displayCondition: (data: Record<string, any> & {
+            context: CallbackContext;
+        }, done: (result: {
+            type: string;
+            label: string;
+            description: string;
+            before: string;
+            after: string;
+        } | null) => void) => void;
+        mergeTag: (data: {
+            mergeTags: MergeTags;
+            mergeTagGroup?: string;
+            mergeTagRule?: string;
+            context: CallbackContext;
+        }, done: (result: {
+            name?: string;
+            value: string;
+        }) => void) => void;
+        mergeTagRule: (data: {
+            mergeTags: MergeTags;
+            mergeTagGroup?: string;
+            mergeTagRule?: string;
+            context: CallbackContext;
+        }, done: (result: {
+            mergeTagGroup: string;
+            mergeTagRule: string;
+        }) => void) => void;
+        previewHtml: (data: {
+            html: string;
+        }, done: (result: {
+            html: string;
+        }) => void) => void;
+        fetchImage: (data: {
+            url: string;
+        }, done: (result: {
+            blob: Blob;
+            url?: string;
+        }) => void) => void;
+        'image:removed': (params: {
+            id: string | number;
+            projectId?: number | null;
+            userId?: string | number;
+        }, done: () => void) => void;
+        itemAdded: (data: {
+            item: Record<string, any>;
+        }, done: (result: any) => void) => void;
+        itemRemoved: (data: {
+            item: Record<string, any>;
+        }, done: (result: boolean) => void) => void;
+        itemMoved: (data: {
+            item: Record<string, any>;
+        }, done: (result: any) => void) => void;
+        'block:added': (data: Record<string, any>, done: (result: any) => void) => void;
+        'block:modified': (data: Record<string, any>, done: (result: any) => void) => void;
+        'block:removed': (data: Record<string, any>, done: (result: any) => void) => void;
+    }
+}
 declare module "packages/editor/src/embed/Editor" {
     import { Frame } from "packages/editor/src/embed/Frame";
-    import { Config, ExportFromApiResult, ExportHtmlOptions, ExportHtmlResult, ExportPlainTextResult, ExportImageFromApiOptions, ExportLiveHtmlOptions, ExportPdfFromApiOptions, ExportPlainTextOptions, ExportZipFromApiOptions, SaveDesignOptions, ExportLiveHtmlResult } from "packages/editor/src/embed/Config";
-    import { AppearanceConfig, Audit, DesignMode, DesignTagsConfig, Device, DisplayConditions, DisplayMode, JSONTemplate, Language, LinkTypes, LinkTypesSharedConfig, MergeTags, MergeTagsConfig, SpecialLink, StyleGuideConfig, Tabs, Translations, User, Validator } from "packages/editor/src/state/types/types";
-    import { BodyValues } from "packages/editor/src/engine/options/bodies";
-    import { Locale, TextDirection } from "packages/editor/src/engine/config/intl";
-    import { DeepPartial } from "packages/editor/src/editor/components/editors/types";
-    import { ColorPicker } from "packages/editor/src/engine/config/features";
+    import type { Config, ExportFromApiResult, ExportHtmlOptions, ExportHtmlResult, ExportPlainTextResult, ExportImageFromApiOptions, ExportLiveHtmlOptions, ExportPdfFromApiOptions, ExportPlainTextOptions, ExportZipFromApiOptions, SaveDesignOptions, ExportLiveHtmlResult } from "packages/editor/src/embed/Config";
+    import type { ToolConfig as ToolDefinition } from "packages/editor/src/engine/config/tools";
+    import type { PropertyEditorConfig } from "packages/editor/src/engine/config/tools";
+    import type { TabConfig } from "packages/editor/src/engine/config/tabs";
+    import type { PanelConfig } from "packages/editor/src/engine/config/createPanel";
+    import type { ViewerConfig } from "packages/editor/src/engine/config/createViewer";
+    import type { WidgetConfig } from "packages/editor/src/engine/config/createWidget";
+    import type { AppearanceConfig, Audit, DesignMode, DesignTagsConfig, Device, DisplayConditions, DisplayMode, JSONTemplate, Language, LinkTypes, LinkTypesSharedConfig, MergeTags, MergeTagsConfig, SpecialLink, StyleGuideConfig, Tabs, Translations, User, Validator, Container, BodyContainerExporter, RowContainerExporter, ColumnContainerExporter, ContentContainerExporter, ItemExporter } from "packages/editor/src/state/types/types";
+    import type { BodyValues } from "packages/editor/src/engine/options/bodies";
+    import type { Locale, TextDirection } from "packages/editor/src/engine/config/intl";
+    import type { DeepPartial } from "packages/editor/src/editor/components/editors/types";
+    import type { ColorPicker } from "packages/editor/src/engine/config/features";
+    import type { CallbackTypeMap } from "packages/editor/src/state/types/callbacks";
     export const LATEST_VERSION: string;
     export const STABLE_VERSION: string;
     export const ENV_VERSION: string;
-    export class Editor {
+    export class Editor<TClassDisplayMode extends DisplayMode | undefined = undefined> {
         frame: Frame | null;
         constructor(config?: Config);
         init(config?: Config): void;
@@ -2325,12 +3160,16 @@ declare module "packages/editor/src/embed/Editor" {
         renderEditor(config: Config): void;
         initEditor(config: Config): void;
         registerColumns(cells: number[]): void;
-        registerCallback(type: string, callback: Function): void;
+        registerCallback<T extends keyof CallbackTypeMap<TClassDisplayMode>>(type: T, callback: CallbackTypeMap<TClassDisplayMode>[T]): void;
+        registerCallback(type: string, callback: (...args: any[]) => void): void;
+        unregisterCallback<T extends keyof CallbackTypeMap<TClassDisplayMode>>(type: T): void;
         unregisterCallback(type: string): void;
-        registerProvider(type: string, callback: Function): void;
+        registerProvider(type: string, callback: (...args: any[]) => any): void;
         unregisterProvider(type: string): void;
         reloadProvider(type: string): void;
-        addEventListener(type: string, callback: Function): void;
+        addEventListener<T extends keyof CallbackTypeMap<TClassDisplayMode>>(type: T, callback: CallbackTypeMap<TClassDisplayMode>[T]): void;
+        addEventListener(type: string, callback: (...args: any[]) => void): void;
+        removeEventListener<T extends keyof CallbackTypeMap<TClassDisplayMode>>(type: T): void;
         removeEventListener(type: string): void;
         setDesignId(id: string | null): void;
         setDesignMode(designMode: DesignMode | null): void;
@@ -2348,14 +3187,14 @@ declare module "packages/editor/src/embed/Editor" {
         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;
+        loadDesign<TDisplayMode extends DisplayMode | undefined = TClassDisplayMode>(design: JSONTemplate<TDisplayMode>): void;
+        saveDesign<TDisplayMode extends DisplayMode | undefined = TClassDisplayMode>(callback: (data: JSONTemplate<TDisplayMode>) => void, options?: SaveDesignOptions): void;
+        exportHtml<TDisplayMode extends DisplayMode | undefined = TClassDisplayMode>(callback: (data: ExportHtmlResult<TDisplayMode>) => void, options?: ExportHtmlOptions): void;
+        exportLiveHtml<TDisplayMode extends DisplayMode | undefined = TClassDisplayMode>(callback: (data: ExportLiveHtmlResult<TDisplayMode>) => void, options?: ExportLiveHtmlOptions): void;
+        exportPlainText<TDisplayMode extends DisplayMode | undefined = TClassDisplayMode>(callback: (data: ExportPlainTextResult<TDisplayMode>) => void, options?: ExportPlainTextOptions): void;
+        exportImage<TDisplayMode extends DisplayMode | undefined = TClassDisplayMode>(callback: (data: ExportFromApiResult<TDisplayMode>) => void, options?: ExportImageFromApiOptions): void;
+        exportPdf<TDisplayMode extends DisplayMode | undefined = TClassDisplayMode>(callback: (data: ExportFromApiResult<TDisplayMode>) => void, options?: ExportPdfFromApiOptions): void;
+        exportZip<TDisplayMode extends DisplayMode | undefined = TClassDisplayMode>(callback: (data: ExportFromApiResult<TDisplayMode>) => void, options?: ExportZipFromApiOptions): void;
         setAppearance(appearance: DeepPartial<AppearanceConfig>): void;
         setTheme(theme: AppearanceConfig['theme']): void;
         setBodyValues(bodyValues: Partial<BodyValues>, bodyId?: number): void;
@@ -2365,7 +3204,7 @@ declare module "packages/editor/src/embed/Editor" {
         showPreview(payload: {
             device?: Device;
             resolution?: number;
-        }): void;
+        } | Device): void;
         hidePreview(): void;
         canUndo(callback: (result: boolean) => void): void;
         canRedo(callback: (result: boolean) => void): void;
@@ -2382,22 +3221,28 @@ declare module "packages/editor/src/embed/Editor" {
         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;
+        registerContainerExporter(_name: Container, _exporter: BodyContainerExporter | RowContainerExporter | ColumnContainerExporter | ContentContainerExporter | null | undefined): void;
+        registerItemExporter(_name: string, _exporter: ItemExporter<Record<string, unknown>> | null | undefined): void;
+        registerTool(_config: ToolDefinition): void;
+        registerPropertyEditor(_config: PropertyEditorConfig): void;
+        registerTab(_config: TabConfig): void;
+        createPanel(_config: PanelConfig): void;
+        createViewer(_config: ViewerConfig): void;
+        createWidget(_config: WidgetConfig): void;
     }
 }
 declare module "packages/editor/src/embed/index" {
     import { Editor } from "packages/editor/src/embed/Editor";
-    import { Config } from "packages/editor/src/embed/Config";
+    import type { Config } from "packages/editor/src/embed/Config";
+    import type { DisplayMode } from "packages/editor/src/state/types/types";
     class Embed extends Editor {
-        createEditor(config: Config): Editor;
+        createEditor<TDisplayMode extends DisplayMode | undefined = undefined>(config: Config): Editor<TDisplayMode>;
     }
     const _default: Embed;
     export default _default;
+    export type UnlayerEditor<TDisplayMode extends DisplayMode | undefined = undefined> = Editor<TDisplayMode>;
+    export type UnlayerEmbed<TDisplayMode extends DisplayMode | undefined = undefined> = Omit<Embed, keyof Editor> & Editor<TDisplayMode>;
+    export type UnlayerOptions<TDisplayMode extends DisplayMode | undefined = undefined> = Omit<Config, 'displayMode'> & {
+        displayMode?: TDisplayMode extends undefined ? DisplayMode : TDisplayMode;
+    };
 }

package/package.json

@@ -1,5 +1,5 @@
 {
   "name": "unlayer-types",
-  "version": "1.386.0",
+  "version": "1.388.0",
   "license": "MIT"
 }