@element-plus/nightly 0.0.20220921 → 0.0.20220922

package/lib/components/color-picker/index.d.ts

@@ -470,13 +470,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 __epPropKey: true;
             };
             virtualTriggering: BooleanConstructor;
-            onMouseenter: FunctionConstructor;
-            onMouseleave: FunctionConstructor;
-            onClick: FunctionConstructor;
-            onKeydown: FunctionConstructor;
-            onFocus: FunctionConstructor;
-            onBlur: FunctionConstructor;
-            onContextmenu: FunctionConstructor;
+            onMouseenter: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onMouseleave: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onClick: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onKeydown: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onFocus: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onBlur: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onContextmenu: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
             id: StringConstructor;
             open: BooleanConstructor;
             appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown, string, boolean>;
@@ -774,13 +809,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 __epPropKey: true;
             };
             virtualTriggering: BooleanConstructor;
-            onMouseenter: FunctionConstructor;
-            onMouseleave: FunctionConstructor;
-            onClick: FunctionConstructor;
-            onKeydown: FunctionConstructor;
-            onFocus: FunctionConstructor;
-            onBlur: FunctionConstructor;
-            onContextmenu: FunctionConstructor;
+            onMouseenter: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onMouseleave: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onClick: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onKeydown: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onFocus: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onBlur: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onContextmenu: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
             id: StringConstructor;
             open: BooleanConstructor;
             appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown, string, boolean>;
@@ -1065,13 +1135,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     __epPropKey: true;
                 };
                 virtualTriggering: BooleanConstructor;
-                onMouseenter: FunctionConstructor;
-                onMouseleave: FunctionConstructor;
-                onClick: FunctionConstructor;
-                onKeydown: FunctionConstructor;
-                onFocus: FunctionConstructor;
-                onBlur: FunctionConstructor;
-                onContextmenu: FunctionConstructor;
+                onMouseenter: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onMouseleave: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onClick: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onKeydown: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onFocus: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onContextmenu: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
                 id: StringConstructor;
                 open: BooleanConstructor;
                 appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown, string, boolean>;
@@ -1415,13 +1520,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     __epPropKey: true;
                 };
                 readonly virtualTriggering: BooleanConstructor;
-                readonly onMouseenter: FunctionConstructor;
-                readonly onMouseleave: FunctionConstructor;
-                readonly onClick: FunctionConstructor;
-                readonly onKeydown: FunctionConstructor;
-                readonly onFocus: FunctionConstructor;
-                readonly onBlur: FunctionConstructor;
-                readonly onContextmenu: FunctionConstructor;
+                readonly onMouseenter: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onMouseleave: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onClick: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onKeydown: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onFocus: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onBlur: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onContextmenu: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
                 readonly id: StringConstructor;
                 readonly open: BooleanConstructor;
             }, {
@@ -1436,13 +1576,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                         __epPropKey: true;
                     };
                     readonly virtualTriggering: BooleanConstructor;
-                    readonly onMouseenter: FunctionConstructor;
-                    readonly onMouseleave: FunctionConstructor;
-                    readonly onClick: FunctionConstructor;
-                    readonly onKeydown: FunctionConstructor;
-                    readonly onFocus: FunctionConstructor;
-                    readonly onBlur: FunctionConstructor;
-                    readonly onContextmenu: FunctionConstructor;
+                    readonly onMouseenter: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onMouseleave: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onClick: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onKeydown: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onFocus: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onBlur: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onContextmenu: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
                     readonly id: StringConstructor;
                     readonly open: BooleanConstructor;
                 }>> & {
@@ -1490,13 +1665,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                         __epPropKey: true;
                     };
                     readonly virtualTriggering: BooleanConstructor;
-                    readonly onMouseenter: FunctionConstructor;
-                    readonly onMouseleave: FunctionConstructor;
-                    readonly onClick: FunctionConstructor;
-                    readonly onKeydown: FunctionConstructor;
-                    readonly onFocus: FunctionConstructor;
-                    readonly onBlur: FunctionConstructor;
-                    readonly onContextmenu: FunctionConstructor;
+                    readonly onMouseenter: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onMouseleave: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onClick: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onKeydown: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onFocus: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onBlur: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onContextmenu: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
                     readonly id: StringConstructor;
                     readonly open: BooleanConstructor;
                 }, {
@@ -1508,13 +1718,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                             __epPropKey: true;
                         };
                         readonly virtualTriggering: BooleanConstructor;
