@element-plus/nightly 0.0.20220921 → 0.0.20220923

package/es/components/popover/index.d.ts

@@ -375,13 +375,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 __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>;
@@ -679,13 +714,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 __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>;
@@ -970,13 +1040,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     __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>;
@@ -1320,13 +1425,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     __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;
             }, {
@@ -1341,13 +1481,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                         __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;
                 }>> & {
@@ -1395,13 +1570,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                         __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;
                 }, {
@@ -1413,13 +1623,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                             __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;
                     }>> & {
@@ -1443,13 +1688,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                         __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;
                 }>>, {
@@ -1467,13 +1747,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     __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;
             }>>, {
@@ -2283,7 +2598,7 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     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: {
@@ -2532,7 +2847,11 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                         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>;
@@ -2559,7 +2878,7 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                         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>;
@@ -2593,11 +2912,7 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                         [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;
@@ -2635,7 +2950,13 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                         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>>;
@@ -2883,7 +3204,11 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     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;
@@ -3260,13 +3585,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
             __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>;
@@ -3551,13 +3911,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 __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>;
@@ -3901,13 +4296,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 __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;
         }, {
@@ -3922,13 +4352,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     __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;
             }>> & {
@@ -3976,13 +4441,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     __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;
             }, {
@@ -3994,13 +4494,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                         __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;
                 }>> & {
@@ -4024,13 +4559,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     __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;
             }>>, {
@@ -4047,14 +4617,49 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 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;
         }>>, {
@@ -4864,7 +5469,7 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 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: {
@@ -5113,7 +5718,11 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     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>;
@@ -5140,7 +5749,7 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     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>;
@@ -5174,11 +5783,7 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     [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;
@@ -5216,7 +5821,13 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     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>>;
@@ -5464,7 +6075,11 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 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;
@@ -5823,13 +6438,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
             __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>;
@@ -6112,13 +6762,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 __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>;
@@ -6462,13 +7147,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 __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;
         }, {
@@ -6483,13 +7203,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     __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;
             }>> & {
@@ -6537,13 +7292,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     __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;
             }, {
@@ -6555,13 +7345,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                         __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;
                 }>> & {
@@ -6585,13 +7410,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     __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;
             }>>, {
@@ -6609,13 +7469,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 __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;
         }>>, {
@@ -7425,7 +8320,7 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 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: {
@@ -7674,7 +8569,11 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     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>;
@@ -7701,7 +8600,7 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     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>;
@@ -7735,11 +8634,7 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     [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;
@@ -7777,7 +8672,13 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                     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>>;
@@ -8025,7 +8926,11 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
                 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;
@@ -8350,13 +9255,48 @@ export declare const ElPopover: import("element-plus/es/utils").SFCWithInstall<i
             __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>;