@element-plus/nightly 0.0.20220920 → 0.0.20220922

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

@@ -906,13 +906,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 __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>;
@@ -1210,13 +1245,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 __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>;
@@ -1501,13 +1571,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     __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>;
@@ -1851,13 +1956,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     __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;
             }, {
@@ -1872,13 +2012,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                         __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;
                 }>> & {
@@ -1926,13 +2101,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                         __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;
                 }, {
@@ -1944,13 +2154,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                             __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;
                     }>> & {
@@ -1974,13 +2219,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                         __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;
                 }>>, {
@@ -1998,13 +2278,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     __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;
             }>>, {
@@ -2814,7 +3129,7 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     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: {
@@ -3063,7 +3378,11 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                         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>;
@@ -3090,7 +3409,7 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                         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>;
@@ -3124,11 +3443,7 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                         [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;
@@ -3166,7 +3481,13 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                         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>>;
@@ -3414,7 +3735,11 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     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;
@@ -3791,13 +4116,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
             __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>;
@@ -4082,13 +4442,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 __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>;
@@ -4432,13 +4827,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 __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;
         }, {
@@ -4453,13 +4883,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     __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;
             }>> & {
@@ -4507,13 +4972,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     __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;
             }, {
@@ -4525,13 +5025,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                         __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;
                 }>> & {
@@ -4555,13 +5090,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     __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;
             }>>, {
@@ -4579,13 +5149,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 __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;
         }>>, {
@@ -5395,7 +6000,7 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 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: {
@@ -5644,7 +6249,11 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     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>;
@@ -5671,7 +6280,7 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     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>;
@@ -5705,11 +6314,7 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     [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;
@@ -5747,7 +6352,13 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     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>>;
@@ -5995,7 +6606,11 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 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;
@@ -7277,13 +7892,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
             __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>;
@@ -7566,13 +8216,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 __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>;
@@ -7916,13 +8601,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 __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;
         }, {
@@ -7937,13 +8657,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     __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;
             }>> & {
@@ -7991,13 +8746,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     __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;
             }, {
@@ -8009,13 +8799,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                         __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;
                 }>> & {
@@ -8039,13 +8864,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     __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;
             }>>, {
@@ -8063,13 +8923,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 __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;
         }>>, {
@@ -8879,7 +9774,7 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 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: {
@@ -9128,7 +10023,11 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     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>;
@@ -9155,7 +10054,7 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     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>;
@@ -9189,11 +10088,7 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     [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;
@@ -9231,7 +10126,13 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                     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>>;
@@ -9479,7 +10380,11 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
                 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;
@@ -9804,13 +10709,48 @@ export declare const ElAutocomplete: import("element-plus/es/utils").SFCWithInst
             __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>;