-                        readonly onMouseenter: FunctionConstructor;
-                        readonly onMouseleave: FunctionConstructor;
-                        readonly onClick: FunctionConstructor;
-                        readonly onKeydown: FunctionConstructor;
-                        readonly onFocus: FunctionConstructor;
-                        readonly onBlur: FunctionConstructor;
-                        readonly onContextmenu: FunctionConstructor;
+                        readonly onMouseenter: {
+                            readonly type: import("vue").PropType<(e: Event) => void>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly onMouseleave: {
+                            readonly type: import("vue").PropType<(e: Event) => void>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly onClick: {
+                            readonly type: import("vue").PropType<(e: Event) => void>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly onKeydown: {
+                            readonly type: import("vue").PropType<(e: Event) => void>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly onFocus: {
+                            readonly type: import("vue").PropType<(e: Event) => void>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly onBlur: {
+                            readonly type: import("vue").PropType<(e: Event) => void>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly onContextmenu: {
+                            readonly type: import("vue").PropType<(e: Event) => void>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
                         readonly id: StringConstructor;
                         readonly open: BooleanConstructor;
                     }>> & {
@@ -1538,13 +1783,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                         __epPropKey: true;
                     };
                     readonly virtualTriggering: BooleanConstructor;
-                    readonly onMouseenter: FunctionConstructor;
-                    readonly onMouseleave: FunctionConstructor;
-                    readonly onClick: FunctionConstructor;
-                    readonly onKeydown: FunctionConstructor;
-                    readonly onFocus: FunctionConstructor;
-                    readonly onBlur: FunctionConstructor;
-                    readonly onContextmenu: FunctionConstructor;
+                    readonly onMouseenter: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onMouseleave: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onClick: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onKeydown: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onFocus: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onBlur: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onContextmenu: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
                     readonly id: StringConstructor;
                     readonly open: BooleanConstructor;
                 }>>, {
@@ -1562,13 +1842,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     __epPropKey: true;
                 };
                 readonly virtualTriggering: BooleanConstructor;
-                readonly onMouseenter: FunctionConstructor;
-                readonly onMouseleave: FunctionConstructor;
-                readonly onClick: FunctionConstructor;
-                readonly onKeydown: FunctionConstructor;
-                readonly onFocus: FunctionConstructor;
-                readonly onBlur: FunctionConstructor;
-                readonly onContextmenu: FunctionConstructor;
+                readonly onMouseenter: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onMouseleave: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onClick: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onKeydown: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onFocus: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onBlur: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onContextmenu: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
                 readonly id: StringConstructor;
                 readonly open: BooleanConstructor;
             }>>, {
@@ -2378,7 +2693,7 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>) | ((new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>))[], unknown, unknown, () => {}, boolean>;
                     readonly strategy: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                 }, {
-                    emit: (event: string, ...args: any[]) => void;
+                    emit: ((event: "focus") => void) & ((event: "close") => void) & ((event: "blur") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void);
                     props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                         readonly id: StringConstructor;
                         readonly style: {
@@ -2627,7 +2942,11 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                         readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>) | ((new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>))[], unknown, unknown, () => {}, boolean>;
                         readonly strategy: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                     }>> & {
-                        [x: string & `on${string}`]: ((...args: any[]) => any) | undefined;
+                        onClose?: (() => any) | undefined;
+                        onFocus?: (() => any) | undefined;
+                        onBlur?: (() => any) | undefined;
+                        onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                        onMouseenter?: ((evt: MouseEvent) => any) | undefined;
                     }>>;
                     popperInstanceRef: import("vue").Ref<import("@popperjs/core").Instance | undefined>;
                     contentRef: import("vue").Ref<HTMLElement | undefined>;
@@ -2654,7 +2973,7 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                         cssVarBlockName: (name: string) => string;
                     };
                     popperContentRef: import("vue").Ref<HTMLElement | undefined>;
-                    focusStartRef: import("vue").Ref<string | HTMLElement>;
+                    focusStartRef: import("vue").Ref<HTMLElement | "first" | "container">;
                     arrowRef: import("vue").Ref<HTMLElement | undefined>;
                     arrowOffset: import("vue").Ref<number | undefined>;
                     contentZIndex: import("vue").Ref<number>;
@@ -2688,11 +3007,7 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                         [x: string]: boolean;
                     } | any)[])[])[])[])[])[])[])[])[])[])[]) | undefined)[]>;
                     ariaModal: import("vue").ComputedRef<string | undefined>;
