@elementor/editor-elements 3.33.0-98 → 3.34.2

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { PropsSchema, PropValue, Props } from '@elementor/editor-props';
-import { StyleDefinitionID, StyleDefinition, StyleDefinitionVariant } from '@elementor/editor-styles';
+import { ClassState, StyleDefinitionID, StyleDefinition, StyleDefinitionVariant } from '@elementor/editor-styles';
 import * as _elementor_editor_v1_adapters from '@elementor/editor-v1-adapters';
 
 type ElementID = string;
@@ -12,6 +12,7 @@ type ElementType = {
     controls: ControlItem[];
     propsSchema: PropsSchema;
     dependenciesPerTargetMapping?: Record<string, string[]>;
+    styleStates?: ClassState[];
     title: string;
 };
 type ControlsSection = {
@@ -36,16 +37,48 @@ type Control = {
         };
     };
 };
-type ControlItem = ControlsSection | Control;
+type ElementControl = {
+    type: 'element-control';
+    value: {
+        type: string;
+        label?: string;
+        props: Record<string, unknown>;
+        meta?: {
+            layout?: ControlLayout;
+            topDivider?: boolean;
+        };
+    };
+};
+type ControlItem = ControlsSection | Control | ElementControl;
 type ControlLayout = 'full' | 'two-columns' | 'custom';
 
