@vuetify/nightly 3.2.0-dev-20230309.0 → 3.2.0-dev-20230322.0

package/lib/components/VMenu/index.d.ts

@@ -1,5 +1,5 @@
 import * as vue from 'vue';
-import { Ref, EffectScope } from 'vue';
+import { Ref, EffectScope, ComponentPropsOptions, ExtractPropTypes } from 'vue';
 
 interface ScrollStrategyData {
     root: Ref<HTMLElement | undefined>;
@@ -46,6 +46,10 @@ type Tblock = typeof block[number];
 type Tinline = typeof inline[number];
 type Anchor = Tblock | Tinline | 'center' | 'center center' | `${Tblock} ${Tinline | 'center'}` | `${Tinline} ${Tblock | 'center'}`;
 
+interface FilterPropsOptions<PropsOptions extends Readonly<ComponentPropsOptions>, Props = ExtractPropTypes<PropsOptions>> {
+    filterProps<T extends Partial<Props>, U extends Exclude<keyof Props, Exclude<keyof Props, keyof T>>>(props: T): [yes: Partial<Pick<T, U>>, no: Omit<T, U>];
+}
+
 interface LocationStrategyData {
     contentEl: Ref<HTMLElement | undefined>;
     activatorEl: Ref<HTMLElement | undefined>;
@@ -80,27 +84,1653 @@ declare function connectedLocationStrategy(data: LocationStrategyData, props: St
     } | undefined;
 };
 
-declare const VMenu: vue.DefineComponent<{
-    location: Anchor;
-    origin: "auto" | Anchor | "overlap";
-    transition: NonNullable<string | boolean | (vue.TransitionProps & {
-        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-    })> | {
-        component: vue.DefineComponent<{} & {
-            target?: HTMLElement | undefined;
+declare const VMenu: {
+    new (...args: any[]): {
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            })> | {
+                component: {
+                    new (...args: any[]): {
+                        $: vue.ComponentInternalInstance;
+                        $data: {};
+                        $props: Partial<{}> & Omit<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                        $attrs: {
+                            [x: string]: unknown;
+                        };
+                        $refs: {
+                            [x: string]: unknown;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: vue.Slot | undefined;
+                        }>;
+                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $emit: (event: string, ...args: any[]) => void;
+                        $el: any;
+                        $options: vue.ComponentOptionsBase<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                            created?: ((() => void) | (() => void)[]) | undefined;
+                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                            mounted?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                            updated?: ((() => void) | (() => void)[]) | undefined;
+                            activated?: ((() => void) | (() => void)[]) | undefined;
+                            deactivated?: ((() => void) | (() => void)[]) | undefined;
+                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                            destroyed?: ((() => void) | (() => void)[]) | undefined;
+                            unmounted?: ((() => void) | (() => void)[]) | undefined;
+                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof vue.nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                    } & {} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & vue.ComponentOptionsBase<{} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                    target: vue.PropType<HTMLElement>;
+                }, vue.ExtractPropTypes<{
+                    target: vue.PropType<HTMLElement>;
+                }>>;
+            };
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            closeDelay: NonNullable<string | number>;
+            openDelay: NonNullable<string | number>;
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined)>;
+            scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: NonNullable<string | boolean>;
+        }> & Omit<{
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            })> | {
+                component: {
+                    new (...args: any[]): {
+                        $: vue.ComponentInternalInstance;
+                        $data: {};
+                        $props: Partial<{}> & Omit<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                        $attrs: {
+                            [x: string]: unknown;
+                        };
+                        $refs: {
+                            [x: string]: unknown;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: vue.Slot | undefined;
+                        }>;
+                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $emit: (event: string, ...args: any[]) => void;
+                        $el: any;
+                        $options: vue.ComponentOptionsBase<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                            created?: ((() => void) | (() => void)[]) | undefined;
+                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                            mounted?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                            updated?: ((() => void) | (() => void)[]) | undefined;
+                            activated?: ((() => void) | (() => void)[]) | undefined;
+                            deactivated?: ((() => void) | (() => void)[]) | undefined;
+                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                            destroyed?: ((() => void) | (() => void)[]) | undefined;
+                            unmounted?: ((() => void) | (() => void)[]) | undefined;
+                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof vue.nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                    } & {} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & vue.ComponentOptionsBase<{} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                    target: vue.PropType<HTMLElement>;
+                }, vue.ExtractPropTypes<{
+                    target: vue.PropType<HTMLElement>;
+                }>>;
+            };
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            closeDelay: NonNullable<string | number>;
+            openDelay: NonNullable<string | number>;
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined)>;
+            scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: NonNullable<string | boolean>;
         } & {
-            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
-                default?: (() => vue.VNodeChild) | undefined;
+            offset?: string | number | number[] | undefined;
+            id?: string | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            theme?: string | undefined;
+            contentClass?: any;
+            activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } & {
+            $children?: {} | vue.VNodeChild | {
+                default?: ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
             };
             $slots?: {
-                default?: (() => vue.VNodeChild) | undefined;
+                default?: ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
             } | undefined;
             'v-slots'?: {
-                default?: false | (() => vue.VNodeChild) | undefined;
+                default?: false | ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
             } | undefined;
         } & {
-            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
+            "v-slot:default"?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: vue.Slot | undefined;
+        }>;
+        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $emit: (event: "update:modelValue", value: boolean) => void;
+        $el: any;
+        $options: vue.ComponentOptionsBase<{
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            })> | {
+                component: {
+                    new (...args: any[]): {
+                        $: vue.ComponentInternalInstance;
+                        $data: {};
+                        $props: Partial<{}> & Omit<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                        $attrs: {
+                            [x: string]: unknown;
+                        };
+                        $refs: {
+                            [x: string]: unknown;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: vue.Slot | undefined;
+                        }>;
+                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $emit: (event: string, ...args: any[]) => void;
+                        $el: any;
+                        $options: vue.ComponentOptionsBase<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                            created?: ((() => void) | (() => void)[]) | undefined;
+                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                            mounted?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                            updated?: ((() => void) | (() => void)[]) | undefined;
+                            activated?: ((() => void) | (() => void)[]) | undefined;
+                            deactivated?: ((() => void) | (() => void)[]) | undefined;
+                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                            destroyed?: ((() => void) | (() => void)[]) | undefined;
+                            unmounted?: ((() => void) | (() => void)[]) | undefined;
+                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof vue.nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                    } & {} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & vue.ComponentOptionsBase<{} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                    target: vue.PropType<HTMLElement>;
+                }, vue.ExtractPropTypes<{
+                    target: vue.PropType<HTMLElement>;
+                }>>;
+            };
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            closeDelay: NonNullable<string | number>;
+            openDelay: NonNullable<string | number>;
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined)>;
+            scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: NonNullable<string | boolean>;
+        } & {
+            offset?: string | number | number[] | undefined;
+            id?: string | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            theme?: string | undefined;
+            contentClass?: any;
+            activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } & {
+            $children?: {} | vue.VNodeChild | {
+                default?: ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            };
+            $slots?: {
+                default?: ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+            'v-slots'?: {
+                default?: false | ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        }, {
+            id: vue.ComputedRef<string>;
+            ΨopenChildren: vue.Ref<number>;
+        } & Omit<Omit<{
+            $: vue.ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                absolute: boolean;
+                location: Anchor;
+                origin: "auto" | Anchor | "overlap";
+                transition: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                });
+                zIndex: string | number;
+                eager: boolean;
+                disabled: boolean;
+                modelValue: boolean;
+                activatorProps: Record<string, any>;
+                openOnClick: boolean;
+                openOnHover: boolean;
+                openOnFocus: boolean;
+                closeOnContentClick: boolean;
+                locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined);
+                scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+                closeOnBack: boolean;
+                contained: boolean;
+                noClickAnimation: boolean;
+                persistent: boolean;
+                scrim: string | boolean;
+                _disableGlobalStack: boolean;
+            }> & Omit<{
+                absolute: boolean;
+                location: Anchor;
+                origin: "auto" | Anchor | "overlap";
+                transition: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                });
+                zIndex: string | number;
+                eager: boolean;
+                disabled: boolean;
+                modelValue: boolean;
+                activatorProps: Record<string, any>;
+                openOnHover: boolean;
+                closeOnContentClick: boolean;
+                locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined);
+                scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+                closeOnBack: boolean;
+                contained: boolean;
+                noClickAnimation: boolean;
+                persistent: boolean;
+                scrim: string | boolean;
+                _disableGlobalStack: boolean;
+            } & {
+                offset?: string | number | number[] | undefined;
+                height?: string | number | undefined;
+                width?: string | number | undefined;
+                maxHeight?: string | number | undefined;
+                maxWidth?: string | number | undefined;
+                minHeight?: string | number | undefined;
+                minWidth?: string | number | undefined;
+                theme?: string | undefined;
+                contentClass?: any;
+                activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+                closeDelay?: string | number | undefined;
+                openDelay?: string | number | undefined;
+                openOnClick?: boolean | undefined;
+                openOnFocus?: boolean | undefined;
+                contentProps?: any;
+                attach?: string | boolean | Element | undefined;
+            } & {
+                $children?: {} | vue.VNodeChild | {
+                    default?: ((args_0: {
+                        isActive: vue.Ref<boolean>;
+                    }) => vue.VNodeChild) | undefined;
+                    activator?: ((args_0: {
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }) => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: ((args_0: {
+                        isActive: vue.Ref<boolean>;
+                    }) => vue.VNodeChild) | undefined;
+                    activator?: ((args_0: {
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }) => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | ((args_0: {
+                        isActive: vue.Ref<boolean>;
+                    }) => vue.VNodeChild) | undefined;
+                    activator?: false | ((args_0: {
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }) => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                "v-slot:activator"?: false | ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } & {
+                onAfterLeave?: (() => any) | undefined;
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: vue.Slot | undefined;
+            }>;
+            $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+            $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+            $emit: ((event: "update:modelValue", value: boolean) => void) & ((event: "click:outside", e: MouseEvent) => void) & ((event: "afterLeave") => void);
+            $el: any;
+            $options: vue.ComponentOptionsBase<{
+                absolute: boolean;
+                location: Anchor;
+                origin: "auto" | Anchor | "overlap";
+                transition: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                });
+                zIndex: string | number;
+                eager: boolean;
+                disabled: boolean;
+                modelValue: boolean;
+                activatorProps: Record<string, any>;
+                openOnHover: boolean;
+                closeOnContentClick: boolean;
+                locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined);
+                scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+                closeOnBack: boolean;
+                contained: boolean;
+                noClickAnimation: boolean;
+                persistent: boolean;
+                scrim: string | boolean;
+                _disableGlobalStack: boolean;
+            } & {
+                offset?: string | number | number[] | undefined;
+                height?: string | number | undefined;
+                width?: string | number | undefined;
+                maxHeight?: string | number | undefined;
+                maxWidth?: string | number | undefined;
+                minHeight?: string | number | undefined;
+                minWidth?: string | number | undefined;
+                theme?: string | undefined;
+                contentClass?: any;
+                activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+                closeDelay?: string | number | undefined;
+                openDelay?: string | number | undefined;
+                openOnClick?: boolean | undefined;
+                openOnFocus?: boolean | undefined;
+                contentProps?: any;
+                attach?: string | boolean | Element | undefined;
+            } & {
+                $children?: {} | vue.VNodeChild | {
+                    default?: ((args_0: {
+                        isActive: vue.Ref<boolean>;
+                    }) => vue.VNodeChild) | undefined;
+                    activator?: ((args_0: {
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }) => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: ((args_0: {
+                        isActive: vue.Ref<boolean>;
+                    }) => vue.VNodeChild) | undefined;
+                    activator?: ((args_0: {
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }) => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | ((args_0: {
+                        isActive: vue.Ref<boolean>;
+                    }) => vue.VNodeChild) | undefined;
+                    activator?: false | ((args_0: {
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }) => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                "v-slot:activator"?: false | ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } & {
+                onAfterLeave?: (() => any) | undefined;
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+            }, {
+                activatorEl: vue.Ref<HTMLElement | undefined>;
+                animateClick: () => void;
+                contentEl: vue.Ref<HTMLElement | undefined>;
+                globalTop: Readonly<vue.Ref<boolean>>;
+                localTop: vue.ComputedRef<boolean>;
+                updateLocation: vue.Ref<((e: Event) => void) | undefined>;
+            }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+                'click:outside': (e: MouseEvent) => true;
+                'update:modelValue': (value: boolean) => true;
+                afterLeave: () => true;
+            }, string, {
+                absolute: boolean;
+                location: Anchor;
+                origin: "auto" | Anchor | "overlap";
+                transition: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                });
+                zIndex: string | number;
+                eager: boolean;
+                disabled: boolean;
+                modelValue: boolean;
+                activatorProps: Record<string, any>;
+                openOnClick: boolean;
+                openOnHover: boolean;
+                openOnFocus: boolean;
+                closeOnContentClick: boolean;
+                locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined);
+                scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+                closeOnBack: boolean;
+                contained: boolean;
+                noClickAnimation: boolean;
+                persistent: boolean;
+                scrim: string | boolean;
+                _disableGlobalStack: boolean;
+            }, {}, string> & {
+                beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                created?: ((() => void) | (() => void)[]) | undefined;
+                beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                mounted?: ((() => void) | (() => void)[]) | undefined;
+                beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                updated?: ((() => void) | (() => void)[]) | undefined;
+                activated?: ((() => void) | (() => void)[]) | undefined;
+                deactivated?: ((() => void) | (() => void)[]) | undefined;
+                beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                destroyed?: ((() => void) | (() => void)[]) | undefined;
+                unmounted?: ((() => void) | (() => void)[]) | undefined;
+                renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof vue.nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+        } & {
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            offset?: string | number | number[] | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            theme?: string | undefined;
+            contentClass?: any;
+            activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+            closeDelay?: string | number | undefined;
+            openDelay?: string | number | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } & {
+            $children?: {} | vue.VNodeChild | {
+                default?: ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            };
+            $slots?: {
+                default?: ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+            'v-slots'?: {
+                default?: false | ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            onAfterLeave?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        } & vue.ShallowUnwrapRef<{
+            activatorEl: vue.Ref<HTMLElement | undefined>;
+            animateClick: () => void;
+            contentEl: vue.Ref<HTMLElement | undefined>;
+            globalTop: Readonly<vue.Ref<boolean>>;
+            localTop: vue.ComputedRef<boolean>;
+            updateLocation: vue.Ref<((e: Event) => void) | undefined>;
+        }> & {} & vue.ComponentCustomProperties & {}, "offset" | "height" | "width" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "onAfterLeave" | "$children" | "theme" | "v-slot:default" | "$slots" | "v-slots" | "contentClass" | keyof vue.VNodeProps | keyof vue.AllowedComponentProps | "onUpdate:modelValue" | "activator" | "v-slot:activator" | "closeDelay" | "openDelay" | "contentProps" | "attach" | "onClick:outside" | ("absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack")>, `$${any}`>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+            'update:modelValue': (value: boolean) => boolean;
+        }, string, {
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            })> | {
+                component: {
+                    new (...args: any[]): {
+                        $: vue.ComponentInternalInstance;
+                        $data: {};
+                        $props: Partial<{}> & Omit<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                        $attrs: {
+                            [x: string]: unknown;
+                        };
+                        $refs: {
+                            [x: string]: unknown;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: vue.Slot | undefined;
+                        }>;
+                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $emit: (event: string, ...args: any[]) => void;
+                        $el: any;
+                        $options: vue.ComponentOptionsBase<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                            created?: ((() => void) | (() => void)[]) | undefined;
+                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                            mounted?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                            updated?: ((() => void) | (() => void)[]) | undefined;
+                            activated?: ((() => void) | (() => void)[]) | undefined;
+                            deactivated?: ((() => void) | (() => void)[]) | undefined;
+                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                            destroyed?: ((() => void) | (() => void)[]) | undefined;
+                            unmounted?: ((() => void) | (() => void)[]) | undefined;
+                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof vue.nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                    } & {} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & vue.ComponentOptionsBase<{} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                    target: vue.PropType<HTMLElement>;
+                }, vue.ExtractPropTypes<{
+                    target: vue.PropType<HTMLElement>;
+                }>>;
+            };
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            closeDelay: NonNullable<string | number>;
+            openDelay: NonNullable<string | number>;
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined)>;
+            scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: NonNullable<string | boolean>;
+        }, {}, string> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof vue.nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+    } & {
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })> | {
+            component: {
+                new (...args: any[]): {
+                    $: vue.ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{}> & Omit<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: vue.Slot | undefined;
+                    }>;
+                    $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: vue.ComponentOptionsBase<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                        beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                        created?: ((() => void) | (() => void)[]) | undefined;
+                        beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                        mounted?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                        updated?: ((() => void) | (() => void)[]) | undefined;
+                        activated?: ((() => void) | (() => void)[]) | undefined;
+                        deactivated?: ((() => void) | (() => void)[]) | undefined;
+                        beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                        destroyed?: ((() => void) | (() => void)[]) | undefined;
+                        unmounted?: ((() => void) | (() => void)[]) | undefined;
+                        renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof vue.nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                } & {} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & vue.ComponentOptionsBase<{} & {
+                target?: HTMLElement | undefined;
+            } & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                target: vue.PropType<HTMLElement>;
+            }, vue.ExtractPropTypes<{
+                target: vue.PropType<HTMLElement>;
+            }>>;
+        };
+        zIndex: string | number;
+        eager: boolean;
+        disabled: boolean;
+        modelValue: boolean;
+        closeDelay: NonNullable<string | number>;
+        openDelay: NonNullable<string | number>;
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined)>;
+        scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        persistent: boolean;
+        scrim: NonNullable<string | boolean>;
+    } & {
+        offset?: string | number | number[] | undefined;
+        id?: string | undefined;
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        theme?: string | undefined;
+        contentClass?: any;
+        activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+    } & {
+        $children?: {} | vue.VNodeChild | {
+            default?: ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        };
+        $slots?: {
+            default?: ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+        'v-slots'?: {
+            default?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((args_0: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((args_0: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    } & vue.ShallowUnwrapRef<{
+        id: vue.ComputedRef<string>;
+        ΨopenChildren: vue.Ref<number>;
+    } & Omit<Omit<{
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }> & Omit<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            offset?: string | number | number[] | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            theme?: string | undefined;
+            contentClass?: any;
+            activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+            closeDelay?: string | number | undefined;
+            openDelay?: string | number | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } & {
+            $children?: {} | vue.VNodeChild | {
+                default?: ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            };
+            $slots?: {
+                default?: ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+            'v-slots'?: {
+                default?: false | ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            onAfterLeave?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: vue.Slot | undefined;
+        }>;
+        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $emit: ((event: "update:modelValue", value: boolean) => void) & ((event: "click:outside", e: MouseEvent) => void) & ((event: "afterLeave") => void);
+        $el: any;
+        $options: vue.ComponentOptionsBase<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            offset?: string | number | number[] | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            theme?: string | undefined;
+            contentClass?: any;
+            activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+            closeDelay?: string | number | undefined;
+            openDelay?: string | number | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } & {
+            $children?: {} | vue.VNodeChild | {
+                default?: ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            };
+            $slots?: {
+                default?: ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+            'v-slots'?: {
+                default?: false | ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            onAfterLeave?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        }, {
+            activatorEl: vue.Ref<HTMLElement | undefined>;
+            animateClick: () => void;
+            contentEl: vue.Ref<HTMLElement | undefined>;
+            globalTop: Readonly<vue.Ref<boolean>>;
+            localTop: vue.ComputedRef<boolean>;
+            updateLocation: vue.Ref<((e: Event) => void) | undefined>;
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+            'click:outside': (e: MouseEvent) => true;
+            'update:modelValue': (value: boolean) => true;
+            afterLeave: () => true;
+        }, string, {
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }, {}, string> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof vue.nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+    } & {
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        });
+        zIndex: string | number;
+        eager: boolean;
+        disabled: boolean;
+        modelValue: boolean;
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined);
+        scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        persistent: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    } & {
+        offset?: string | number | number[] | undefined;
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        theme?: string | undefined;
+        contentClass?: any;
+        activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+    } & {
+        $children?: {} | vue.VNodeChild | {
+            default?: ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        };
+        $slots?: {
+            default?: ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+        'v-slots'?: {
+            default?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((args_0: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((args_0: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        onAfterLeave?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    } & vue.ShallowUnwrapRef<{
+        activatorEl: vue.Ref<HTMLElement | undefined>;
+        animateClick: () => void;
+        contentEl: vue.Ref<HTMLElement | undefined>;
+        globalTop: Readonly<vue.Ref<boolean>>;
+        localTop: vue.ComputedRef<boolean>;
+        updateLocation: vue.Ref<((e: Event) => void) | undefined>;
+    }> & {} & vue.ComponentCustomProperties & {}, "offset" | "height" | "width" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "onAfterLeave" | "$children" | "theme" | "v-slot:default" | "$slots" | "v-slots" | "contentClass" | keyof vue.VNodeProps | keyof vue.AllowedComponentProps | "onUpdate:modelValue" | "activator" | "v-slot:activator" | "closeDelay" | "openDelay" | "contentProps" | "attach" | "onClick:outside" | ("absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack")>, `$${any}`>> & {} & vue.ComponentCustomProperties & {};
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    location: Anchor;
+    origin: "auto" | Anchor | "overlap";
+    transition: NonNullable<string | boolean | (vue.TransitionProps & {
+        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+    })> | {
+        component: {
+            new (...args: any[]): {
+                $: vue.ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{}> & Omit<{} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: vue.Slot | undefined;
+                }>;
+                $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: vue.ComponentOptionsBase<{} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                    created?: ((() => void) | (() => void)[]) | undefined;
+                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                    mounted?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                    updated?: ((() => void) | (() => void)[]) | undefined;
+                    activated?: ((() => void) | (() => void)[]) | undefined;
+                    deactivated?: ((() => void) | (() => void)[]) | undefined;
+                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                    destroyed?: ((() => void) | (() => void)[]) | undefined;
+                    unmounted?: ((() => void) | (() => void)[]) | undefined;
+                    renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                    renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                    errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof vue.nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+            } & {} & {
+                target?: HTMLElement | undefined;
+            } & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } & vue.ComponentOptionsBase<{} & {
             target?: HTMLElement | undefined;
         } & {
             $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
@@ -114,7 +1744,11 @@ declare const VMenu: vue.DefineComponent<{
             } | undefined;
         } & {
             "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-        }, {}>;
+        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+            target: vue.PropType<HTMLElement>;
+        }, vue.ExtractPropTypes<{
+            target: vue.PropType<HTMLElement>;
+        }>>;
     };
     zIndex: string | number;
     eager: boolean;
@@ -186,6 +1820,8 @@ declare const VMenu: vue.DefineComponent<{
         isActive: boolean;
         props: Record<string, any>;
     }) => vue.VNodeChild) | undefined;
+} & {
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
 }, {
     id: vue.ComputedRef<string>;
     ΨopenChildren: vue.Ref<number>;
@@ -541,27 +2177,97 @@ declare const VMenu: vue.DefineComponent<{
     updateLocation: vue.Ref<((e: Event) => void) | undefined>;
 }> & {} & vue.ComponentCustomProperties & {}, "offset" | "height" | "width" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "onAfterLeave" | "$children" | "theme" | "v-slot:default" | "$slots" | "v-slots" | "contentClass" | keyof vue.VNodeProps | keyof vue.AllowedComponentProps | "onUpdate:modelValue" | "activator" | "v-slot:activator" | "closeDelay" | "openDelay" | "contentProps" | "attach" | "onClick:outside" | ("absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack")>, `$${any}`>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     'update:modelValue': (value: boolean) => boolean;
-}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
+}, string, {
     location: Anchor;
     origin: "auto" | Anchor | "overlap";
     transition: NonNullable<string | boolean | (vue.TransitionProps & {
         component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
     })> | {
-        component: vue.DefineComponent<{} & {
-            target?: HTMLElement | undefined;
-        } & {
-            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
-                default?: (() => vue.VNodeChild) | undefined;
-            };
-            $slots?: {
-                default?: (() => vue.VNodeChild) | undefined;
-            } | undefined;
-            'v-slots'?: {
-                default?: false | (() => vue.VNodeChild) | undefined;
-            } | undefined;
-        } & {
-            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
+        component: {
+            new (...args: any[]): {
+                $: vue.ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{}> & Omit<{} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: vue.Slot | undefined;
+                }>;
+                $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: vue.ComponentOptionsBase<{} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                    created?: ((() => void) | (() => void)[]) | undefined;
+                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                    mounted?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                    updated?: ((() => void) | (() => void)[]) | undefined;
+                    activated?: ((() => void) | (() => void)[]) | undefined;
+                    deactivated?: ((() => void) | (() => void)[]) | undefined;
+                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                    destroyed?: ((() => void) | (() => void)[]) | undefined;
+                    unmounted?: ((() => void) | (() => void)[]) | undefined;
+                    renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                    renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                    errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof vue.nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+            } & {} & {
+                target?: HTMLElement | undefined;
+            } & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } & vue.ComponentOptionsBase<{} & {
             target?: HTMLElement | undefined;
         } & {
             $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
@@ -575,115 +2281,11 @@ declare const VMenu: vue.DefineComponent<{
             } | undefined;
         } & {
             "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-        }, {}>;
-    };
-    zIndex: string | number;
-    eager: boolean;
-    disabled: boolean;
-    modelValue: boolean;
-    closeDelay: NonNullable<string | number>;
-    openDelay: NonNullable<string | number>;
-    activatorProps: Record<string, any>;
-    openOnHover: boolean;
-    closeOnContentClick: boolean;
-    locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-        updateLocation: (e: Event) => void;
-    } | undefined)>;
-    scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-    closeOnBack: boolean;
-    contained: boolean;
-    noClickAnimation: boolean;
-    persistent: boolean;
-    scrim: NonNullable<string | boolean>;
-} & {
-    offset?: string | number | number[] | undefined;
-    id?: string | undefined;
-    height?: string | number | undefined;
-    width?: string | number | undefined;
-    maxHeight?: string | number | undefined;
-    maxWidth?: string | number | undefined;
-    minHeight?: string | number | undefined;
-    minWidth?: string | number | undefined;
-    theme?: string | undefined;
-    contentClass?: any;
-    activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
-    openOnClick?: boolean | undefined;
-    openOnFocus?: boolean | undefined;
-    contentProps?: any;
-    attach?: string | boolean | Element | undefined;
-} & {
-    $children?: {} | vue.VNodeChild | {
-        default?: ((args_0: {
-            isActive: vue.Ref<boolean>;
-        }) => vue.VNodeChild) | undefined;
-        activator?: ((args_0: {
-            isActive: boolean;
-            props: Record<string, any>;
-        }) => vue.VNodeChild) | undefined;
-    };
-    $slots?: {
-        default?: ((args_0: {
-            isActive: vue.Ref<boolean>;
-        }) => vue.VNodeChild) | undefined;
-        activator?: ((args_0: {
-            isActive: boolean;
-            props: Record<string, any>;
-        }) => vue.VNodeChild) | undefined;
-    } | undefined;
-    'v-slots'?: {
-        default?: false | ((args_0: {
-            isActive: vue.Ref<boolean>;
-        }) => vue.VNodeChild) | undefined;
-        activator?: false | ((args_0: {
-            isActive: boolean;
-            props: Record<string, any>;
-        }) => vue.VNodeChild) | undefined;
-    } | undefined;
-} & {
-    "v-slot:default"?: false | ((args_0: {
-        isActive: vue.Ref<boolean>;
-    }) => vue.VNodeChild) | undefined;
-    "v-slot:activator"?: false | ((args_0: {
-        isActive: boolean;
-        props: Record<string, any>;
-    }) => vue.VNodeChild) | undefined;
-} & {
-    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-}, {
-    location: Anchor;
-    origin: "auto" | Anchor | "overlap";
-    transition: NonNullable<string | boolean | (vue.TransitionProps & {
-        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-    })> | {
-        component: vue.DefineComponent<{} & {
-            target?: HTMLElement | undefined;
-        } & {
-            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
-                default?: (() => vue.VNodeChild) | undefined;
-            };
-            $slots?: {
-                default?: (() => vue.VNodeChild) | undefined;
-            } | undefined;
-            'v-slots'?: {
-                default?: false | (() => vue.VNodeChild) | undefined;
-            } | undefined;
-        } & {
-            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
-            target?: HTMLElement | undefined;
-        } & {
-            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
-                default?: (() => vue.VNodeChild) | undefined;
-            };
-            $slots?: {
-                default?: (() => vue.VNodeChild) | undefined;
-            } | undefined;
-            'v-slots'?: {
-                default?: false | (() => vue.VNodeChild) | undefined;
-            } | undefined;
-        } & {
-            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-        }, {}>;
+        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+            target: vue.PropType<HTMLElement>;
+        }, vue.ExtractPropTypes<{
+            target: vue.PropType<HTMLElement>;
+        }>>;
     };
     zIndex: string | number;
     eager: boolean;
@@ -705,7 +2307,631 @@ declare const VMenu: vue.DefineComponent<{
     noClickAnimation: boolean;
     persistent: boolean;
     scrim: NonNullable<string | boolean>;
-}>;
+}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    offset: vue.PropType<string | number | number[] | undefined>;
+    location: {
+        type: vue.PropType<Anchor>;
+        default: string;
+    };
+    origin: {
+        type: vue.PropType<"auto" | Anchor | "overlap">;
+        default: string;
+    };
+    height: (StringConstructor | NumberConstructor)[];
+    width: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    transition: Omit<{
+        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })> | {
+            component: {
+                new (...args: any[]): {
+                    $: vue.ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{}> & Omit<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: vue.Slot | undefined;
+                    }>;
+                    $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: vue.ComponentOptionsBase<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                        beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                        created?: ((() => void) | (() => void)[]) | undefined;
+                        beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                        mounted?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                        updated?: ((() => void) | (() => void)[]) | undefined;
+                        activated?: ((() => void) | (() => void)[]) | undefined;
+                        deactivated?: ((() => void) | (() => void)[]) | undefined;
+                        beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                        destroyed?: ((() => void) | (() => void)[]) | undefined;
+                        unmounted?: ((() => void) | (() => void)[]) | undefined;
+                        renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof vue.nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                } & {} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & vue.ComponentOptionsBase<{} & {
+                target?: HTMLElement | undefined;
+            } & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                target: vue.PropType<HTMLElement>;
+            }, vue.ExtractPropTypes<{
+                target: vue.PropType<HTMLElement>;
+            }>>;
+        }>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })> | {
+            component: {
+                new (...args: any[]): {
+                    $: vue.ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{}> & Omit<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: vue.Slot | undefined;
+                    }>;
+                    $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: vue.ComponentOptionsBase<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                        beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                        created?: ((() => void) | (() => void)[]) | undefined;
+                        beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                        mounted?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                        updated?: ((() => void) | (() => void)[]) | undefined;
+                        activated?: ((() => void) | (() => void)[]) | undefined;
+                        deactivated?: ((() => void) | (() => void)[]) | undefined;
+                        beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                        destroyed?: ((() => void) | (() => void)[]) | undefined;
+                        unmounted?: ((() => void) | (() => void)[]) | undefined;
+                        renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof vue.nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                } & {} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & vue.ComponentOptionsBase<{} & {
+                target?: HTMLElement | undefined;
+            } & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                target: vue.PropType<HTMLElement>;
+            }, vue.ExtractPropTypes<{
+                target: vue.PropType<HTMLElement>;
+            }>>;
+        };
+    };
+    zIndex: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    eager: BooleanConstructor;
+    disabled: BooleanConstructor;
+    theme: StringConstructor;
+    contentClass: null;
+    modelValue: BooleanConstructor;
+    activator: vue.PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined>;
+    closeDelay: {
+        type: vue.PropType<NonNullable<string | number>>;
+        default: NonNullable<string | number>;
+    };
+    openDelay: {
+        type: vue.PropType<NonNullable<string | number>>;
+        default: NonNullable<string | number>;
+    };
+    activatorProps: {
+        type: vue.PropType<Record<string, any>>;
+        default: () => {};
+    };
+    openOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openOnHover: BooleanConstructor;
+    openOnFocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    closeOnContentClick: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    locationStrategy: Omit<{
+        type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined)>;
+        default: string;
+        validator: (val: any) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined)>>;
+        default: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined)>;
+    };
+    scrollStrategy: Omit<{
+        type: vue.PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        default: string;
+        validator: (val: any) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">>;
+        default: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+    };
+    closeOnBack: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contained: BooleanConstructor;
+    contentProps: null;
+    noClickAnimation: BooleanConstructor;
+    persistent: BooleanConstructor;
+    scrim: Omit<{
+        type: (StringConstructor | BooleanConstructor)[];
+        default: boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<string | boolean>>;
+        default: NonNullable<string | boolean>;
+    };
+    attach: vue.PropType<string | boolean | Element>;
+    id: StringConstructor;
+}, vue.ExtractPropTypes<{
+    offset: vue.PropType<string | number | number[] | undefined>;
+    location: {
+        type: vue.PropType<Anchor>;
+        default: string;
+    };
+    origin: {
+        type: vue.PropType<"auto" | Anchor | "overlap">;
+        default: string;
+    };
+    height: (StringConstructor | NumberConstructor)[];
+    width: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    transition: Omit<{
+        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })> | {
+            component: {
+                new (...args: any[]): {
+                    $: vue.ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{}> & Omit<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: vue.Slot | undefined;
+                    }>;
+                    $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: vue.ComponentOptionsBase<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                        beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                        created?: ((() => void) | (() => void)[]) | undefined;
+                        beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                        mounted?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                        updated?: ((() => void) | (() => void)[]) | undefined;
+                        activated?: ((() => void) | (() => void)[]) | undefined;
+                        deactivated?: ((() => void) | (() => void)[]) | undefined;
+                        beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                        destroyed?: ((() => void) | (() => void)[]) | undefined;
+                        unmounted?: ((() => void) | (() => void)[]) | undefined;
+                        renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof vue.nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                } & {} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & vue.ComponentOptionsBase<{} & {
+                target?: HTMLElement | undefined;
+            } & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                target: vue.PropType<HTMLElement>;
+            }, vue.ExtractPropTypes<{
+                target: vue.PropType<HTMLElement>;
+            }>>;
+        }>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })> | {
+            component: {
+                new (...args: any[]): {
+                    $: vue.ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{}> & Omit<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: vue.Slot | undefined;
+                    }>;
+                    $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: vue.ComponentOptionsBase<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & {
+                        beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                        created?: ((() => void) | (() => void)[]) | undefined;
+                        beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                        mounted?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                        updated?: ((() => void) | (() => void)[]) | undefined;
+                        activated?: ((() => void) | (() => void)[]) | undefined;
+                        deactivated?: ((() => void) | (() => void)[]) | undefined;
+                        beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                        destroyed?: ((() => void) | (() => void)[]) | undefined;
+                        unmounted?: ((() => void) | (() => void)[]) | undefined;
+                        renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof vue.nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                } & {} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & vue.ComponentOptionsBase<{} & {
+                target?: HTMLElement | undefined;
+            } & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                target: vue.PropType<HTMLElement>;
+            }, vue.ExtractPropTypes<{
+                target: vue.PropType<HTMLElement>;
+            }>>;
+        };
+    };
+    zIndex: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    eager: BooleanConstructor;
+    disabled: BooleanConstructor;
+    theme: StringConstructor;
+    contentClass: null;
+    modelValue: BooleanConstructor;
+    activator: vue.PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined>;
+    closeDelay: {
+        type: vue.PropType<NonNullable<string | number>>;
+        default: NonNullable<string | number>;
+    };
+    openDelay: {
+        type: vue.PropType<NonNullable<string | number>>;
+        default: NonNullable<string | number>;
+    };
+    activatorProps: {
+        type: vue.PropType<Record<string, any>>;
+        default: () => {};
+    };
+    openOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openOnHover: BooleanConstructor;
+    openOnFocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    closeOnContentClick: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    locationStrategy: Omit<{
+        type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined)>;
+        default: string;
+        validator: (val: any) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined)>>;
+        default: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined)>;
+    };
+    scrollStrategy: Omit<{
+        type: vue.PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        default: string;
+        validator: (val: any) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">>;
+        default: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+    };
+    closeOnBack: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contained: BooleanConstructor;
+    contentProps: null;
+    noClickAnimation: BooleanConstructor;
+    persistent: BooleanConstructor;
+    scrim: Omit<{
+        type: (StringConstructor | BooleanConstructor)[];
+        default: boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<string | boolean>>;
+        default: NonNullable<string | boolean>;
+    };
+    attach: vue.PropType<string | boolean | Element>;
+    id: StringConstructor;
+}>>;
 type VMenu = InstanceType<typeof VMenu>;
 
 export { VMenu };