-                    createPopperInstance: ({ referenceEl, popperContentEl, arrowEl }: {
-                        referenceEl: any;
-                        popperContentEl: any;
-                        arrowEl: any;
-                    }) => import("@popperjs/core").Instance;
+                    createPopperInstance: ({ referenceEl, popperContentEl, arrowEl, }: import("..").CreatePopperInstanceParams) => import("@popperjs/core").Instance;
                     updatePopper: (shouldUpdateZIndex?: boolean) => void;
                     togglePopperAlive: () => void;
                     onFocusAfterTrapped: () => void;
@@ -2730,7 +3045,13 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                         trapped: boolean;
                         focusStartEl: HTMLElement | "first" | "container";
                     }>;
-                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    mouseenter: (evt: MouseEvent) => boolean;
+                    mouseleave: (evt: MouseEvent) => boolean;
+                    focus: () => boolean;
+                    blur: () => boolean;
+                    close: () => boolean;
+                }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                     readonly id: StringConstructor;
                     readonly style: {
                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;
@@ -2978,7 +3299,11 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>) | ((new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>))[], unknown, unknown, () => {}, boolean>;
                     readonly strategy: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                 }>> & {
-                    [x: string & `on${string}`]: ((...args: any[]) => any) | undefined;
+                    onClose?: (() => any) | undefined;
+                    onFocus?: (() => any) | undefined;
+                    onBlur?: (() => any) | undefined;
+                    onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                    onMouseenter?: ((evt: MouseEvent) => any) | undefined;
                 }, {
                     readonly placement: import("element-plus/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
                     readonly offset: number;
@@ -3355,13 +3680,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
             __epPropKey: true;
         };
         virtualTriggering: BooleanConstructor;
-        onMouseenter: FunctionConstructor;
-        onMouseleave: FunctionConstructor;
-        onClick: FunctionConstructor;
-        onKeydown: FunctionConstructor;
-        onFocus: FunctionConstructor;
-        onBlur: FunctionConstructor;
-        onContextmenu: FunctionConstructor;
+        onMouseenter: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onMouseleave: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onClick: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onKeydown: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onFocus: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onBlur: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onContextmenu: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
         id: StringConstructor;
         open: BooleanConstructor;
         appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown, string, boolean>;
@@ -3646,13 +4006,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 __epPropKey: true;
             };
             virtualTriggering: BooleanConstructor;
-            onMouseenter: FunctionConstructor;
-            onMouseleave: FunctionConstructor;
-            onClick: FunctionConstructor;
-            onKeydown: FunctionConstructor;
-            onFocus: FunctionConstructor;
-            onBlur: FunctionConstructor;
-            onContextmenu: FunctionConstructor;
+            onMouseenter: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onMouseleave: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onClick: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onKeydown: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onFocus: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onBlur: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onContextmenu: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
             id: StringConstructor;
             open: BooleanConstructor;
             appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown, string, boolean>;
@@ -3996,13 +4391,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 __epPropKey: true;
             };
             readonly virtualTriggering: BooleanConstructor;
-            readonly onMouseenter: FunctionConstructor;
-            readonly onMouseleave: FunctionConstructor;
-            readonly onClick: FunctionConstructor;
-            readonly onKeydown: FunctionConstructor;
-            readonly onFocus: FunctionConstructor;
-            readonly onBlur: FunctionConstructor;
-            readonly onContextmenu: FunctionConstructor;
+            readonly onMouseenter: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onMouseleave: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onClick: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onKeydown: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onFocus: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onBlur: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onContextmenu: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
             readonly id: StringConstructor;
             readonly open: BooleanConstructor;
         }, {
@@ -4017,13 +4447,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     __epPropKey: true;
                 };
                 readonly virtualTriggering: BooleanConstructor;
