@elementor/editor-components 4.0.0-manual → 4.1.0-684

package/dist/index.d.ts

@@ -1,3 +1,1424 @@
+import * as axios from 'axios';
+import * as _elementor_editor_elements from '@elementor/editor-elements';
+import { V1ElementData, V1Element, V1ElementModelProps } from '@elementor/editor-elements';
+import { HttpResponse } from '@elementor/http-client';
+import * as _elementor_editor_props from '@elementor/editor-props';
+import { PropValue } from '@elementor/editor-props';
+import { StyleDefinition } from '@elementor/editor-styles';
+import * as React from 'react';
+import { ElementType, PropsWithChildren } from 'react';
+import { z } from '@elementor/schema';
+import { useElement } from '@elementor/editor-editing-panel';
+import { V1Document } from '@elementor/editor-documents';
+import * as reselect from 'reselect';
+import { PayloadAction, SliceState } from '@elementor/store';
+import * as immer_dist_internal_js from 'immer/dist/internal.js';
+import * as _reduxjs_toolkit_dist_tsHelpers from '@reduxjs/toolkit/dist/tsHelpers';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+
 declare function init(): void;
 
-export { init };
+type ComponentFormValues = {
+    componentName: string;
+};
+type ComponentId = number;
+type StylesDefinition = Record<ComponentId, StyleDefinition[]>;
+type Component = PublishedComponent | UnpublishedComponent;
+type PublishedComponent = BaseComponent & {
+    id: number;
+    isArchived?: boolean;
+};
+type OriginalElementData = {
+    model: V1ElementData;
+    parentId: string;
+    index: number;
+};
+type UnpublishedComponent = BaseComponent & {
+    elements: V1ElementData[];
+};
+type OriginPropFields = Pick<OverridableProp, 'propKey' | 'widgetType' | 'elType' | 'elementId'>;
+type OverridableProp = {
+    overrideKey: string;
+    label: string;
+    elementId: string;
+    propKey: string;
+    elType: string;
+    widgetType: string;
+    originValue: PropValue;
+    groupId: string;
+    originPropFields?: OriginPropFields;
+};
+type OverridablePropsGroup = {
+    id: string;
+    label: string;
+    props: string[];
+};
+type OverridableProps = {
+    props: Record<string, OverridableProp>;
+    groups: {
+        items: Record<string, OverridablePropsGroup>;
+        order: string[];
+    };
+};
+type BaseComponent = {
+    uid: string;
+    name: string;
+    overridableProps?: OverridableProps;
+};
+type DocumentStatus = 'publish' | 'draft';
+type DocumentSaveStatus = DocumentStatus | 'autosave';
+type ElementorStorage = {
+    get: <T = unknown>(key: string) => T | null;
+    set: <T>(key: string, data: T) => void;
+};
+type ExtendedWindow = Window & {
+    elementorCommon: Record<string, unknown> & {
+        eventsManager: {
+            config: {
+                locations: Record<string, string | Record<string, string>>;
+                secondaryLocations: Record<string, string>;
+                triggers: Record<string, string>;
+            };
+        };
+        storage: ElementorStorage;
+    };
+    elementor?: {
+        getContainerByKeyValue?: (args: {
+            key: string;
+            value: string;
+            parent?: V1Element['view'];
+        }) => V1Element | null;
+    };
+};
+type UpdatedComponentName = {
+    componentId: number;
+    title: string;
+};
+
+type ComponentItems = Array<{
+    uid: string;
+    title: string;
+    elements: V1ElementData[];
+    settings?: {
+        overridable_props?: OverridableProps;
+    };
+}>;
+type CreateComponentPayload = {
+    status: DocumentSaveStatus;
+    items: ComponentItems;
+};
+type GetComponentResponse = Array<PublishedComponent>;
+type CreateComponentResponse = Record<string, number>;
+type ValidateComponentsPayload = {
+    items: ComponentItems;
+};
+type ValidateComponentsResponse = {
+    code: string;
+    message: string;
+    data: {
+        status: number;
+        meta: Record<string, unknown>;
+    };
+};
+declare const apiClient: {
+    get: () => Promise<GetComponentResponse>;
+    create: (payload: CreateComponentPayload) => Promise<CreateComponentResponse>;
+    updateStatuses: (ids: number[], status: DocumentSaveStatus) => Promise<axios.AxiosResponse<any, any, {}>>;
+    getComponentConfig: (id: number) => Promise<V1ElementData>;
+    invalidateComponentConfigCache: (id: number) => void;
+    getComponentLockStatus: (componentId: number) => Promise<{
+        isAllowedToSwitchDocument: boolean;
+        lockedBy: string;
+    }>;
+    lockComponent: (componentId: number) => Promise<{
+        success: boolean;
+    }>;
+    unlockComponent: (componentId: number) => Promise<{
+        success: boolean;
+    }>;
+    getOverridableProps: (componentId: number) => Promise<OverridableProps>;
+    updateArchivedComponents: (componentIds: number[], status: DocumentSaveStatus) => Promise<{
+        failedIds: number[];
+        successIds: number[];
+        success: boolean;
+    }>;
+    updateComponentTitle: (updatedComponentNames: UpdatedComponentName[], status: DocumentSaveStatus) => Promise<{
+        failedIds: number[];
+        successIds: number[];
+        success: boolean;
+    }>;
+    validate: (payload: ValidateComponentsPayload) => Promise<HttpResponse<ValidateComponentsResponse>>;
+};
+
+declare const ComponentSearch: () => React.JSX.Element;
+
+type ComponentItemProps = {
+    component: Omit<Component, 'id'> & {
+        id?: number;
+    };
+    disabled?: boolean;
+    draggable?: boolean;
+    onDragStart?: React.DragEventHandler;
+    onDragEnd?: React.DragEventHandler;
+    onClick?: () => void;
+    isEditing?: boolean;
+    error?: string | null;
+    nameSlot?: React.ReactNode;
+    endSlot?: React.ReactNode;
+};
+declare const ComponentItem: React.ForwardRefExoticComponent<ComponentItemProps & React.RefAttributes<HTMLElement>>;
+type EditableConfig = {
+    ref: React.Ref<HTMLElement>;
+    isEditing: boolean;
+    getProps: () => Record<string, unknown>;
+};
+type ComponentNameProps = {
+    name: string;
+    editable?: EditableConfig;
+};
+declare function ComponentName({ name, editable }: ComponentNameProps): React.JSX.Element;
+
+declare function ComponentsList(): React.JSX.Element;
+declare const EmptySearchResult: () => React.JSX.Element;
+declare const useFilteredComponents: () => {
+    components: (PublishedComponent | {
+        uid: string;
+        name: string;
+        overridableProps: OverridableProps | undefined;
+    })[];
+    isLoading: boolean;
+    searchValue: string;
+};
+
+declare const LoadingComponents: () => React.JSX.Element;
+
+declare const SearchProvider: ({ children, localStorageKey, }: {
+    children: React.ReactNode;
+    localStorageKey: string;
+}) => React.JSX.Element;
+
+declare const EmptyState: ({ onEditComponent }: {
+    onEditComponent?: () => void;
+}) => React.JSX.Element;
+
+type InstancePanelBodyProps = {
+    groups: OverridablePropsGroup[];
+    isEmpty: boolean;
+    emptyState: React.ReactNode;
+    componentInstanceId?: string;
+};
+declare function InstancePanelBody({ groups, isEmpty, emptyState, componentInstanceId }: InstancePanelBodyProps): React.JSX.Element;
+
+type InstancePanelHeaderProps = {
+    componentName: string;
+    actions?: React.ReactNode;
+};
+declare function InstancePanelHeader({ componentName, actions }: InstancePanelHeaderProps): React.JSX.Element;
+type EditComponentActionProps = {
+    label: string;
+    onClick?: () => void;
+    disabled?: boolean;
+    icon: ElementType;
+};
+declare function EditComponentAction({ label, onClick, disabled, icon: Icon }: EditComponentActionProps): React.JSX.Element;
+
+declare function useSanitizeOverridableProps(componentId: ComponentId | null, instanceElementId?: string): OverridableProps | undefined;
+
+declare const componentInstanceOverridesPropTypeUtil: {
+    extract: (prop: unknown) => ({
+        value: {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        };
+        $$type: "override";
+        disabled?: boolean | undefined;
+    } | {
+        value: {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        };
+        $$type: "overridable";
+        disabled?: boolean | undefined;
+    })[] | null | undefined;
+    isValid: (prop: unknown) => prop is _elementor_editor_props.TransformablePropValue<"overrides", ({
+        value: {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        };
+        $$type: "override";
+        disabled?: boolean | undefined;
+    } | {
+        value: {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        };
+        $$type: "overridable";
+        disabled?: boolean | undefined;
+    })[] | undefined>;
+    create: {
+        (value: ({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined): _elementor_editor_props.TransformablePropValue<"overrides", ({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined>;
+        (value: ({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined, createOptions?: _elementor_editor_props.CreateOptions): _elementor_editor_props.TransformablePropValue<"overrides", ({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined>;
+        (value: (prev?: ({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined) => ({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined, createOptions: _elementor_editor_props.CreateOptions): _elementor_editor_props.TransformablePropValue<"overrides", ({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined>;
+    };
+    schema: z.ZodObject<{
+        $$type: z.ZodLiteral<"overrides">;
+        value: z.ZodType<({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined, z.ZodTypeDef, ({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        $$type: "overrides";
+        value?: ({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined;
+        disabled?: boolean | undefined;
+    }, {
+        $$type: "overrides";
+        value?: ({
+            value: {
+                override_key: string;
+                schema_source: {
+                    type: "component";
+                    id: number;
+                };
+                override_value?: unknown;
+            };
+            $$type: "override";
+            disabled?: boolean | undefined;
+        } | {
+            value: {
+                override_key: string;
+                origin_value: {
+                    $$type: string;
+                    value?: unknown;
+                } | null;
+            };
+            $$type: "overridable";
+            disabled?: boolean | undefined;
+        })[] | undefined;
+        disabled?: boolean | undefined;
+    }>;
+    key: "overrides";
+};
+type ComponentInstanceOverridesPropValue = z.infer<typeof componentInstanceOverridesPropTypeUtil.schema>['value'];
+type ComponentInstanceOverride = NonNullable<ComponentInstanceOverridesPropValue>[number];
+
+type InstancePanelData = {
+    componentId: number;
+    component: Component;
+    overrides: ComponentInstanceOverridesPropValue;
+    overridableProps: NonNullable<ReturnType<typeof useSanitizeOverridableProps>>;
+    groups: OverridablePropsGroup[];
+    isEmpty: boolean;
+    componentInstanceId: string;
+};
+declare function useInstancePanelData(): InstancePanelData | null;
+
+declare const DetachAction: ({ componentInstanceId, componentId, }: {
+    componentInstanceId: string;
+    componentId: number;
+}) => React.JSX.Element;
+
+declare const COMPONENT_WIDGET_TYPE = "e-component";
+
+declare const useComponents: () => {
+    components: (PublishedComponent | {
+        uid: string;
+        name: string;
+        overridableProps: OverridableProps | undefined;
+    })[];
+    isLoading: boolean;
+};
+
+declare const useComponentsPermissions: () => {
+    canCreate: boolean;
+    canEdit: boolean;
+    canDelete: boolean;
+    canRename: boolean;
+};
+
+declare const componentInstanceOverridePropTypeUtil: {
+    extract: (prop: unknown) => {
+        override_key: string;
+        schema_source: {
+            type: "component";
+            id: number;
+        };
+        override_value?: unknown;
+    } | null;
+    isValid: (prop: unknown) => prop is _elementor_editor_props.TransformablePropValue<"override", {
+        override_key: string;
+        schema_source: {
+            type: "component";
+            id: number;
+        };
+        override_value?: unknown;
+    }>;
+    create: {
+        (value: {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        }): _elementor_editor_props.TransformablePropValue<"override", {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        }>;
+        (value: {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        }, createOptions?: _elementor_editor_props.CreateOptions): _elementor_editor_props.TransformablePropValue<"override", {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        }>;
+        (value: (prev?: {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        } | undefined) => {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        }, createOptions: _elementor_editor_props.CreateOptions): _elementor_editor_props.TransformablePropValue<"override", {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        }>;
+    };
+    schema: z.ZodObject<{
+        $$type: z.ZodLiteral<"override">;
+        value: z.ZodType<{
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        }, z.ZodTypeDef, {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        }>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        value: {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        };
+        $$type: "override";
+        disabled?: boolean | undefined;
+    }, {
+        value: {
+            override_key: string;
+            schema_source: {
+                type: "component";
+                id: number;
+            };
+            override_value?: unknown;
+        };
+        $$type: "override";
+        disabled?: boolean | undefined;
+    }>;
+    key: "override";
+};
+type ComponentInstanceOverrideProp = z.infer<typeof componentInstanceOverridePropTypeUtil.schema>;
+type ComponentInstanceOverridePropValue = ComponentInstanceOverrideProp['value'];
+
+declare const componentInstancePropTypeUtil: {
+    extract: (prop: unknown) => {
+        component_id: {
+            $$type: "number";
+            value: number | null;
+            disabled?: boolean | undefined;
+        };
+        overrides?: {
+            $$type: "overrides";
+            value?: ({
+                value: {
+                    override_key: string;
+                    schema_source: {
+                        type: "component";
+                        id: number;
+                    };
+                    override_value?: unknown;
+                };
+                $$type: "override";
+                disabled?: boolean | undefined;
+            } | {
+                value: {
+                    override_key: string;
+                    origin_value: {
+                        $$type: string;
+                        value?: unknown;
+                    } | null;
+                };
+                $$type: "overridable";
+                disabled?: boolean | undefined;
+            })[] | undefined;
+            disabled?: boolean | undefined;
+        } | undefined;
+    } | null;
+    isValid: (prop: unknown) => prop is _elementor_editor_props.TransformablePropValue<"component-instance", {
+        component_id: {
+            $$type: "number";
+            value: number | null;
+            disabled?: boolean | undefined;
+        };
+        overrides?: {
+            $$type: "overrides";
+            value?: ({
+                value: {
+                    override_key: string;
+                    schema_source: {
+                        type: "component";
+                        id: number;
+                    };
+                    override_value?: unknown;
+                };
+                $$type: "override";
+                disabled?: boolean | undefined;
+            } | {
+                value: {
+                    override_key: string;
+                    origin_value: {
+                        $$type: string;
+                        value?: unknown;
+                    } | null;
+                };
+                $$type: "overridable";
+                disabled?: boolean | undefined;
+            })[] | undefined;
+            disabled?: boolean | undefined;
+        } | undefined;
+    }>;
+    create: {
+        (value: {
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        }): _elementor_editor_props.TransformablePropValue<"component-instance", {
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        }>;
+        (value: {
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        }, createOptions?: _elementor_editor_props.CreateOptions): _elementor_editor_props.TransformablePropValue<"component-instance", {
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        }>;
+        (value: (prev?: {
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        } | undefined) => {
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        }, createOptions: _elementor_editor_props.CreateOptions): _elementor_editor_props.TransformablePropValue<"component-instance", {
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        }>;
+    };
+    schema: z.ZodObject<{
+        $$type: z.ZodLiteral<"component-instance">;
+        value: z.ZodType<{
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        }, z.ZodTypeDef, {
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        }>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        value: {
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        };
+        $$type: "component-instance";
+        disabled?: boolean | undefined;
+    }, {
+        value: {
+            component_id: {
+                $$type: "number";
+                value: number | null;
+                disabled?: boolean | undefined;
+            };
+            overrides?: {
+                $$type: "overrides";
+                value?: ({
+                    value: {
+                        override_key: string;
+                        schema_source: {
+                            type: "component";
+                            id: number;
+                        };
+                        override_value?: unknown;
+                    };
+                    $$type: "override";
+                    disabled?: boolean | undefined;
+                } | {
+                    value: {
+                        override_key: string;
+                        origin_value: {
+                            $$type: string;
+                            value?: unknown;
+                        } | null;
+                    };
+                    $$type: "overridable";
+                    disabled?: boolean | undefined;
+                })[] | undefined;
+                disabled?: boolean | undefined;
+            } | undefined;
+        };
+        $$type: "component-instance";
+        disabled?: boolean | undefined;
+    }>;
+    key: "component-instance";
+};
+type ComponentInstanceProp = z.infer<typeof componentInstancePropTypeUtil.schema>;
+type ComponentInstancePropValue = ComponentInstanceProp['value'];
+
+declare const componentOverridablePropTypeUtil: {
+    extract: (prop: unknown) => {
+        override_key: string;
+        origin_value: {
+            $$type: string;
+            value?: unknown;
+        } | null;
+    } | null;
+    isValid: (prop: unknown) => prop is _elementor_editor_props.TransformablePropValue<"overridable", {
+        override_key: string;
+        origin_value: {
+            $$type: string;
+            value?: unknown;
+        } | null;
+    }>;
+    create: {
+        (value: {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        }): _elementor_editor_props.TransformablePropValue<"overridable", {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        }>;
+        (value: {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        }, createOptions?: _elementor_editor_props.CreateOptions): _elementor_editor_props.TransformablePropValue<"overridable", {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        }>;
+        (value: (prev?: {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        } | undefined) => {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        }, createOptions: _elementor_editor_props.CreateOptions): _elementor_editor_props.TransformablePropValue<"overridable", {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        }>;
+    };
+    schema: z.ZodObject<{
+        $$type: z.ZodLiteral<"overridable">;
+        value: z.ZodType<{
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        }, z.ZodTypeDef, {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        }>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        value: {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        };
+        $$type: "overridable";
+        disabled?: boolean | undefined;
+    }, {
+        value: {
+            override_key: string;
+            origin_value: {
+                $$type: string;
+                value?: unknown;
+            } | null;
+        };
+        $$type: "overridable";
+        disabled?: boolean | undefined;
+    }>;
+    key: "overridable";
+};
+type ComponentOverridableProp = z.infer<typeof componentOverridablePropTypeUtil.schema>;
+type ComponentOverridablePropValue = ComponentOverridableProp['value'];
+
+type ComponentInstanceData = {
+    componentId: number;
+    overrides: ComponentInstanceOverridesPropValue;
+    overridableProps: OverridableProps;
+};
+declare function ComponentInstanceProvider({ children, ...props }: PropsWithChildren<ComponentInstanceData>): React.JSX.Element;
+
+type OverridablePropData = {
+    value?: ComponentOverridablePropValue;
+    componentInstanceElement?: ReturnType<typeof useElement>;
+};
+declare function OverridablePropProvider({ children, ...props }: PropsWithChildren<OverridablePropData>): React.JSX.Element;
+declare const useOverridablePropValue: () => {
+    override_key: string;
+    origin_value: {
+        $$type: string;
+        value?: unknown;
+    } | null;
+} | undefined;
+declare const useComponentInstanceElement: () => {
+    element: _elementor_editor_elements.Element;
+    elementType: _elementor_editor_elements.ElementType;
+    settings: Record<string, _elementor_editor_props.AnyTransformable | null>;
+} | undefined;
+
+declare function loadComponentsAssets(elements: V1ElementData[]): Promise<void>;
+
+declare function updateOverridableProp(componentId: number, propValue: ComponentOverridablePropValue, originPropFields?: OriginPropFields): void;
+
+type SanitizeAttributes = 'overridableProps';
+type ComponentsState = {
+    data: PublishedComponent[];
+    unpublishedData: UnpublishedComponent[];
+    loadStatus: 'idle' | 'pending' | 'error';
+    styles: StylesDefinition;
+    createdThisSession: Component['uid'][];
+    archivedThisSession: ComponentId[];
+    path: ComponentsPathItem[];
+    currentComponentId: V1Document['id'] | null;
+    updatedComponentNames: Record<number, string>;
+    sanitized: Record<ComponentId, Partial<Record<SanitizeAttributes, boolean>>>;
+};
+type ComponentsPathItem = {
+    instanceId?: string;
+    instanceTitle?: string;
+    componentId: V1Document['id'];
+};
+declare const SLICE_NAME = "components";
+
+type ComponentsReducer<P> = (state: ComponentsState, action: PayloadAction<P>) => void;
+declare function registerComponentsReducer<P>(name: string, reducer: ComponentsReducer<P>): void;
+declare function createComponentsAction<P>(name: string): {
+    action: _reduxjs_toolkit_dist_tsHelpers.IsAny<P, _reduxjs_toolkit.ActionCreatorWithPayload<any, string>, _reduxjs_toolkit_dist_tsHelpers.IsUnknown<P, _reduxjs_toolkit.ActionCreatorWithNonInferrablePayload<string>, _reduxjs_toolkit_dist_tsHelpers.IfVoid<P, _reduxjs_toolkit.ActionCreatorWithoutPayload<string>, _reduxjs_toolkit_dist_tsHelpers.IfMaybeUndefined<P, _reduxjs_toolkit.ActionCreatorWithOptionalPayload<P, string>, _reduxjs_toolkit.ActionCreatorWithPayload<P, string>>>>>;
+    register(reducer: ComponentsReducer<P>): void;
+    dispatch(payload: P): void;
+};
+declare const baseSlice: _reduxjs_toolkit.Slice<ComponentsState, {
+    add: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<PublishedComponent | PublishedComponent[]>) => void;
+    load: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<PublishedComponent[]>) => void;
+    addUnpublished: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<UnpublishedComponent>) => void;
+    removeUnpublished: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<string | string[]>) => void;
+    resetUnpublished: (state: immer_dist_internal_js.WritableDraft<ComponentsState>) => void;
+    removeStyles(state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<{
+        id: ComponentId;
+    }>): void;
+    addStyles: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: {
+        payload: any;
+        type: string;
+    }) => void;
+    addCreatedThisSession: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<string>) => void;
+    removeCreatedThisSession: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<string>) => void;
+    archive: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<number>) => void;
+    setCurrentComponentId: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<V1Document["id"] | null>) => void;
+    setPath: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<ComponentsState["path"]>) => void;
+    setOverridableProps: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<{
+        componentId: ComponentId;
+        overridableProps: OverridableProps;
+    }>) => void;
+    rename: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload }: PayloadAction<{
+        componentUid: string;
+        name: string;
+    }>) => void;
+    cleanUpdatedComponentNames: (state: immer_dist_internal_js.WritableDraft<ComponentsState>) => void;
+    updateComponentSanitizedAttribute: (state: immer_dist_internal_js.WritableDraft<ComponentsState>, { payload: { componentId, attribute }, }: PayloadAction<{
+        componentId: ComponentId;
+        attribute: SanitizeAttributes;
+    }>) => void;
+    resetSanitizedComponents: (state: immer_dist_internal_js.WritableDraft<ComponentsState>) => void;
+}, "components">;
+declare const slice: typeof baseSlice;
+
+type ComponentsSlice = SliceState<typeof slice>;
+
+declare const selectOverridableProps: ((state: ComponentsSlice, componentId: number) => OverridableProps | undefined) & reselect.OutputSelectorFields<(args_0: PublishedComponent | undefined) => OverridableProps | undefined, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+declare const useOverridableProps: (componentId: ComponentId | null) => OverridableProps | null | undefined;
+declare const selectPath: ((state: ComponentsSlice) => ComponentsPathItem[]) & reselect.OutputSelectorFields<(args_0: ComponentsPathItem[]) => ComponentsPathItem[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+declare const useCurrentComponentId: () => number | null;
+declare const useCurrentComponent: () => PublishedComponent | undefined;
+declare const useIsSanitizedComponent: (componentId: ComponentId | null, key: SanitizeAttributes) => boolean;
+
+declare const componentsActions: {
+    add(components: PublishedComponent | PublishedComponent[]): void;
+    load(components: PublishedComponent[]): void;
+    addUnpublished(component: UnpublishedComponent): void;
+    removeUnpublished(uids: string | string[]): void;
+    resetUnpublished(): void;
+    removeStyles(id: ComponentId): void;
+    addStyles(styles: Record<string, unknown>): void;
+    addCreatedThisSession(uid: string): void;
+    removeCreatedThisSession(uid: string): void;
+    archive(componentId: ComponentId): void;
+    setCurrentComponentId(id: V1Document["id"] | null): void;
+    setPath(path: ComponentsPathItem[]): void;
+    setOverridableProps(componentId: ComponentId, overridableProps: OverridableProps): void;
+    rename(componentUid: string, name: string): void;
+    cleanUpdatedComponentNames(): void;
+    updateComponentSanitizedAttribute(componentId: ComponentId, attribute: SanitizeAttributes): void;
+    resetSanitizedComponents(): void;
+};
+
+declare const componentsSelectors: {
+    getOverridableProps(componentId: ComponentId): OverridableProps | undefined;
+    getCurrentComponent(): PublishedComponent | undefined;
+    getCurrentComponentId(): number | null;
+    getUnpublishedComponents(): UnpublishedComponent[];
+    getUpdatedComponentNames(): {
+        componentId: number;
+        title: string;
+    }[];
+    getArchivedThisSession(): number[];
+    getCreatedThisSession(): string[];
+    getComponents(): (PublishedComponent | {
+        uid: string;
+        name: string;
+        overridableProps: OverridableProps | undefined;
+    })[];
+    getComponentByUid(componentUid: string): PublishedComponent | UnpublishedComponent | undefined;
+};
+
+type Options = {
+    status: DocumentSaveStatus;
+    elements: V1ElementData[];
+};
+declare function publishDraftComponentsInPageBeforeSave({ status, elements }: Options): Promise<void>;
+
+declare function filterValidOverridableProps(overridableProps: OverridableProps, instanceElementId?: string): OverridableProps;
+
+/**
+ * Resolves a container by its origin ID, with optional scoping to a component instance.
+ *
+ * When component instances are rendered, their inner elements get prefixed IDs
+ * (e.g., `{instanceId}_{originalId}`), but store data uses original IDs.
+ * This function bridges between the two by searching for elements with a matching `originId`.
+ *
+ * @param originElementId   - The original (unprefixed) element ID from store data
+ * @param instanceElementId - Optional instance widget ID to scope the search
+ *
+ * @return The container with prefixed runtime ID, or null if not found
+ *
+ * @example
+ * // Component editing mode (no prefixing)
+ * getContainerByOriginId('element-1') // returns container with id='element-1'
+ *
+ * @example
+ * // Instance editing mode (with hash prefixing)
+ * getContainerByOriginId('element-1', 'instance-abc')
+ * // returns container with id='{hash}_element-1' and originId='element-1'
+ */
+declare function getContainerByOriginId(originElementId: string, instanceElementId?: string): V1Element | null;
+
+declare function getOverridableProp({ componentId, overrideKey, }: {
+    componentId: number;
+    overrideKey: string;
+}): OverridableProp | undefined;
+
+declare const getPropTypeForComponentOverride: (overridableProp: OverridableProp) => _elementor_editor_props.PropType<{
+    key?: string;
+}> | undefined;
+
+declare function isComponentInstance(elementModel: Partial<V1ElementModelProps>): boolean;
+
+declare const resolveOverridePropValue: (originalPropValue: ComponentInstanceOverride | PropValue) => PropValue;
+
+declare function switchToComponent(componentId: number, componentInstanceId?: string | null, element?: HTMLElement | null): Promise<void>;
+
+type Source = 'user' | 'mcp_tool' | 'system';
+type ComponentEventData = Record<string, unknown> & {
+    action: 'createClicked' | 'created' | 'createCancelled' | 'instanceAdded' | 'edited' | 'propertyExposed' | 'propertyRemoved' | 'propertiesPanelOpened' | 'propertiesGroupCreated' | 'detached';
+    source: Source;
+};
+declare const trackComponentEvent: ({ action, source, ...data }: ComponentEventData) => void;
+declare const onElementDrop: (_args: unknown, element: V1Element) => void;
+
+export { COMPONENT_WIDGET_TYPE, type Component, type ComponentFormValues, type ComponentId, type ComponentInstanceOverride, type ComponentInstanceOverrideProp, type ComponentInstanceOverridePropValue, type ComponentInstanceOverridesPropValue, type ComponentInstanceProp, type ComponentInstancePropValue, ComponentInstanceProvider, ComponentItem, type ComponentItemProps, ComponentName, type ComponentOverridableProp, type ComponentOverridablePropValue, ComponentSearch, ComponentsList, type ComponentsPathItem, type ComponentsSlice, type ComponentsState, DetachAction, type DocumentSaveStatus, EditComponentAction, EmptySearchResult, type ExtendedWindow, EmptyState as InstanceEmptyState, InstancePanelBody, InstancePanelHeader, LoadingComponents, type OriginPropFields, type OriginalElementData, type OverridableProp, OverridablePropProvider, type OverridableProps, type OverridablePropsGroup, type PublishedComponent, SLICE_NAME, type SanitizeAttributes, SearchProvider, type Source, type StylesDefinition, type UnpublishedComponent, type UpdatedComponentName, apiClient, componentInstanceOverridePropTypeUtil, componentInstanceOverridesPropTypeUtil, componentInstancePropTypeUtil, componentOverridablePropTypeUtil, componentsActions, componentsSelectors, createComponentsAction, filterValidOverridableProps, getContainerByOriginId, getOverridableProp, getPropTypeForComponentOverride, init, isComponentInstance, loadComponentsAssets, onElementDrop, publishDraftComponentsInPageBeforeSave, registerComponentsReducer, resolveOverridePropValue, selectOverridableProps, selectPath, slice, switchToComponent, trackComponentEvent, updateOverridableProp, useComponentInstanceElement, useComponents, useComponentsPermissions, useCurrentComponent, useCurrentComponentId, useFilteredComponents, useInstancePanelData, useIsSanitizedComponent, useOverridablePropValue, useOverridableProps, useSanitizeOverridableProps };