-type V1Element = {
+type ExtendedWindow = Window & {
+    elementor?: {
+        selection?: {
+            getElements: () => V1Element$1[];
+        };
+        widgetsCache?: Record<string, V1ElementConfig>;
+        documents?: {
+            getCurrent?: () => {
+                container: V1Element$1;
+            } | undefined;
+            getCurrentId?: () => number;
+        };
+        getContainer?: (id: string) => V1Element$1 | undefined;
+    };
+    elementorCommon?: {
+        helpers?: {
+            getUniqueId?: () => string;
+        };
+    };
+};
+type V1Element$1 = {
     id: string;
-    model: V1Model<V1ElementModelProps>;
-    settings: V1Model<V1ElementSettingsProps>;
-    children?: V1Element[] & {
-        findRecursive?: (predicate: (child: V1Element) => boolean) => V1Element | undefined;
-        forEachRecursive?: (callback: (child: V1Element) => void) => V1Element[];
+    model: V1Model$1<V1ElementModelProps$1>;
+    settings: V1Model$1<V1ElementSettingsProps$1>;
+    children?: V1Element$1[] & {
+        findRecursive?: (predicate: (child: V1Element$1) => boolean) => V1Element$1 | undefined;
+        forEachRecursive?: (callback: (child: V1Element$1) => void) => V1Element$1[];
     };
     view?: {
         el?: HTMLElement;
@@ -54,19 +87,43 @@ type V1Element = {
             get?: (index: number) => HTMLElement | undefined;
         };
     };
-    parent?: V1Element;
+    parent?: V1Element$1;
 };
-type V1ElementModelProps = {
+type ElementInteractions$1 = {
+    version: number;
+    items: InteractionItem$1[];
+};
+type InteractionItem$1 = {
+    interaction_id?: string;
+    animation: {
+        animation_type: string;
+        animation_id: string;
+    };
+};
+type V1ElementModelProps$1 = {
+    isLocked?: boolean;
     widgetType?: string;
     elType: string;
     id: string;
     styles?: Record<StyleDefinitionID, StyleDefinition>;
-    elements?: V1Model<V1ElementModelProps>[];
-    settings?: V1ElementSettingsProps;
+    elements?: V1Model$1<V1ElementModelProps$1>[];
+    settings?: V1ElementSettingsProps$1;
+    editor_settings?: V1ElementEditorSettingsProps$1;
+    interactions?: string | ElementInteractions$1;
 };
-type V1ElementSettingsProps = Record<string, PropValue>;
-type V1ElementConfig = {
+type V1ElementData = Omit<V1ElementModelProps$1, 'elements'> & {
+    elements?: V1ElementData[];
+};
+type V1ElementEditorSettingsProps$1 = {
+    title?: string;
+    initial_position?: number;
+    component_uid?: string;
+};
+type V1ElementSettingsProps$1 = Record<string, PropValue>;
+type V1ElementConfig<T = object> = {
     title: string;
+    widgetType?: string;
+    elType?: string;
     controls: object;
     atomic?: boolean;
     atomic_controls?: ControlItem[];
@@ -76,8 +133,9 @@ type V1ElementConfig = {
     twig_main_template?: string;
     base_styles?: Record<string, StyleDefinition>;
     base_styles_dictionary?: Record<string, string>;
-};
-type V1Model<T> = {
+    atomic_style_states?: ClassState[];
+} & T;
+type V1Model$1<T> = {
     get: <K extends keyof T>(key: K) => T[K];
     set: <K extends keyof T>(key: K, value: T[K]) => void;
     toJSON: (options?: {
@@ -85,10 +143,71 @@ type V1Model<T> = {
     }) => T;
 };
 
+type ElementModel = {
+    id: string;
+};
+type ElementChildren = Record<string, ElementModel[]>;
+declare function useElementChildren<T extends ElementChildren>(elementId: ElementID, childrenTypes: Record<string, string>): T;
+
+declare const useElementEditorSettings: (elementId: ElementID) => V1ElementEditorSettingsProps$1;
+
 declare const useElementSetting: <TValue>(elementId: ElementID, settingKey: string) => TValue | null;
 declare const useElementSettings: <TValue>(elementId: ElementID, settingKeys: string[]) => Record<string, TValue>;
 
-declare function useElementType(type?: string): ElementType | null;
+type V1Element = {
+    id: string;
+    model: V1Model<V1ElementModelProps>;
+    settings: V1Model<V1ElementSettingsProps>;
+    children?: V1Element[] & {
+        findRecursive?: (predicate: (child: V1Element) => boolean) => V1Element | undefined;
+        forEachRecursive?: (callback: (child: V1Element) => void) => V1Element[];
+    };
+    view?: {
+        el?: HTMLElement;
+        _index?: number;
+        getDomElement?: () => {
+            get?: (index: number) => HTMLElement | undefined;
+        };
+    };
+    parent?: V1Element;
+};
+type ElementInteractions = {
+    version: number;
+    items: InteractionItem[];
+};
+type InteractionItem = {
+    interaction_id?: string;
+    animation: {
+        animation_type: string;
+        animation_id: string;
+    };
+};
+type V1ElementModelProps = {
+    isLocked?: boolean;
+    widgetType?: string;
+    elType: string;
+    id: string;
+    styles?: Record<StyleDefinitionID, StyleDefinition>;
+    elements?: V1Model<V1ElementModelProps>[];
+    settings?: V1ElementSettingsProps;
+    editor_settings?: V1ElementEditorSettingsProps;
+    interactions?: string | ElementInteractions;
+};
+type V1ElementEditorSettingsProps = {
+    title?: string;
+    initial_position?: number;
+    component_uid?: string;
+};
+type V1ElementSettingsProps = Record<string, PropValue>;
+type V1Model<T> = {
+    get: <K extends keyof T>(key: K) => T[K];
+    set: <K extends keyof T>(key: K, value: T[K]) => void;
+    toJSON: (options?: {
+        remove?: string[];
+    }) => T;
+};
+
+declare function useParentElement(elementId: string | null): V1Element | null | undefined;
 
 declare function useSelectedElement(): {
     element: null;
@@ -98,39 +217,20 @@ declare function useSelectedElement(): {
     elementType: ElementType;
 };
 
-declare function useParentElement(elementId: string | null): V1Element | null | undefined;
-
-type ElementModel = {
-    id: string;
-};
-type ElementChildren = Record<string, ElementModel[]>;
-declare function useElementChildren<T extends ElementChildren>(elementId: ElementID, childrenTypes: (keyof T & string)[]): T;
-
-type Options$2 = {
+type Options$4 = {
     useHistory?: boolean;
     at?: number;
     clone?: boolean;
 };
 type CreateElementParams = {
     containerId: string;
-    options?: Options$2;
-    model?: Omit<V1ElementModelProps, 'settings' | 'id'> & {
-        settings?: V1ElementSettingsProps;
+    options?: Options$4;
+    model?: Omit<V1ElementModelProps$1, 'settings' | 'id'> & {
+        settings?: V1ElementSettingsProps$1;
         id?: string;
     };
 };
-declare function createElement({ containerId, model, options }: CreateElementParams): V1Element;
-
-type Options$1 = {
-    useHistory?: boolean;
-    at?: number;
-    clone?: boolean;
-};
-type DuplicateElementParams = {
-    elementId: string;
-    options?: Options$1;
-};
-declare function duplicateElement({ elementId, options }: DuplicateElementParams): V1Element;
+declare function createElement({ containerId, model, options }: CreateElementParams): V1Element$1;
 
 type CreateNestedElementsParams = {
     elements: CreateElementParams[];
@@ -139,7 +239,7 @@ type CreateNestedElementsParams = {
 };
 type CreatedElement = {
     elementId: string;
-    model: V1ElementModelProps;
+    model: V1ElementModelProps$1;
     createParams: CreateElementParams;
 };
 type CreatedElementsResult = {
@@ -148,17 +248,53 @@ type CreatedElementsResult = {
 
 declare const createElements: ({ elements, title, subtitle, }: CreateNestedElementsParams) => CreatedElementsResult;
 
+type Options$3 = {
+    useHistory?: boolean;
+    at?: number;
+};
+declare function deleteElement({ elementId, options, }: {
+    elementId: string;
+    options?: Options$3;
+}): Promise<void>;
+
+type Options$2 = {
+    useHistory?: boolean;
+    at?: number;
+    scrollIntoView: boolean;
+};
+type DropElementParams = {
+    containerId: string;
+    options?: Options$2;
+    model?: Omit<V1ElementModelProps$1, 'settings' | 'id'> & {
+        settings?: V1ElementSettingsProps$1;
+        id?: string;
+    };
+};
+declare function dropElement({ containerId, model, options }: DropElementParams): V1Element$1;
+
+type Options$1 = {
+    useHistory?: boolean;
+    at?: number;
+    clone?: boolean;
+};
+type DuplicateElementParams = {
+    elementId: string;
+    options?: Options$1;
+};
+declare function duplicateElement({ elementId, options }: DuplicateElementParams): V1Element$1;
+
 type DuplicateElementsParams = {
     elementIds: string[];
     title: string;
     subtitle?: string;
-    onCreate?: (duplicatedElements: DuplicatedElement[]) => DuplicatedElement[];
+    onDuplicateElements?: () => void;
+    onRestoreElements?: () => void;
 };
 type DuplicatedElement = {
     id: string;
-    model: V1ElementModelProps;
+    model: V1ElementModelProps$1;
     originalElementId: string;
-    modelToRestore?: V1ElementModelProps;
+    modelToRestore?: V1ElementModelProps$1;
     parentContainerId?: string;
     at?: number;
 };
@@ -166,26 +302,82 @@ type DuplicatedElementsResult = {
     duplicatedElements: DuplicatedElement[];
 };
 
-declare const duplicateElements: ({ elementIds, title, subtitle, onCreate, }: DuplicateElementsParams) => DuplicatedElementsResult;
+declare const duplicateElements: ({ elementIds, title, subtitle, onDuplicateElements, onRestoreElements, }: DuplicateElementsParams) => DuplicatedElementsResult;
+
+declare const generateElementId: () => string;
+
+declare function getContainer(id: string): V1Element$1 | null;
+declare const selectElement: (elementId: string) => void;
+
+declare function getCurrentDocumentContainer(): V1Element$1 | null;
+
+declare function getCurrentDocumentId(): number | null;
+
+declare function getElementEditorSettings(elementId: ElementID): V1ElementEditorSettingsProps$1;
+
+declare function getElementLabel(elementId?: ElementID): string;
+
+declare const getElementSetting: <TValue>(elementId: ElementID, settingKey: string) => TValue | null;
+declare const getElementSettings: <TValue>(elementId: ElementID, settingKey: string[]) => Record<string, TValue | null>;
+
+declare const getElementStyles: (elementID: ElementID) => Record<string, StyleDefinition> | null;
+
+declare function getElementType(type: string): ElementType | null;
+
+declare function getElements(root?: ElementID): V1Element$1[];
+
+declare function getSelectedElements(): Element[];
+
+type WidgetsCache<T> = Record<string, T>;
+declare function getWidgetsCache<T extends V1ElementConfig>(): WidgetsCache<T> | null;
 
 type Options = {
     useHistory?: boolean;
     at?: number;
+    edit?: boolean;
 };
-declare function deleteElement({ elementId, options }: {
+type MoveElementParams = {
     elementId: string;
+    targetContainerId: string;
     options?: Options;
-}): void;
+};
+declare function moveElement({ elementId, targetContainerId, options }: MoveElementParams): V1Element$1;
+
+type MoveElementsParams = {
+    moves: MoveElementParams[];
+    title: string;
+    subtitle?: string;
+    onMoveElements?: () => void;
+    onRestoreElements?: () => void;
+};
+type OriginalPosition = {
+    elementId: string;
+    originalContainerId: string;
+    originalIndex: number;
+};
+type MovedElement = {
+    elementId: string;
+    originalPosition: OriginalPosition;
+    move: MoveElementParams;
+    element: V1Element$1;
+};
+type MovedElementsResult = {
+    movedElements: MovedElement[];
+};
+
+declare const moveElements: ({ moves: movesToMake, title, subtitle, onMoveElements, onRestoreElements, }: MoveElementsParams) => MovedElementsResult;
 
 type RemoveNestedElementsParams = {
     elementIds: string[];
     title: string;
     subtitle?: string;
+    onRemoveElements?: () => void;
+    onRestoreElements?: () => void;
 };
 type RemovedElement = {
     elementId: string;
-    model: V1ElementModelProps;
-    parent: V1Element | null;
+    model: V1ElementModelProps$1;
+    parent: V1Element$1 | null;
     at: number;
 };
 type RemovedElementsResult = {
@@ -193,25 +385,19 @@ type RemovedElementsResult = {
     removedElements: RemovedElement[];
 };
 
-declare const removeElements: ({ elementIds, title, subtitle, }: RemoveNestedElementsParams) => RemovedElementsResult;
-
-declare function getContainer(id: string): V1Element | null;
-declare const selectElement: (elementId: string) => void;
+declare const removeElements: ({ elementIds, title, subtitle, onRemoveElements, onRestoreElements, }: RemoveNestedElementsParams) => RemovedElementsResult;
 
-declare const getElementSetting: <TValue>(elementId: ElementID, settingKey: string) => TValue | null;
-declare const getElementSettings: <TValue>(elementId: ElementID, settingKey: string[]) => Record<string, TValue | null>;
-
-declare const getElementStyles: (elementID: ElementID) => Record<string, StyleDefinition> | null;
-
-declare function getElementLabel(elementId: ElementID): string;
-
-declare function getElements(root?: ElementID): V1Element[];
-
-declare function getCurrentDocumentId(): number | null;
-
-declare function getSelectedElements(): Element[];
+type ReplaceElementArgs = {
+    currentElement: V1ElementData;
+    newElement: Omit<V1ElementModelProps$1, 'id'>;
+    withHistory?: boolean;
+};
+declare const replaceElement: ({ currentElement, newElement, withHistory }: ReplaceElementArgs) => void;
 
-declare function getWidgetsCache(): Record<string, V1ElementConfig> | null;
+declare const updateElementEditorSettings: ({ elementId, settings, }: {
+    elementId: string;
+    settings: V1ElementModelProps$1["editor_settings"];
+}) => void;
 
 type UpdateElementSettingsArgs = {
     id: ElementID;
@@ -220,14 +406,19 @@ type UpdateElementSettingsArgs = {
 };
 declare const updateElementSettings: ({ id, props, withHistory }: UpdateElementSettingsArgs) => void;
 
-declare const generateElementId: () => string;
-
-type ReplaceElementArgs = {
-    currentElement: V1Element;
-    newElement: Omit<V1ElementModelProps, 'id'>;
-    withHistory?: boolean;
+type LinkInLinkRestriction = {
+    shouldRestrict: true;
+    reason: 'ancestor' | 'descendant';
+    elementId: string | null;
+} | {
+    shouldRestrict: false;
+    reason?: never;
+    elementId?: never;
 };
-declare const replaceElement: ({ currentElement, newElement, withHistory }: ReplaceElementArgs) => void;
+declare function getLinkInLinkRestriction(elementId: string): LinkInLinkRestriction;
+declare function getAnchoredDescendantId(elementId: string): string | null;
+declare function getAnchoredAncestorId(elementId: string): string | null;
+declare function isElementAnchored(elementId: string): boolean;
 
 declare const ELEMENT_STYLE_CHANGE_EVENT = "elementor/editor-v2/editor-elements/style";
 declare const styleRerenderEvents: (_elementor_editor_v1_adapters.CommandEventDescriptor | _elementor_editor_v1_adapters.WindowEventDescriptor)[];
@@ -248,6 +439,8 @@ declare function shouldCreateNewLocalStyle<T>(payload: {
     provider: T | null;
 } | null): boolean;
 
+declare function deleteElementStyle(elementId: ElementID, styleId: StyleDefinitionID): void;
+
 type UpdateElementStyleArgs = {
     elementId: ElementID;
     styleId: StyleDefinition['id'];
@@ -257,20 +450,16 @@ type UpdateElementStyleArgs = {
 };
 declare function updateElementStyle(args: UpdateElementStyleArgs): void;
 
-declare function deleteElementStyle(elementId: ElementID, styleId: StyleDefinitionID): void;
+declare const useElementInteractions: (elementId: ElementID) => ElementInteractions$1;
 
-type LinkInLinkRestriction = {
-    shouldRestrict: true;
-    reason: 'ancestor' | 'descendant';
-    elementId: string | null;
-} | {
-    shouldRestrict: false;
-    reason?: never;
-    elementId?: never;
-};
-declare function getLinkInLinkRestriction(elementId: string): LinkInLinkRestriction;
-declare function getAnchoredDescendantId(elementId: string): string | null;
-declare function getAnchoredAncestorId(elementId: string): string | null;
-declare function isElementAnchored(elementId: string): boolean;
+declare function getElementInteractions(elementId: ElementID): ElementInteractions$1 | undefined;
+
+declare const updateElementInteractions: ({ elementId, interactions, }: {
+    elementId: string;
+    interactions: V1ElementModelProps$1["interactions"];
+}) => void;
+declare const playElementInteractions: (elementId: string, animationId: string) => void;
+
+declare function initMcp(): void;
 
-export { type Control, type ControlItem, type ControlLayout, type ControlsSection, type CreateElementParams, type CreateElementStyleArgs, type DuplicateElementParams, type DuplicateElementsParams, type DuplicatedElement, type DuplicatedElementsResult, ELEMENT_STYLE_CHANGE_EVENT, type Element, type ElementChildren, type ElementID, type ElementType, type LinkInLinkRestriction, type UpdateElementSettingsArgs, type UpdateElementStyleArgs, type V1Element, type V1ElementConfig, type V1ElementModelProps, type V1ElementSettingsProps, createElement, createElementStyle, createElements, deleteElement, deleteElementStyle, duplicateElement, duplicateElements, generateElementId, getAnchoredAncestorId, getAnchoredDescendantId, getContainer, getCurrentDocumentId, getElementLabel, getElementSetting, getElementSettings, getElementStyles, getElements, getLinkInLinkRestriction, getSelectedElements, getWidgetsCache, isElementAnchored, removeElements, replaceElement, selectElement, shouldCreateNewLocalStyle, styleRerenderEvents, updateElementSettings, updateElementStyle, useElementChildren, useElementSetting, useElementSettings, useElementType, useParentElement, useSelectedElement };
+export { type Control, type ControlItem, type ControlLayout, type ControlsSection, type CreateElementParams, type CreateElementStyleArgs, type DropElementParams, type DuplicateElementParams, type DuplicateElementsParams, type DuplicatedElement, type DuplicatedElementsResult, ELEMENT_STYLE_CHANGE_EVENT, type Element, type ElementChildren, type ElementControl, type ElementID, type ElementInteractions$1 as ElementInteractions, type ElementModel, type ElementType, type ExtendedWindow, type InteractionItem$1 as InteractionItem, type LinkInLinkRestriction, type MoveElementParams, type MoveElementsParams, type MovedElement, type MovedElementsResult, type UpdateElementSettingsArgs, type UpdateElementStyleArgs, type V1Element$1 as V1Element, type V1ElementConfig, type V1ElementData, type V1ElementEditorSettingsProps$1 as V1ElementEditorSettingsProps, type V1ElementModelProps$1 as V1ElementModelProps, type V1ElementSettingsProps$1 as V1ElementSettingsProps, createElement, createElementStyle, createElements, deleteElement, deleteElementStyle, dropElement, duplicateElement, duplicateElements, generateElementId, getAnchoredAncestorId, getAnchoredDescendantId, getContainer, getCurrentDocumentContainer, getCurrentDocumentId, getElementEditorSettings, getElementInteractions, getElementLabel, getElementSetting, getElementSettings, getElementStyles, getElementType, getElements, getLinkInLinkRestriction, getSelectedElements, getWidgetsCache, initMcp as initElementsMcp, isElementAnchored, moveElement, moveElements, playElementInteractions, removeElements, replaceElement, selectElement, shouldCreateNewLocalStyle, styleRerenderEvents, updateElementEditorSettings, updateElementInteractions, updateElementSettings, updateElementStyle, useElementChildren, useElementEditorSettings, useElementInteractions, useElementSetting, useElementSettings, useParentElement, useSelectedElement };