-                readonly onMouseenter: FunctionConstructor;
-                readonly onMouseleave: FunctionConstructor;
-                readonly onClick: FunctionConstructor;
-                readonly onKeydown: FunctionConstructor;
-                readonly onFocus: FunctionConstructor;
-                readonly onBlur: FunctionConstructor;
-                readonly onContextmenu: FunctionConstructor;
+                readonly onMouseenter: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onMouseleave: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onClick: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onKeydown: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onFocus: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onBlur: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onContextmenu: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
                 readonly id: StringConstructor;
                 readonly open: BooleanConstructor;
             }>> & {
@@ -4071,13 +4536,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     __epPropKey: true;
                 };
                 readonly virtualTriggering: BooleanConstructor;
-                readonly onMouseenter: FunctionConstructor;
-                readonly onMouseleave: FunctionConstructor;
-                readonly onClick: FunctionConstructor;
-                readonly onKeydown: FunctionConstructor;
-                readonly onFocus: FunctionConstructor;
-                readonly onBlur: FunctionConstructor;
-                readonly onContextmenu: FunctionConstructor;
+                readonly onMouseenter: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onMouseleave: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onClick: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onKeydown: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onFocus: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onBlur: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onContextmenu: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
                 readonly id: StringConstructor;
                 readonly open: BooleanConstructor;
             }, {
@@ -4089,13 +4589,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                         __epPropKey: true;
                     };
                     readonly virtualTriggering: BooleanConstructor;
-                    readonly onMouseenter: FunctionConstructor;
-                    readonly onMouseleave: FunctionConstructor;
-                    readonly onClick: FunctionConstructor;
-                    readonly onKeydown: FunctionConstructor;
-                    readonly onFocus: FunctionConstructor;
-                    readonly onBlur: FunctionConstructor;
-                    readonly onContextmenu: FunctionConstructor;
+                    readonly onMouseenter: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onMouseleave: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onClick: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onKeydown: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onFocus: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onBlur: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onContextmenu: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
                     readonly id: StringConstructor;
                     readonly open: BooleanConstructor;
                 }>> & {
@@ -4119,13 +4654,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     __epPropKey: true;
                 };
                 readonly virtualTriggering: BooleanConstructor;
-                readonly onMouseenter: FunctionConstructor;
-                readonly onMouseleave: FunctionConstructor;
-                readonly onClick: FunctionConstructor;
-                readonly onKeydown: FunctionConstructor;
-                readonly onFocus: FunctionConstructor;
-                readonly onBlur: FunctionConstructor;
-                readonly onContextmenu: FunctionConstructor;
+                readonly onMouseenter: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onMouseleave: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onClick: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onKeydown: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onFocus: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onBlur: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onContextmenu: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
                 readonly id: StringConstructor;
                 readonly open: BooleanConstructor;
             }>>, {
@@ -4142,14 +4712,49 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 readonly validator: ((val: unknown) => boolean) | undefined;
                 __epPropKey: true;
             };
-            readonly virtualTriggering: BooleanConstructor;
-            readonly onMouseenter: FunctionConstructor;
-            readonly onMouseleave: FunctionConstructor;
-            readonly onClick: FunctionConstructor;
-            readonly onKeydown: FunctionConstructor;
-            readonly onFocus: FunctionConstructor;
-            readonly onBlur: FunctionConstructor;
-            readonly onContextmenu: FunctionConstructor;
+            readonly virtualTriggering: BooleanConstructor;
+            readonly onMouseenter: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onMouseleave: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onClick: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onKeydown: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onFocus: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onBlur: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onContextmenu: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
             readonly id: StringConstructor;
             readonly open: BooleanConstructor;
         }>>, {
@@ -4959,7 +5564,7 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>) | ((new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>))[], unknown, unknown, () => {}, boolean>;
                 readonly strategy: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
             }, {
-                emit: (event: string, ...args: any[]) => void;
+                emit: ((event: "focus") => void) & ((event: "close") => void) & ((event: "blur") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void);
                 props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                     readonly id: StringConstructor;
                     readonly style: {
@@ -5208,7 +5813,11 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>) | ((new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>))[], unknown, unknown, () => {}, boolean>;
                     readonly strategy: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                 }>> & {
-                    [x: string & `on${string}`]: ((...args: any[]) => any) | undefined;
+                    onClose?: (() => any) | undefined;
+                    onFocus?: (() => any) | undefined;
+                    onBlur?: (() => any) | undefined;
+                    onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                    onMouseenter?: ((evt: MouseEvent) => any) | undefined;
                 }>>;
                 popperInstanceRef: import("vue").Ref<import("@popperjs/core").Instance | undefined>;
                 contentRef: import("vue").Ref<HTMLElement | undefined>;
@@ -5235,7 +5844,7 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     cssVarBlockName: (name: string) => string;
                 };
                 popperContentRef: import("vue").Ref<HTMLElement | undefined>;
-                focusStartRef: import("vue").Ref<string | HTMLElement>;
+                focusStartRef: import("vue").Ref<HTMLElement | "first" | "container">;
                 arrowRef: import("vue").Ref<HTMLElement | undefined>;
                 arrowOffset: import("vue").Ref<number | undefined>;
                 contentZIndex: import("vue").Ref<number>;
@@ -5269,11 +5878,7 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     [x: string]: boolean;
                 } | any)[])[])[])[])[])[])[])[])[])[])[]) | undefined)[]>;
                 ariaModal: import("vue").ComputedRef<string | undefined>;
-                createPopperInstance: ({ referenceEl, popperContentEl, arrowEl }: {
-                    referenceEl: any;
-                    popperContentEl: any;
-                    arrowEl: any;
-                }) => import("@popperjs/core").Instance;
+                createPopperInstance: ({ referenceEl, popperContentEl, arrowEl, }: import("..").CreatePopperInstanceParams) => import("@popperjs/core").Instance;
                 updatePopper: (shouldUpdateZIndex?: boolean) => void;
                 togglePopperAlive: () => void;
                 onFocusAfterTrapped: () => void;
@@ -5311,7 +5916,13 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     trapped: boolean;
                     focusStartEl: HTMLElement | "first" | "container";
                 }>;
-            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                mouseenter: (evt: MouseEvent) => boolean;
+                mouseleave: (evt: MouseEvent) => boolean;
+                focus: () => boolean;
+                blur: () => boolean;
+                close: () => boolean;
+            }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                 readonly id: StringConstructor;
                 readonly style: {
                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;
@@ -5559,7 +6170,11 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>) | ((new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>))[], unknown, unknown, () => {}, boolean>;
                 readonly strategy: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
             }>> & {
-                [x: string & `on${string}`]: ((...args: any[]) => any) | undefined;
+                onClose?: (() => any) | undefined;
+                onFocus?: (() => any) | undefined;
+                onBlur?: (() => any) | undefined;
+                onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                onMouseenter?: ((evt: MouseEvent) => any) | undefined;
             }, {
                 readonly placement: import("element-plus/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
                 readonly offset: number;
@@ -6221,13 +6836,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
             __epPropKey: true;
         };
         virtualTriggering: BooleanConstructor;
-        onMouseenter: FunctionConstructor;
-        onMouseleave: FunctionConstructor;
-        onClick: FunctionConstructor;
-        onKeydown: FunctionConstructor;
-        onFocus: FunctionConstructor;
-        onBlur: FunctionConstructor;
-        onContextmenu: FunctionConstructor;
+        onMouseenter: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onMouseleave: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onClick: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onKeydown: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onFocus: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onBlur: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onContextmenu: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
         id: StringConstructor;
         open: BooleanConstructor;
         appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown, string, boolean>;
@@ -6510,13 +7160,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 __epPropKey: true;
             };
             virtualTriggering: BooleanConstructor;
-            onMouseenter: FunctionConstructor;
-            onMouseleave: FunctionConstructor;
-            onClick: FunctionConstructor;
-            onKeydown: FunctionConstructor;
-            onFocus: FunctionConstructor;
-            onBlur: FunctionConstructor;
-            onContextmenu: FunctionConstructor;
+            onMouseenter: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onMouseleave: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onClick: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onKeydown: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onFocus: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onBlur: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onContextmenu: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
             id: StringConstructor;
             open: BooleanConstructor;
             appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown, string, boolean>;
@@ -6860,13 +7545,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 __epPropKey: true;
             };
             readonly virtualTriggering: BooleanConstructor;
-            readonly onMouseenter: FunctionConstructor;
-            readonly onMouseleave: FunctionConstructor;
-            readonly onClick: FunctionConstructor;
-            readonly onKeydown: FunctionConstructor;
-            readonly onFocus: FunctionConstructor;
-            readonly onBlur: FunctionConstructor;
-            readonly onContextmenu: FunctionConstructor;
+            readonly onMouseenter: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onMouseleave: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onClick: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onKeydown: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onFocus: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onBlur: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onContextmenu: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
             readonly id: StringConstructor;
             readonly open: BooleanConstructor;
         }, {
@@ -6881,13 +7601,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     __epPropKey: true;
                 };
                 readonly virtualTriggering: BooleanConstructor;
-                readonly onMouseenter: FunctionConstructor;
-                readonly onMouseleave: FunctionConstructor;
-                readonly onClick: FunctionConstructor;
-                readonly onKeydown: FunctionConstructor;
-                readonly onFocus: FunctionConstructor;
-                readonly onBlur: FunctionConstructor;
-                readonly onContextmenu: FunctionConstructor;
+                readonly onMouseenter: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onMouseleave: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onClick: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onKeydown: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onFocus: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onBlur: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onContextmenu: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
                 readonly id: StringConstructor;
                 readonly open: BooleanConstructor;
             }>> & {
@@ -6935,13 +7690,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     __epPropKey: true;
                 };
                 readonly virtualTriggering: BooleanConstructor;
-                readonly onMouseenter: FunctionConstructor;
-                readonly onMouseleave: FunctionConstructor;
-                readonly onClick: FunctionConstructor;
-                readonly onKeydown: FunctionConstructor;
-                readonly onFocus: FunctionConstructor;
-                readonly onBlur: FunctionConstructor;
-                readonly onContextmenu: FunctionConstructor;
+                readonly onMouseenter: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onMouseleave: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onClick: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onKeydown: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onFocus: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onBlur: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onContextmenu: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
                 readonly id: StringConstructor;
                 readonly open: BooleanConstructor;
             }, {
@@ -6953,13 +7743,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                         __epPropKey: true;
                     };
                     readonly virtualTriggering: BooleanConstructor;
-                    readonly onMouseenter: FunctionConstructor;
-                    readonly onMouseleave: FunctionConstructor;
-                    readonly onClick: FunctionConstructor;
-                    readonly onKeydown: FunctionConstructor;
-                    readonly onFocus: FunctionConstructor;
-                    readonly onBlur: FunctionConstructor;
-                    readonly onContextmenu: FunctionConstructor;
+                    readonly onMouseenter: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onMouseleave: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onClick: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onKeydown: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onFocus: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onBlur: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly onContextmenu: {
+                        readonly type: import("vue").PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
                     readonly id: StringConstructor;
                     readonly open: BooleanConstructor;
                 }>> & {
@@ -6983,13 +7808,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     __epPropKey: true;
                 };
                 readonly virtualTriggering: BooleanConstructor;
-                readonly onMouseenter: FunctionConstructor;
-                readonly onMouseleave: FunctionConstructor;
-                readonly onClick: FunctionConstructor;
-                readonly onKeydown: FunctionConstructor;
-                readonly onFocus: FunctionConstructor;
-                readonly onBlur: FunctionConstructor;
-                readonly onContextmenu: FunctionConstructor;
+                readonly onMouseenter: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onMouseleave: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onClick: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onKeydown: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onFocus: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onBlur: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onContextmenu: {
+                    readonly type: import("vue").PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
                 readonly id: StringConstructor;
                 readonly open: BooleanConstructor;
             }>>, {
@@ -7007,13 +7867,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 __epPropKey: true;
             };
             readonly virtualTriggering: BooleanConstructor;
-            readonly onMouseenter: FunctionConstructor;
-            readonly onMouseleave: FunctionConstructor;
-            readonly onClick: FunctionConstructor;
-            readonly onKeydown: FunctionConstructor;
-            readonly onFocus: FunctionConstructor;
-            readonly onBlur: FunctionConstructor;
-            readonly onContextmenu: FunctionConstructor;
+            readonly onMouseenter: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onMouseleave: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onClick: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onKeydown: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onFocus: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onBlur: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onContextmenu: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
             readonly id: StringConstructor;
             readonly open: BooleanConstructor;
         }>>, {
@@ -7823,7 +8718,7 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>) | ((new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>))[], unknown, unknown, () => {}, boolean>;
                 readonly strategy: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
             }, {
-                emit: (event: string, ...args: any[]) => void;
+                emit: ((event: "focus") => void) & ((event: "close") => void) & ((event: "blur") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void);
                 props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                     readonly id: StringConstructor;
                     readonly style: {
@@ -8072,7 +8967,11 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>) | ((new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>))[], unknown, unknown, () => {}, boolean>;
                     readonly strategy: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                 }>> & {
-                    [x: string & `on${string}`]: ((...args: any[]) => any) | undefined;
+                    onClose?: (() => any) | undefined;
+                    onFocus?: (() => any) | undefined;
+                    onBlur?: (() => any) | undefined;
+                    onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                    onMouseenter?: ((evt: MouseEvent) => any) | undefined;
                 }>>;
                 popperInstanceRef: import("vue").Ref<import("@popperjs/core").Instance | undefined>;
                 contentRef: import("vue").Ref<HTMLElement | undefined>;
@@ -8099,7 +8998,7 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     cssVarBlockName: (name: string) => string;
                 };
                 popperContentRef: import("vue").Ref<HTMLElement | undefined>;
-                focusStartRef: import("vue").Ref<string | HTMLElement>;
+                focusStartRef: import("vue").Ref<HTMLElement | "first" | "container">;
                 arrowRef: import("vue").Ref<HTMLElement | undefined>;
                 arrowOffset: import("vue").Ref<number | undefined>;
                 contentZIndex: import("vue").Ref<number>;
@@ -8133,11 +9032,7 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     [x: string]: boolean;
                 } | any)[])[])[])[])[])[])[])[])[])[])[]) | undefined)[]>;
                 ariaModal: import("vue").ComputedRef<string | undefined>;
-                createPopperInstance: ({ referenceEl, popperContentEl, arrowEl }: {
-                    referenceEl: any;
-                    popperContentEl: any;
-                    arrowEl: any;
-                }) => import("@popperjs/core").Instance;
+                createPopperInstance: ({ referenceEl, popperContentEl, arrowEl, }: import("..").CreatePopperInstanceParams) => import("@popperjs/core").Instance;
                 updatePopper: (shouldUpdateZIndex?: boolean) => void;
                 togglePopperAlive: () => void;
                 onFocusAfterTrapped: () => void;
@@ -8175,7 +9070,13 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                     trapped: boolean;
                     focusStartEl: HTMLElement | "first" | "container";
                 }>;
-            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                mouseenter: (evt: MouseEvent) => boolean;
+                mouseleave: (evt: MouseEvent) => boolean;
+                focus: () => boolean;
+                blur: () => boolean;
+                close: () => boolean;
+            }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                 readonly id: StringConstructor;
                 readonly style: {
                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;
@@ -8423,7 +9324,11 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
                 readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>) | ((new (...args: any[]) => Partial<import("@popperjs/core").Options>) | (() => Partial<import("@popperjs/core").Options>))[], unknown, unknown, () => {}, boolean>;
                 readonly strategy: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
             }>> & {
-                [x: string & `on${string}`]: ((...args: any[]) => any) | undefined;
+                onClose?: (() => any) | undefined;
+                onFocus?: (() => any) | undefined;
+                onBlur?: (() => any) | undefined;
+                onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                onMouseenter?: ((evt: MouseEvent) => any) | undefined;
             }, {
                 readonly placement: import("element-plus/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
                 readonly offset: number;
@@ -8748,13 +9653,48 @@ export declare const ElColorPicker: import("element-plus/es/utils").SFCWithInsta
             __epPropKey: true;
         };
         virtualTriggering: BooleanConstructor;
-        onMouseenter: FunctionConstructor;
-        onMouseleave: FunctionConstructor;
-        onClick: FunctionConstructor;
-        onKeydown: FunctionConstructor;
-        onFocus: FunctionConstructor;
-        onBlur: FunctionConstructor;
-        onContextmenu: FunctionConstructor;
+        onMouseenter: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onMouseleave: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onClick: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onKeydown: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onFocus: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onBlur: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onContextmenu: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
         id: StringConstructor;
         open: BooleanConstructor;
         appendTo: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown, string, boolean>;