vuetify 3.5.16 → 3.5.18

package/lib/labs/components.d.mts

@@ -1,5 +1,5 @@
 import * as vue from 'vue';
-import { ComponentPropsOptions, ExtractPropTypes, VNodeChild, VNode, PropType, Ref, JSXComponent, ComponentInternalInstance, ComputedRef, EffectScope } from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, VNodeChild, VNode, PropType, Ref, JSXComponent, ComponentInternalInstance, ComputedRef, EffectScope, nextTick } from 'vue';
 // @ts-ignore
 import * as vue_router from 'vue-router';
 
@@ -2317,6 +2317,7 @@ interface GroupItem {
     id: number;
     value: Ref<unknown>;
     disabled: Ref<boolean | undefined>;
+    useIndexAsValue?: boolean;
 }
 interface GroupProvide {
     register: (item: GroupItem, cmp: ComponentInternalInstance) => void;
@@ -2346,6 +2347,7 @@ declare const VFab: {
         active: boolean;
         disabled: boolean;
         tag: string;
+        layout: boolean;
         offset: boolean;
         order: string | number;
         absolute: boolean;
@@ -2413,6 +2415,7 @@ declare const VFab: {
         active: boolean;
         disabled: boolean;
         tag: string;
+        layout: boolean;
         offset: boolean;
         order: string | number;
         absolute: boolean;
@@ -2478,6 +2481,7 @@ declare const VFab: {
         active: boolean;
         disabled: boolean;
         tag: string;
+        layout: boolean;
         offset: boolean;
         order: string | number;
         absolute: boolean;
@@ -2520,6 +2524,7 @@ declare const VFab: {
         active: boolean;
         disabled: boolean;
         tag: string;
+        layout: boolean;
         offset: boolean;
         order: string | number;
         absolute: boolean;
@@ -2585,6 +2590,7 @@ declare const VFab: {
         active: boolean;
         disabled: boolean;
         tag: string;
+        layout: boolean;
         offset: boolean;
         order: string | number;
         absolute: boolean;
@@ -2620,6 +2626,7 @@ declare const VFab: {
     active: boolean;
     disabled: boolean;
     tag: string;
+    layout: boolean;
     offset: boolean;
     order: string | number;
     absolute: boolean;
@@ -2687,6 +2694,7 @@ declare const VFab: {
     active: boolean;
     disabled: boolean;
     tag: string;
+    layout: boolean;
     offset: boolean;
     order: string | number;
     absolute: boolean;
@@ -2823,6 +2831,7 @@ declare const VFab: {
     app: BooleanConstructor;
     appear: BooleanConstructor;
     extended: BooleanConstructor;
+    layout: BooleanConstructor;
     location: {
         type: PropType<"left" | "right" | "end" | "top" | "bottom" | "start">;
         default: string;
@@ -2942,6 +2951,7 @@ declare const VFab: {
     app: BooleanConstructor;
     appear: BooleanConstructor;
     extended: BooleanConstructor;
+    layout: BooleanConstructor;
     location: {
         type: PropType<"left" | "right" | "end" | "top" | "bottom" | "start">;
         default: string;
@@ -2997,11 +3007,13 @@ declare const VNumberInput: {
         disabled: boolean;
         focused: boolean;
         readonly: boolean | null;
-        modelValue: string | number;
         variant: "underlined" | "filled" | "outlined" | "plain" | "solo" | "solo-inverted" | "solo-filled";
         inset: boolean;
         density: Density;
+        max: number;
         persistentHint: boolean;
+        min: number;
+        step: number;
         controlVariant: ControlVariant;
         hideInput: boolean;
     } & {
@@ -3011,14 +3023,12 @@ declare const VNumberInput: {
         color?: string | undefined;
         loading?: string | boolean | undefined;
         'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+        modelValue?: number | undefined;
         rounded?: string | number | boolean | undefined;
-        max?: number | undefined;
         bgColor?: string | undefined;
         baseColor?: string | undefined;
         hint?: string | undefined;
         hideDetails?: boolean | "auto" | undefined;
-        min?: number | undefined;
-        step?: number | undefined;
     } & {
         $children?: {} | vue.VNodeChild | {
             clear?: ((arg: DefaultInputSlot & {
@@ -3084,11 +3094,13 @@ declare const VNumberInput: {
         disabled: boolean;
         focused: boolean;
         readonly: boolean | null;
-        modelValue: string | number;
         variant: "underlined" | "filled" | "outlined" | "plain" | "solo" | "solo-inverted" | "solo-filled";
         inset: boolean;
         density: Density;
+        max: number;
         persistentHint: boolean;
+        min: number;
+        step: number;
         controlVariant: ControlVariant;
         hideInput: boolean;
     } & {
@@ -3098,14 +3110,12 @@ declare const VNumberInput: {
         color?: string | undefined;
         loading?: string | boolean | undefined;
         'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+        modelValue?: number | undefined;
         rounded?: string | number | boolean | undefined;
-        max?: number | undefined;
         bgColor?: string | undefined;
         baseColor?: string | undefined;
         hint?: string | undefined;
         hideDetails?: boolean | "auto" | undefined;
-        min?: number | undefined;
-        step?: number | undefined;
     } & {
         $children?: {} | vue.VNodeChild | {
             clear?: ((arg: DefaultInputSlot & {
@@ -3169,12 +3179,15 @@ declare const VNumberInput: {
         disabled: boolean;
         focused: boolean;
         readonly: boolean | null;
-        modelValue: string | number;
+        modelValue: number;
         rounded: string | number | boolean;
         variant: "underlined" | "filled" | "outlined" | "plain" | "solo" | "solo-inverted" | "solo-filled";
         inset: boolean;
         density: Density;
+        max: number;
         persistentHint: boolean;
+        min: number;
+        step: number;
         controlVariant: ControlVariant;
         hideInput: boolean;
     }, true, {}, vue.SlotsType<Partial<{
@@ -3230,11 +3243,13 @@ declare const VNumberInput: {
         disabled: boolean;
         focused: boolean;
         readonly: boolean | null;
-        modelValue: string | number;
         variant: "underlined" | "filled" | "outlined" | "plain" | "solo" | "solo-inverted" | "solo-filled";
         inset: boolean;
         density: Density;
+        max: number;
         persistentHint: boolean;
+        min: number;
+        step: number;
         controlVariant: ControlVariant;
         hideInput: boolean;
     } & {
@@ -3244,14 +3259,12 @@ declare const VNumberInput: {
         color?: string | undefined;
         loading?: string | boolean | undefined;
         'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+        modelValue?: number | undefined;
         rounded?: string | number | boolean | undefined;
-        max?: number | undefined;
         bgColor?: string | undefined;
         baseColor?: string | undefined;
         hint?: string | undefined;
         hideDetails?: boolean | "auto" | undefined;
-        min?: number | undefined;
-        step?: number | undefined;
     } & {
         $children?: {} | vue.VNodeChild | {
             clear?: ((arg: DefaultInputSlot & {
@@ -3315,12 +3328,15 @@ declare const VNumberInput: {
         disabled: boolean;
         focused: boolean;
         readonly: boolean | null;
-        modelValue: string | number;
+        modelValue: number;
         rounded: string | number | boolean;
         variant: "underlined" | "filled" | "outlined" | "plain" | "solo" | "solo-inverted" | "solo-filled";
         inset: boolean;
         density: Density;
+        max: number;
         persistentHint: boolean;
+        min: number;
+        step: number;
         controlVariant: ControlVariant;
         hideInput: boolean;
     }>;
@@ -3334,11 +3350,13 @@ declare const VNumberInput: {
     disabled: boolean;
     focused: boolean;
     readonly: boolean | null;
-    modelValue: string | number;
     variant: "underlined" | "filled" | "outlined" | "plain" | "solo" | "solo-inverted" | "solo-filled";
     inset: boolean;
     density: Density;
+    max: number;
     persistentHint: boolean;
+    min: number;
+    step: number;
     controlVariant: ControlVariant;
     hideInput: boolean;
 } & {
@@ -3348,14 +3366,12 @@ declare const VNumberInput: {
     color?: string | undefined;
     loading?: string | boolean | undefined;
     'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+    modelValue?: number | undefined;
     rounded?: string | number | boolean | undefined;
-    max?: number | undefined;
     bgColor?: string | undefined;
     baseColor?: string | undefined;
     hint?: string | undefined;
     hideDetails?: boolean | "auto" | undefined;
-    min?: number | undefined;
-    step?: number | undefined;
 } & {
     $children?: {} | vue.VNodeChild | {
         clear?: ((arg: DefaultInputSlot & {
@@ -3421,12 +3437,15 @@ declare const VNumberInput: {
     disabled: boolean;
     focused: boolean;
     readonly: boolean | null;
-    modelValue: string | number;
+    modelValue: number;
     rounded: string | number | boolean;
     variant: "underlined" | "filled" | "outlined" | "plain" | "solo" | "solo-inverted" | "solo-filled";
     inset: boolean;
     density: Density;
+    max: number;
     persistentHint: boolean;
+    min: number;
+    step: number;
     controlVariant: ControlVariant;
     hideInput: boolean;
 }, {}, string, vue.SlotsType<Partial<{
@@ -3470,8 +3489,8 @@ declare const VNumberInput: {
     }>[];
 }>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
     modelValue: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: number;
+        type: NumberConstructor;
+        default: undefined;
     };
     focused: BooleanConstructor;
     'onUpdate:focused': PropType<(args_0: boolean) => void>;
@@ -3519,13 +3538,22 @@ declare const VNumberInput: {
     };
     inset: BooleanConstructor;
     hideInput: BooleanConstructor;
-    min: NumberConstructor;
-    max: NumberConstructor;
-    step: NumberConstructor;
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
 }, vue.ExtractPropTypes<{
     modelValue: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: number;
+        type: NumberConstructor;
+        default: undefined;
     };
     focused: BooleanConstructor;
     'onUpdate:focused': PropType<(args_0: boolean) => void>;
@@ -3573,9 +3601,18 @@ declare const VNumberInput: {
     };
     inset: BooleanConstructor;
     hideInput: BooleanConstructor;
-    min: NumberConstructor;
-    max: NumberConstructor;
-    step: NumberConstructor;
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
 }>>;
 type VNumberInput = InstanceType<typeof VNumberInput>;
 
@@ -3812,186 +3849,2823 @@ declare const VPicker: {
         type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
         default: undefined;
     };
-    tile: BooleanConstructor;
+    tile: BooleanConstructor;
+    position: {
+        type: vue.PropType<"fixed" | "absolute" | "relative" | "static" | "sticky">;
+        validator: (v: any) => boolean;
+    };
+    location: vue.PropType<Anchor>;
+    elevation: {
+        type: (StringConstructor | NumberConstructor)[];
+        validator(v: any): boolean;
+    };
+    height: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    width: (StringConstructor | NumberConstructor)[];
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    border: (StringConstructor | NumberConstructor | BooleanConstructor)[];
+    color: StringConstructor;
+    bgColor: StringConstructor;
+    landscape: BooleanConstructor;
+    title: StringConstructor;
+    hideHeader: BooleanConstructor;
+}, vue.ExtractPropTypes<{
+    theme: StringConstructor;
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    rounded: {
+        type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+    tile: BooleanConstructor;
+    position: {
+        type: vue.PropType<"fixed" | "absolute" | "relative" | "static" | "sticky">;
+        validator: (v: any) => boolean;
+    };
+    location: vue.PropType<Anchor>;
+    elevation: {
+        type: (StringConstructor | NumberConstructor)[];
+        validator(v: any): boolean;
+    };
+    height: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    width: (StringConstructor | NumberConstructor)[];
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    border: (StringConstructor | NumberConstructor | BooleanConstructor)[];
+    color: StringConstructor;
+    bgColor: StringConstructor;
+    landscape: BooleanConstructor;
+    title: StringConstructor;
+    hideHeader: BooleanConstructor;
+}>>;
+type VPicker = InstanceType<typeof VPicker>;
+
+declare const VPickerTitle: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        style: vue.StyleValue;
+        tag: string;
+    } & {
+        class?: any;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: (() => vue.VNodeChild) | undefined;
+        } | (() => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+    }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        style: vue.StyleValue;
+        tag: string;
+    } & {
+        class?: any;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: (() => vue.VNodeChild) | undefined;
+        } | (() => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+    }, {
+        style: vue.StyleValue;
+        tag: string;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        style: vue.StyleValue;
+        tag: string;
+    } & {
+        class?: any;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: (() => vue.VNodeChild) | undefined;
+        } | (() => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+    }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, {
+        style: vue.StyleValue;
+        tag: string;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    style: vue.StyleValue;
+    tag: string;
+} & {
+    class?: any;
+} & {
+    $children?: vue.VNodeChild | {
+        default?: (() => vue.VNodeChild) | undefined;
+    } | (() => vue.VNodeChild);
+    'v-slots'?: {
+        default?: false | (() => vue.VNodeChild) | undefined;
+    } | undefined;
+} & {
+    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+    style: vue.StyleValue;
+    tag: string;
+}, {}, string, vue.SlotsType<Partial<{
+    default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+}, vue.ExtractPropTypes<{
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>;
+type VPickerTitle = InstanceType<typeof VPickerTitle>;
+
+interface LocationStrategyData {
+    contentEl: Ref<HTMLElement | undefined>;
+    target: Ref<HTMLElement | [x: number, y: number] | undefined>;
+    isActive: Ref<boolean>;
+    isRtl: Ref<boolean>;
+}
+type LocationStrategyFn = (data: LocationStrategyData, props: StrategyProps$1, contentStyles: Ref<Record<string, string>>) => undefined | {
+    updateLocation: (e: Event) => void;
+};
+declare const locationStrategies: {
+    static: typeof staticLocationStrategy;
+    connected: typeof connectedLocationStrategy;
+};
+interface StrategyProps$1 {
+    locationStrategy: keyof typeof locationStrategies | LocationStrategyFn;
+    location: Anchor;
+    origin: Anchor | 'auto' | 'overlap';
+    offset?: number | string | number[];
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    minWidth?: number | string;
+}
+declare function staticLocationStrategy(): void;
+declare function connectedLocationStrategy(data: LocationStrategyData, props: StrategyProps$1, contentStyles: Ref<Record<string, string>>): {
+    updateLocation: () => {
+        available: {
+            x: number;
+            y: number;
+        };
+        contentBox: Box;
+    } | undefined;
+};
+
+interface ScrollStrategyData {
+    root: Ref<HTMLElement | undefined>;
+    contentEl: Ref<HTMLElement | undefined>;
+    targetEl: Ref<HTMLElement | undefined>;
+    isActive: Ref<boolean>;
+    updateLocation: Ref<((e: Event) => void) | undefined>;
+}
+type ScrollStrategyFn = (data: ScrollStrategyData, props: StrategyProps, scope: EffectScope) => void;
+declare const scrollStrategies: {
+    none: null;
+    close: typeof closeScrollStrategy;
+    block: typeof blockScrollStrategy;
+    reposition: typeof repositionScrollStrategy;
+};
+interface StrategyProps {
+    scrollStrategy: keyof typeof scrollStrategies | ScrollStrategyFn;
+    contained: boolean | undefined;
+}
+declare function closeScrollStrategy(data: ScrollStrategyData): void;
+declare function blockScrollStrategy(data: ScrollStrategyData, props: StrategyProps): void;
+declare function repositionScrollStrategy(data: ScrollStrategyData, props: StrategyProps, scope: EffectScope): void;
+
+declare const VSnackbar: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        zIndex: string | number;
+        modelValue: boolean;
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        origin: Anchor | "auto" | "overlap";
+        vertical: boolean;
+        tile: boolean;
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        multiLine: boolean;
+        timeout: string | number;
+    } & {
+        class?: any;
+        text?: string | undefined;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        color?: string | undefined;
+        offset?: string | number | number[] | undefined;
+        position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+        rounded?: string | number | boolean | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+        timer?: string | boolean | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            default?: (() => vue.VNodeChild) | undefined;
+            actions?: (() => vue.VNodeChild) | undefined;
+            text?: (() => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            default?: false | (() => vue.VNodeChild) | undefined;
+            actions?: false | (() => vue.VNodeChild) | undefined;
+            text?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:actions"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:text"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: boolean) => any) | undefined;
+    }, Omit<Omit<{
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            style: vue.StyleValue;
+            disabled: boolean;
+            absolute: boolean;
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component | undefined;
+            });
+            zIndex: string | number;
+            modelValue: boolean;
+            origin: Anchor | "auto" | "overlap";
+            eager: boolean;
+            location: Anchor;
+            locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined) | "connected";
+            scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }> & Omit<{
+            style: vue.StyleValue;
+            disabled: boolean;
+            absolute: boolean;
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component | undefined;
+            });
+            zIndex: string | number;
+            modelValue: boolean;
+            origin: Anchor | "auto" | "overlap";
+            eager: boolean;
+            location: Anchor;
+            locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined) | "connected";
+            scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+            class?: any;
+            width?: string | number | undefined;
+            height?: string | number | undefined;
+            theme?: string | undefined;
+            target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+            offset?: string | number | number[] | undefined;
+            contentClass?: any;
+            opacity?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild);
+            'v-slots'?: {
+                default?: false | ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+            "v-slot:default"?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            onAfterEnter?: (() => any) | undefined;
+            onAfterLeave?: (() => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+            style: vue.StyleValue;
+            disabled: boolean;
+            absolute: boolean;
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component | undefined;
+            });
+            zIndex: string | number;
+            modelValue: boolean;
+            origin: Anchor | "auto" | "overlap";
+            eager: boolean;
+            location: Anchor;
+            locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined) | "connected";
+            scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            class?: any;
+            width?: string | number | undefined;
+            height?: string | number | undefined;
+            theme?: string | undefined;
+            target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+            offset?: string | number | number[] | undefined;
+            contentClass?: any;
+            opacity?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild);
+            'v-slots'?: {
+                default?: false | ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            onAfterEnter?: (() => any) | undefined;
+            onAfterLeave?: (() => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        }, "style" | "disabled" | "absolute" | "transition" | "zIndex" | "modelValue" | "origin" | "eager" | "location" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            default?: ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | 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: "afterEnter") => void) & ((event: "afterLeave") => void);
+        $el: any;
+        $options: vue.ComponentOptionsBase<{
+            style: vue.StyleValue;
+            disabled: boolean;
+            absolute: boolean;
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component | undefined;
+            });
+            zIndex: string | number;
+            modelValue: boolean;
+            origin: Anchor | "auto" | "overlap";
+            eager: boolean;
+            location: Anchor;
+            locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined) | "connected";
+            scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            class?: any;
+            width?: string | number | undefined;
+            height?: string | number | undefined;
+            theme?: string | undefined;
+            target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+            offset?: string | number | number[] | undefined;
+            contentClass?: any;
+            opacity?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild);
+            'v-slots'?: {
+                default?: false | ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            onAfterEnter?: (() => any) | undefined;
+            onAfterLeave?: (() => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        }, {
+            activatorEl: vue.Ref<HTMLElement | undefined>;
+            scrimEl: vue.Ref<HTMLElement | undefined>;
+            target: vue.ComputedRef<HTMLElement | [x: number, y: number] | 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;
+            afterEnter: () => true;
+            afterLeave: () => true;
+        }, string, {
+            style: vue.StyleValue;
+            disabled: boolean;
+            absolute: boolean;
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component | undefined;
+            });
+            zIndex: string | number;
+            modelValue: boolean;
+            origin: Anchor | "auto" | "overlap";
+            eager: boolean;
+            location: Anchor;
+            locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined) | "connected";
+            scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }, {}, string, vue.SlotsType<Partial<{
+            default: (arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            activator: (arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }>>> & {
+            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 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;
+    } & Omit<{
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        zIndex: string | number;
+        modelValue: boolean;
+        origin: Anchor | "auto" | "overlap";
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        persistent: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    } & {
+        class?: any;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        offset?: string | number | number[] | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        onAfterEnter?: (() => any) | undefined;
+        onAfterLeave?: (() => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    }, "target" | "activatorEl" | "scrimEl" | "animateClick" | "contentEl" | "globalTop" | "localTop" | "updateLocation"> & vue.ShallowUnwrapRef<{
+        activatorEl: vue.Ref<HTMLElement | undefined>;
+        scrimEl: vue.Ref<HTMLElement | undefined>;
+        target: vue.ComputedRef<HTMLElement | [x: number, y: number] | 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 & {}, "class" | "width" | "height" | "theme" | "key" | "target" | "v-slot:default" | "$children" | "v-slots" | "ref" | "ref_for" | "ref_key" | "onVnodeBeforeMount" | "onVnodeMounted" | "onVnodeBeforeUpdate" | "onVnodeUpdated" | "onVnodeBeforeUnmount" | "onVnodeUnmounted" | "offset" | "onUpdate:modelValue" | "contentClass" | "opacity" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "onAfterEnter" | "onAfterLeave" | "activator" | "v-slot:activator" | "closeDelay" | "openDelay" | "contentProps" | "attach" | "onClick:outside" | ("style" | "disabled" | "absolute" | "transition" | "zIndex" | "modelValue" | "origin" | "eager" | "location" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack")>, `$${any}`>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        'update:modelValue': (v: boolean) => boolean;
+    }, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        zIndex: string | number;
+        modelValue: boolean;
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        origin: Anchor | "auto" | "overlap";
+        vertical: boolean;
+        tile: boolean;
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        multiLine: boolean;
+        timeout: string | number;
+    } & {
+        class?: any;
+        text?: string | undefined;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        color?: string | undefined;
+        offset?: string | number | number[] | undefined;
+        position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+        rounded?: string | number | boolean | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+        timer?: string | boolean | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            default?: (() => vue.VNodeChild) | undefined;
+            actions?: (() => vue.VNodeChild) | undefined;
+            text?: (() => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            default?: false | (() => vue.VNodeChild) | undefined;
+            actions?: false | (() => vue.VNodeChild) | undefined;
+            text?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:actions"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:text"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: boolean) => any) | undefined;
+    }, {
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        zIndex: string | number;
+        modelValue: boolean;
+        rounded: string | number | boolean;
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        origin: Anchor | "auto" | "overlap";
+        vertical: boolean;
+        tile: boolean;
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        multiLine: boolean;
+        timeout: string | number;
+    }, true, {}, vue.SlotsType<Partial<{
+        activator: (arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        actions: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        text: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        zIndex: string | number;
+        modelValue: boolean;
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        origin: Anchor | "auto" | "overlap";
+        vertical: boolean;
+        tile: boolean;
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        multiLine: boolean;
+        timeout: string | number;
+    } & {
+        class?: any;
+        text?: string | undefined;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        color?: string | undefined;
+        offset?: string | number | number[] | undefined;
+        position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+        rounded?: string | number | boolean | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+        timer?: string | boolean | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            default?: (() => vue.VNodeChild) | undefined;
+            actions?: (() => vue.VNodeChild) | undefined;
+            text?: (() => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            default?: false | (() => vue.VNodeChild) | undefined;
+            actions?: false | (() => vue.VNodeChild) | undefined;
+            text?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:actions"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:text"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: boolean) => any) | undefined;
+    }, Omit<Omit<{
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            style: vue.StyleValue;
+            disabled: boolean;
+            absolute: boolean;
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component | undefined;
+            });
+            zIndex: string | number;
+            modelValue: boolean;
+            origin: Anchor | "auto" | "overlap";
+            eager: boolean;
+            location: Anchor;
+            locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined) | "connected";
+            scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }> & Omit<{
+            style: vue.StyleValue;
+            disabled: boolean;
+            absolute: boolean;
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component | undefined;
+            });
+            zIndex: string | number;
+            modelValue: boolean;
+            origin: Anchor | "auto" | "overlap";
+            eager: boolean;
+            location: Anchor;
+            locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined) | "connected";
+            scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+            class?: any;
+            width?: string | number | undefined;
+            height?: string | number | undefined;
+            theme?: string | undefined;
+            target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+            offset?: string | number | number[] | undefined;
+            contentClass?: any;
+            opacity?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild);
+            'v-slots'?: {
+                default?: false | ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+            "v-slot:default"?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            onAfterEnter?: (() => any) | undefined;
+            onAfterLeave?: (() => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+            style: vue.StyleValue;
+            disabled: boolean;
+            absolute: boolean;
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component | undefined;
+            });
+            zIndex: string | number;
+            modelValue: boolean;
+            origin: Anchor | "auto" | "overlap";
+            eager: boolean;
+            location: Anchor;
+            locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined) | "connected";
+            scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            class?: any;
+            width?: string | number | undefined;
+            height?: string | number | undefined;
+            theme?: string | undefined;
+            target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+            offset?: string | number | number[] | undefined;
+            contentClass?: any;
+            opacity?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild);
+            'v-slots'?: {
+                default?: false | ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            onAfterEnter?: (() => any) | undefined;
+            onAfterLeave?: (() => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        }, "style" | "disabled" | "absolute" | "transition" | "zIndex" | "modelValue" | "origin" | "eager" | "location" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            default?: ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | 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: "afterEnter") => void) & ((event: "afterLeave") => void);
+        $el: any;
+        $options: vue.ComponentOptionsBase<{
+            style: vue.StyleValue;
+            disabled: boolean;
+            absolute: boolean;
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component | undefined;
+            });
+            zIndex: string | number;
+            modelValue: boolean;
+            origin: Anchor | "auto" | "overlap";
+            eager: boolean;
+            location: Anchor;
+            locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined) | "connected";
+            scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            class?: any;
+            width?: string | number | undefined;
+            height?: string | number | undefined;
+            theme?: string | undefined;
+            target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+            offset?: string | number | number[] | undefined;
+            contentClass?: any;
+            opacity?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild);
+            'v-slots'?: {
+                default?: false | ((arg: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            onAfterEnter?: (() => any) | undefined;
+            onAfterLeave?: (() => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        }, {
+            activatorEl: vue.Ref<HTMLElement | undefined>;
+            scrimEl: vue.Ref<HTMLElement | undefined>;
+            target: vue.ComputedRef<HTMLElement | [x: number, y: number] | 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;
+            afterEnter: () => true;
+            afterLeave: () => true;
+        }, string, {
+            style: vue.StyleValue;
+            disabled: boolean;
+            absolute: boolean;
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component | undefined;
+            });
+            zIndex: string | number;
+            modelValue: boolean;
+            origin: Anchor | "auto" | "overlap";
+            eager: boolean;
+            location: Anchor;
+            locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined) | "connected";
+            scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }, {}, string, vue.SlotsType<Partial<{
+            default: (arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            activator: (arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }>>> & {
+            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 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;
+    } & Omit<{
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        zIndex: string | number;
+        modelValue: boolean;
+        origin: Anchor | "auto" | "overlap";
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        persistent: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    } & {
+        class?: any;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        offset?: string | number | number[] | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        onAfterEnter?: (() => any) | undefined;
+        onAfterLeave?: (() => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    }, "target" | "activatorEl" | "scrimEl" | "animateClick" | "contentEl" | "globalTop" | "localTop" | "updateLocation"> & vue.ShallowUnwrapRef<{
+        activatorEl: vue.Ref<HTMLElement | undefined>;
+        scrimEl: vue.Ref<HTMLElement | undefined>;
+        target: vue.ComputedRef<HTMLElement | [x: number, y: number] | 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 & {}, "class" | "width" | "height" | "theme" | "key" | "target" | "v-slot:default" | "$children" | "v-slots" | "ref" | "ref_for" | "ref_key" | "onVnodeBeforeMount" | "onVnodeMounted" | "onVnodeBeforeUpdate" | "onVnodeUpdated" | "onVnodeBeforeUnmount" | "onVnodeUnmounted" | "offset" | "onUpdate:modelValue" | "contentClass" | "opacity" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "onAfterEnter" | "onAfterLeave" | "activator" | "v-slot:activator" | "closeDelay" | "openDelay" | "contentProps" | "attach" | "onClick:outside" | ("style" | "disabled" | "absolute" | "transition" | "zIndex" | "modelValue" | "origin" | "eager" | "location" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack")>, `$${any}`>, {}, {}, {}, {
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        zIndex: string | number;
+        modelValue: boolean;
+        rounded: string | number | boolean;
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        origin: Anchor | "auto" | "overlap";
+        vertical: boolean;
+        tile: boolean;
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        multiLine: boolean;
+        timeout: string | number;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    style: vue.StyleValue;
+    disabled: boolean;
+    absolute: boolean;
+    transition: NonNullable<string | boolean | (vue.TransitionProps & {
+        component?: vue.Component | undefined;
+    })>;
+    zIndex: string | number;
+    modelValue: boolean;
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+    origin: Anchor | "auto" | "overlap";
+    vertical: boolean;
+    tile: boolean;
+    eager: boolean;
+    location: Anchor;
+    locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+        updateLocation: (e: Event) => void;
+    } | undefined) | "connected";
+    activatorProps: Record<string, any>;
+    openOnHover: boolean;
+    closeOnContentClick: boolean;
+    closeOnBack: boolean;
+    contained: boolean;
+    multiLine: boolean;
+    timeout: string | number;
+} & {
+    class?: any;
+    text?: string | undefined;
+    width?: string | number | undefined;
+    height?: string | number | undefined;
+    theme?: string | undefined;
+    target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+    color?: string | undefined;
+    offset?: string | number | number[] | undefined;
+    position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+    rounded?: string | number | boolean | undefined;
+    contentClass?: any;
+    opacity?: string | number | undefined;
+    maxHeight?: string | number | undefined;
+    maxWidth?: string | number | undefined;
+    minHeight?: string | number | undefined;
+    minWidth?: string | number | undefined;
+    activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined;
+    closeDelay?: string | number | undefined;
+    openDelay?: string | number | undefined;
+    openOnClick?: boolean | undefined;
+    openOnFocus?: boolean | undefined;
+    contentProps?: any;
+    attach?: string | boolean | Element | undefined;
+    timer?: string | boolean | undefined;
+} & {
+    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+        activator?: ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+        default?: (() => vue.VNodeChild) | undefined;
+        actions?: (() => vue.VNodeChild) | undefined;
+        text?: (() => vue.VNodeChild) | undefined;
+    };
+    'v-slots'?: {
+        activator?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+        default?: false | (() => vue.VNodeChild) | undefined;
+        actions?: false | (() => vue.VNodeChild) | undefined;
+        text?: false | (() => vue.VNodeChild) | undefined;
+    } | undefined;
+} & {
+    "v-slot:activator"?: false | ((arg: {
+        isActive: boolean;
+        props: Record<string, any>;
+    }) => vue.VNodeChild) | undefined;
+    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+    "v-slot:actions"?: false | (() => vue.VNodeChild) | undefined;
+    "v-slot:text"?: false | (() => vue.VNodeChild) | undefined;
+} & {
+    "onUpdate:modelValue"?: ((v: boolean) => any) | undefined;
+}, Omit<Omit<{
+    $: vue.ComponentInternalInstance;
+    $data: {};
+    $props: Partial<{
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        zIndex: string | number;
+        modelValue: boolean;
+        origin: Anchor | "auto" | "overlap";
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        persistent: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    }> & Omit<{
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        zIndex: string | number;
+        modelValue: boolean;
+        origin: Anchor | "auto" | "overlap";
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        persistent: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+        class?: any;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        offset?: string | number | number[] | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+        "v-slot:default"?: false | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        onAfterEnter?: (() => any) | undefined;
+        onAfterLeave?: (() => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        zIndex: string | number;
+        modelValue: boolean;
+        origin: Anchor | "auto" | "overlap";
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        persistent: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    } & {
+        class?: any;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        offset?: string | number | number[] | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        onAfterEnter?: (() => any) | undefined;
+        onAfterLeave?: (() => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    }, "style" | "disabled" | "absolute" | "transition" | "zIndex" | "modelValue" | "origin" | "eager" | "location" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack">;
+    $attrs: {
+        [x: string]: unknown;
+    };
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        default?: ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[]) | undefined;
+        activator?: ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[]) | 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: "afterEnter") => void) & ((event: "afterLeave") => void);
+    $el: any;
+    $options: vue.ComponentOptionsBase<{
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        zIndex: string | number;
+        modelValue: boolean;
+        origin: Anchor | "auto" | "overlap";
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        persistent: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    } & {
+        class?: any;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        offset?: string | number | number[] | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        onAfterEnter?: (() => any) | undefined;
+        onAfterLeave?: (() => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    }, {
+        activatorEl: vue.Ref<HTMLElement | undefined>;
+        scrimEl: vue.Ref<HTMLElement | undefined>;
+        target: vue.ComputedRef<HTMLElement | [x: number, y: number] | 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;
+        afterEnter: () => true;
+        afterLeave: () => true;
+    }, string, {
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        zIndex: string | number;
+        modelValue: boolean;
+        origin: Anchor | "auto" | "overlap";
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        persistent: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    }, {}, string, vue.SlotsType<Partial<{
+        default: (arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        activator: (arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>> & {
+        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 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;
+} & Omit<{
+    style: vue.StyleValue;
+    disabled: boolean;
+    absolute: boolean;
+    transition: string | boolean | (vue.TransitionProps & {
+        component?: vue.Component | undefined;
+    });
+    zIndex: string | number;
+    modelValue: boolean;
+    origin: Anchor | "auto" | "overlap";
+    eager: boolean;
+    location: Anchor;
+    locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+        updateLocation: (e: Event) => void;
+    } | undefined) | "connected";
+    scrollStrategy: "close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition";
+    activatorProps: Record<string, any>;
+    openOnHover: boolean;
+    closeOnContentClick: boolean;
+    closeOnBack: boolean;
+    contained: boolean;
+    noClickAnimation: boolean;
+    persistent: boolean;
+    scrim: string | boolean;
+    _disableGlobalStack: boolean;
+} & {
+    class?: any;
+    width?: string | number | undefined;
+    height?: string | number | undefined;
+    theme?: string | undefined;
+    target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+    offset?: string | number | number[] | undefined;
+    contentClass?: any;
+    opacity?: string | number | undefined;
+    maxHeight?: string | number | undefined;
+    maxWidth?: string | number | undefined;
+    minHeight?: string | number | undefined;
+    minWidth?: string | number | undefined;
+    activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | 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?: ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        activator?: ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+    } | ((arg: {
+        isActive: vue.Ref<boolean>;
+    }) => vue.VNodeChild);
+    'v-slots'?: {
+        default?: false | ((arg: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        activator?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+    } | undefined;
+} & {
+    "v-slot:default"?: false | ((arg: {
+        isActive: vue.Ref<boolean>;
+    }) => vue.VNodeChild) | undefined;
+    "v-slot:activator"?: false | ((arg: {
+        isActive: boolean;
+        props: Record<string, any>;
+    }) => vue.VNodeChild) | undefined;
+} & {
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onAfterEnter?: (() => any) | undefined;
+    onAfterLeave?: (() => any) | undefined;
+    "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+}, "target" | "activatorEl" | "scrimEl" | "animateClick" | "contentEl" | "globalTop" | "localTop" | "updateLocation"> & vue.ShallowUnwrapRef<{
+    activatorEl: vue.Ref<HTMLElement | undefined>;
+    scrimEl: vue.Ref<HTMLElement | undefined>;
+    target: vue.ComputedRef<HTMLElement | [x: number, y: number] | 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 & {}, "class" | "width" | "height" | "theme" | "key" | "target" | "v-slot:default" | "$children" | "v-slots" | "ref" | "ref_for" | "ref_key" | "onVnodeBeforeMount" | "onVnodeMounted" | "onVnodeBeforeUpdate" | "onVnodeUpdated" | "onVnodeBeforeUnmount" | "onVnodeUnmounted" | "offset" | "onUpdate:modelValue" | "contentClass" | "opacity" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "onAfterEnter" | "onAfterLeave" | "activator" | "v-slot:activator" | "closeDelay" | "openDelay" | "contentProps" | "attach" | "onClick:outside" | ("style" | "disabled" | "absolute" | "transition" | "zIndex" | "modelValue" | "origin" | "eager" | "location" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim" | "_disableGlobalStack")>, `$${any}`>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (v: boolean) => boolean;
+}, string, {
+    style: vue.StyleValue;
+    disabled: boolean;
+    absolute: boolean;
+    transition: NonNullable<string | boolean | (vue.TransitionProps & {
+        component?: vue.Component | undefined;
+    })>;
+    zIndex: string | number;
+    modelValue: boolean;
+    rounded: string | number | boolean;
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+    origin: Anchor | "auto" | "overlap";
+    vertical: boolean;
+    tile: boolean;
+    eager: boolean;
+    location: Anchor;
+    locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+        updateLocation: (e: Event) => void;
+    } | undefined) | "connected";
+    activatorProps: Record<string, any>;
+    openOnClick: boolean;
+    openOnHover: boolean;
+    openOnFocus: boolean;
+    closeOnContentClick: boolean;
+    closeOnBack: boolean;
+    contained: boolean;
+    multiLine: boolean;
+    timeout: string | number;
+}, {}, string, vue.SlotsType<Partial<{
+    activator: (arg: {
+        isActive: boolean;
+        props: Record<string, any>;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    actions: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    text: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    width: (StringConstructor | NumberConstructor)[];
+    height: (StringConstructor | NumberConstructor)[];
+    theme: StringConstructor;
+    target: vue.PropType<Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined>;
+    disabled: BooleanConstructor;
+    offset: vue.PropType<string | number | number[] | undefined>;
+    absolute: BooleanConstructor;
+    transition: Omit<{
+        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    }, "default" | "type"> & {
+        type: vue.PropType<NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+    };
+    zIndex: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    modelValue: BooleanConstructor;
+    contentClass: null;
+    origin: {
+        type: vue.PropType<Anchor | "auto" | "overlap">;
+        default: string;
+    };
+    opacity: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    eager: BooleanConstructor;
+    location: {
+        type: vue.PropType<Anchor>;
+        default: string;
+    };
+    activator: vue.PropType<Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined>;
+    locationStrategy: {
+        type: vue.PropType<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected">;
+        default: string;
+        validator: (val: any) => boolean;
+    };
+    closeDelay: (StringConstructor | NumberConstructor)[];
+    openDelay: (StringConstructor | NumberConstructor)[];
+    activatorProps: {
+        type: vue.PropType<Record<string, any>>;
+        default: () => {};
+    };
+    openOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openOnHover: BooleanConstructor;
+    openOnFocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    closeOnContentClick: BooleanConstructor;
+    closeOnBack: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contained: BooleanConstructor;
+    contentProps: null;
+    attach: vue.PropType<string | boolean | Element>;
+    color: StringConstructor;
+    variant: {
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    rounded: {
+        type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+    tile: BooleanConstructor;
+    position: {
+        type: vue.PropType<"fixed" | "absolute" | "relative" | "static" | "sticky">;
+        validator: (v: any) => boolean;
+    };
+    multiLine: BooleanConstructor;
+    text: StringConstructor;
+    timer: (StringConstructor | BooleanConstructor)[];
+    timeout: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    vertical: BooleanConstructor;
+}, vue.ExtractPropTypes<{
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    width: (StringConstructor | NumberConstructor)[];
+    height: (StringConstructor | NumberConstructor)[];
+    theme: StringConstructor;
+    target: vue.PropType<Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined>;
+    disabled: BooleanConstructor;
+    offset: vue.PropType<string | number | number[] | undefined>;
+    absolute: BooleanConstructor;
+    transition: Omit<{
+        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    }, "default" | "type"> & {
+        type: vue.PropType<NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+    };
+    zIndex: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    modelValue: BooleanConstructor;
+    contentClass: null;
+    origin: {
+        type: vue.PropType<Anchor | "auto" | "overlap">;
+        default: string;
+    };
+    opacity: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    eager: BooleanConstructor;
+    location: {
+        type: vue.PropType<Anchor>;
+        default: string;
+    };
+    activator: vue.PropType<Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined>;
+    locationStrategy: {
+        type: vue.PropType<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected">;
+        default: string;
+        validator: (val: any) => boolean;
+    };
+    closeDelay: (StringConstructor | NumberConstructor)[];
+    openDelay: (StringConstructor | NumberConstructor)[];
+    activatorProps: {
+        type: vue.PropType<Record<string, any>>;
+        default: () => {};
+    };
+    openOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openOnHover: BooleanConstructor;
+    openOnFocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    closeOnContentClick: BooleanConstructor;
+    closeOnBack: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contained: BooleanConstructor;
+    contentProps: null;
+    attach: vue.PropType<string | boolean | Element>;
+    color: StringConstructor;
+    variant: {
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    rounded: {
+        type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+    tile: BooleanConstructor;
+    position: {
+        type: vue.PropType<"fixed" | "absolute" | "relative" | "static" | "sticky">;
+        validator: (v: any) => boolean;
+    };
+    multiLine: BooleanConstructor;
+    text: StringConstructor;
+    timer: (StringConstructor | BooleanConstructor)[];
+    timeout: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    vertical: BooleanConstructor;
+}>>;
+type VSnackbar = InstanceType<typeof VSnackbar>;
+
+type VSnackbarQueueSlots<T extends string | SnackbarMessage> = {
+    default: {
+        item: T;
+    };
+    text: {
+        item: T;
+    };
+    actions: {
+        item: T;
+        props: {
+            onClick: () => void;
+        };
+    };
+};
+type SnackbarMessage = Omit<VSnackbar['$props'], '$children' | 'modelValue' | 'onUpdate:modelValue' | 'activator' | 'activatorProps' | 'closeDelay' | 'openDelay' | 'openOnClick' | 'openOnFocus' | 'openOnHover'>;
+declare const VSnackbarQueue: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        zIndex: string | number;
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        origin: Anchor | "auto" | "overlap";
+        vertical: boolean;
+        tile: boolean;
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        closeText: string;
+        multiLine: boolean;
+        timeout: string | number;
+    } & {
+        class?: any;
+        text?: string | undefined;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        color?: string | undefined;
+        offset?: string | number | number[] | undefined;
+        position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+        rounded?: string | number | boolean | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        closable?: string | boolean | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+        timer?: string | boolean | undefined;
+    } & {}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+        'update:modelValue': (val: (string | SnackbarMessage)[]) => true;
+    }, "v-slot:default" | "$children" | "v-slots" | "modelValue" | "v-slot:text" | "update:modelValue" | "v-slot:actions">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        zIndex: string | number;
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        origin: Anchor | "auto" | "overlap";
+        vertical: boolean;
+        tile: boolean;
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        closeText: string;
+        multiLine: boolean;
+        timeout: string | number;
+    } & {
+        class?: any;
+        text?: string | undefined;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        color?: string | undefined;
+        offset?: string | number | number[] | undefined;
+        position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+        rounded?: string | number | boolean | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        closable?: string | boolean | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+        timer?: string | boolean | undefined;
+    } & {}, {
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        zIndex: string | number;
+        rounded: string | number | boolean;
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        origin: Anchor | "auto" | "overlap";
+        vertical: boolean;
+        tile: boolean;
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        closeText: string;
+        multiLine: boolean;
+        timeout: string | number;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: (arg: {
+            item: string | SnackbarMessage;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        text: (arg: {
+            item: string | SnackbarMessage;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        actions: (arg: {
+            item: string | SnackbarMessage;
+            props: {
+                onClick: () => void;
+            };
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        zIndex: string | number;
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        origin: Anchor | "auto" | "overlap";
+        vertical: boolean;
+        tile: boolean;
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        closeText: string;
+        multiLine: boolean;
+        timeout: string | number;
+    } & {
+        class?: any;
+        text?: string | undefined;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        theme?: string | undefined;
+        target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+        color?: string | undefined;
+        offset?: string | number | number[] | undefined;
+        position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+        rounded?: string | number | boolean | undefined;
+        contentClass?: any;
+        opacity?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        closable?: string | boolean | undefined;
+        activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+        timer?: string | boolean | undefined;
+    } & {}, {}, {}, {}, {}, {
+        style: vue.StyleValue;
+        disabled: boolean;
+        absolute: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        zIndex: string | number;
+        rounded: string | number | boolean;
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        origin: Anchor | "auto" | "overlap";
+        vertical: boolean;
+        tile: boolean;
+        eager: boolean;
+        location: Anchor;
+        locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected";
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        closeText: string;
+        multiLine: boolean;
+        timeout: string | number;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    style: vue.StyleValue;
+    disabled: boolean;
+    absolute: boolean;
+    transition: NonNullable<string | boolean | (vue.TransitionProps & {
+        component?: vue.Component | undefined;
+    })>;
+    zIndex: string | number;
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+    origin: Anchor | "auto" | "overlap";
+    vertical: boolean;
+    tile: boolean;
+    eager: boolean;
+    location: Anchor;
+    locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+        updateLocation: (e: Event) => void;
+    } | undefined) | "connected";
+    activatorProps: Record<string, any>;
+    openOnHover: boolean;
+    closeOnContentClick: boolean;
+    closeOnBack: boolean;
+    contained: boolean;
+    closeText: string;
+    multiLine: boolean;
+    timeout: string | number;
+} & {
+    class?: any;
+    text?: string | undefined;
+    width?: string | number | undefined;
+    height?: string | number | undefined;
+    theme?: string | undefined;
+    target?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined;
+    color?: string | undefined;
+    offset?: string | number | number[] | undefined;
+    position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+    rounded?: string | number | boolean | undefined;
+    contentClass?: any;
+    opacity?: string | number | undefined;
+    maxHeight?: string | number | undefined;
+    maxWidth?: string | number | undefined;
+    minHeight?: string | number | undefined;
+    minWidth?: string | number | undefined;
+    closable?: string | boolean | undefined;
+    activator?: Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined;
+    closeDelay?: string | number | undefined;
+    openDelay?: string | number | undefined;
+    openOnClick?: boolean | undefined;
+    openOnFocus?: boolean | undefined;
+    contentProps?: any;
+    attach?: string | boolean | Element | undefined;
+    timer?: string | boolean | undefined;
+} & {}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+    'update:modelValue': (val: (string | SnackbarMessage)[]) => true;
+}, "v-slot:default" | "$children" | "v-slots" | "modelValue" | "v-slot:text" | "update:modelValue" | "v-slot:actions">, string, {
+    style: vue.StyleValue;
+    disabled: boolean;
+    absolute: boolean;
+    transition: NonNullable<string | boolean | (vue.TransitionProps & {
+        component?: vue.Component | undefined;
+    })>;
+    zIndex: string | number;
+    rounded: string | number | boolean;
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+    origin: Anchor | "auto" | "overlap";
+    vertical: boolean;
+    tile: boolean;
+    eager: boolean;
+    location: Anchor;
+    locationStrategy: "static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+        updateLocation: (e: Event) => void;
+    } | undefined) | "connected";
+    activatorProps: Record<string, any>;
+    openOnClick: boolean;
+    openOnHover: boolean;
+    openOnFocus: boolean;
+    closeOnContentClick: boolean;
+    closeOnBack: boolean;
+    contained: boolean;
+    closeText: string;
+    multiLine: boolean;
+    timeout: string | number;
+}, {}, string, vue.SlotsType<Partial<{
+    default: (arg: {
+        item: string | SnackbarMessage;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    text: (arg: {
+        item: string | SnackbarMessage;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    actions: (arg: {
+        item: string | SnackbarMessage;
+        props: {
+            onClick: () => void;
+        };
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T extends readonly (string | SnackbarMessage)[]>(props: {
+    modelValue?: T | undefined;
+    'onUpdate:modelValue'?: ((val: T) => void) | undefined;
+}, slots: VSnackbarQueueSlots<T[number]>) => GenericProps<{
+    modelValue?: T | undefined;
+    'onUpdate:modelValue'?: ((val: T) => void) | undefined;
+}, VSnackbarQueueSlots<T[number]>>) & FilterPropsOptions<{
+    class: PropType<any>;
+    style: {
+        type: PropType<vue.StyleValue>;
+        default: null;
+    };
+    text: StringConstructor;
+    width: (StringConstructor | NumberConstructor)[];
+    height: (StringConstructor | NumberConstructor)[];
+    theme: StringConstructor;
+    target: PropType<Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined>;
+    color: StringConstructor;
+    disabled: BooleanConstructor;
+    offset: PropType<string | number | number[] | undefined>;
+    absolute: BooleanConstructor;
+    transition: Omit<{
+        type: PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    }, "default" | "type"> & {
+        type: PropType<NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+    };
+    position: {
+        type: PropType<"fixed" | "absolute" | "relative" | "static" | "sticky">;
+        validator: (v: any) => boolean;
+    };
+    zIndex: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    rounded: {
+        type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
+        default: undefined;
+    };
+    variant: {
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    contentClass: null;
+    origin: {
+        type: PropType<Anchor | "auto" | "overlap">;
+        default: string;
+    };
+    opacity: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    vertical: BooleanConstructor;
+    tile: BooleanConstructor;
+    eager: BooleanConstructor;
+    location: {
+        type: PropType<Anchor>;
+        default: string;
+    };
+    activator: PropType<Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined>;
+    locationStrategy: {
+        type: PropType<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected">;
+        default: string;
+        validator: (val: any) => boolean;
+    };
+    closeDelay: (StringConstructor | NumberConstructor)[];
+    openDelay: (StringConstructor | NumberConstructor)[];
+    activatorProps: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    openOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openOnHover: BooleanConstructor;
+    openOnFocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    closeOnContentClick: BooleanConstructor;
+    closeOnBack: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contained: BooleanConstructor;
+    contentProps: null;
+    attach: PropType<string | boolean | Element>;
+    multiLine: BooleanConstructor;
+    timer: (StringConstructor | BooleanConstructor)[];
+    timeout: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    closable: (StringConstructor | BooleanConstructor)[];
+    closeText: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: PropType<readonly (string | SnackbarMessage)[]>;
+        default: () => never[];
+    };
+}, vue.ExtractPropTypes<{
+    class: PropType<any>;
+    style: {
+        type: PropType<vue.StyleValue>;
+        default: null;
+    };
+    text: StringConstructor;
+    width: (StringConstructor | NumberConstructor)[];
+    height: (StringConstructor | NumberConstructor)[];
+    theme: StringConstructor;
+    target: PropType<Element | (string & {}) | vue.ComponentPublicInstance | "parent" | "cursor" | [x: number, y: number] | undefined>;
+    color: StringConstructor;
+    disabled: BooleanConstructor;
+    offset: PropType<string | number | number[] | undefined>;
+    absolute: BooleanConstructor;
+    transition: Omit<{
+        type: PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    }, "default" | "type"> & {
+        type: PropType<NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+    };
     position: {
-        type: vue.PropType<"fixed" | "absolute" | "relative" | "static" | "sticky">;
+        type: PropType<"fixed" | "absolute" | "relative" | "static" | "sticky">;
         validator: (v: any) => boolean;
     };
-    location: vue.PropType<Anchor>;
-    elevation: {
+    zIndex: {
         type: (StringConstructor | NumberConstructor)[];
-        validator(v: any): boolean;
-    };
-    height: (StringConstructor | NumberConstructor)[];
-    maxHeight: (StringConstructor | NumberConstructor)[];
-    maxWidth: (StringConstructor | NumberConstructor)[];
-    minHeight: (StringConstructor | NumberConstructor)[];
-    minWidth: (StringConstructor | NumberConstructor)[];
-    width: (StringConstructor | NumberConstructor)[];
-    class: vue.PropType<any>;
-    style: {
-        type: vue.PropType<vue.StyleValue>;
-        default: null;
-    };
-    border: (StringConstructor | NumberConstructor | BooleanConstructor)[];
-    color: StringConstructor;
-    bgColor: StringConstructor;
-    landscape: BooleanConstructor;
-    title: StringConstructor;
-    hideHeader: BooleanConstructor;
-}, vue.ExtractPropTypes<{
-    theme: StringConstructor;
-    tag: {
-        type: StringConstructor;
-        default: string;
+        default: number;
     };
     rounded: {
         type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
         default: undefined;
     };
-    tile: BooleanConstructor;
-    position: {
-        type: vue.PropType<"fixed" | "absolute" | "relative" | "static" | "sticky">;
+    variant: {
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: string;
         validator: (v: any) => boolean;
     };
-    location: vue.PropType<Anchor>;
-    elevation: {
-        type: (StringConstructor | NumberConstructor)[];
-        validator(v: any): boolean;
+    contentClass: null;
+    origin: {
+        type: PropType<Anchor | "auto" | "overlap">;
+        default: string;
     };
-    height: (StringConstructor | NumberConstructor)[];
+    opacity: (StringConstructor | NumberConstructor)[];
     maxHeight: (StringConstructor | NumberConstructor)[];
     maxWidth: (StringConstructor | NumberConstructor)[];
     minHeight: (StringConstructor | NumberConstructor)[];
     minWidth: (StringConstructor | NumberConstructor)[];
-    width: (StringConstructor | NumberConstructor)[];
-    class: vue.PropType<any>;
-    style: {
-        type: vue.PropType<vue.StyleValue>;
-        default: null;
-    };
-    border: (StringConstructor | NumberConstructor | BooleanConstructor)[];
-    color: StringConstructor;
-    bgColor: StringConstructor;
-    landscape: BooleanConstructor;
-    title: StringConstructor;
-    hideHeader: BooleanConstructor;
-}>>;
-type VPicker = InstanceType<typeof VPicker>;
-
-declare const VPickerTitle: {
-    new (...args: any[]): vue.CreateComponentPublicInstance<{
-        style: vue.StyleValue;
-        tag: string;
-    } & {
-        class?: any;
-    } & {
-        $children?: vue.VNodeChild | {
-            default?: (() => vue.VNodeChild) | undefined;
-        } | (() => vue.VNodeChild);
-        'v-slots'?: {
-            default?: false | (() => vue.VNodeChild) | undefined;
-        } | undefined;
-    } & {
-        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-    }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
-        style: vue.StyleValue;
-        tag: string;
-    } & {
-        class?: any;
-    } & {
-        $children?: vue.VNodeChild | {
-            default?: (() => vue.VNodeChild) | undefined;
-        } | (() => vue.VNodeChild);
-        'v-slots'?: {
-            default?: false | (() => vue.VNodeChild) | undefined;
-        } | undefined;
-    } & {
-        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-    }, {
-        style: vue.StyleValue;
-        tag: string;
-    }, true, {}, vue.SlotsType<Partial<{
-        default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>[];
-    }>>, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, {
-        style: vue.StyleValue;
-        tag: string;
-    } & {
-        class?: any;
-    } & {
-        $children?: vue.VNodeChild | {
-            default?: (() => vue.VNodeChild) | undefined;
-        } | (() => vue.VNodeChild);
-        'v-slots'?: {
-            default?: false | (() => vue.VNodeChild) | undefined;
-        } | undefined;
-    } & {
-        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-    }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>, {}, {}, {}, {
-        style: vue.StyleValue;
-        tag: string;
-    }>;
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & vue.ComponentOptionsBase<{
-    style: vue.StyleValue;
-    tag: string;
-} & {
-    class?: any;
-} & {
-    $children?: vue.VNodeChild | {
-        default?: (() => vue.VNodeChild) | undefined;
-    } | (() => vue.VNodeChild);
-    'v-slots'?: {
-        default?: false | (() => vue.VNodeChild) | undefined;
-    } | undefined;
-} & {
-    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
-    style: vue.StyleValue;
-    tag: string;
-}, {}, string, vue.SlotsType<Partial<{
-    default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }>[];
-}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-    class: vue.PropType<any>;
-    style: {
-        type: vue.PropType<vue.StyleValue>;
-        default: null;
+    vertical: BooleanConstructor;
+    tile: BooleanConstructor;
+    eager: BooleanConstructor;
+    location: {
+        type: PropType<Anchor>;
+        default: string;
     };
-    tag: {
-        type: StringConstructor;
+    activator: PropType<Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined>;
+    locationStrategy: {
+        type: PropType<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined) | "connected">;
         default: string;
+        validator: (val: any) => boolean;
     };
-}, vue.ExtractPropTypes<{
-    class: vue.PropType<any>;
-    style: {
-        type: vue.PropType<vue.StyleValue>;
-        default: null;
+    closeDelay: (StringConstructor | NumberConstructor)[];
+    openDelay: (StringConstructor | NumberConstructor)[];
+    activatorProps: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
     };
-    tag: {
+    openOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openOnHover: BooleanConstructor;
+    openOnFocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    closeOnContentClick: BooleanConstructor;
+    closeOnBack: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contained: BooleanConstructor;
+    contentProps: null;
+    attach: PropType<string | boolean | Element>;
+    multiLine: BooleanConstructor;
+    timer: (StringConstructor | BooleanConstructor)[];
+    timeout: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    closable: (StringConstructor | BooleanConstructor)[];
+    closeText: {
         type: StringConstructor;
         default: string;
     };
+    modelValue: {
+        type: PropType<readonly (string | SnackbarMessage)[]>;
+        default: () => never[];
+    };
 }>>;
-type VPickerTitle = InstanceType<typeof VPickerTitle>;
+type VSnackbarQueue = InstanceType<typeof VSnackbarQueue>;
 
 type SparklineItem = number | {
     value: number;
@@ -4386,62 +7060,6 @@ declare const VSparkline: {
 }>>;
 type VSparkline = InstanceType<typeof VSparkline>;
 
-interface ScrollStrategyData {
-    root: Ref<HTMLElement | undefined>;
-    contentEl: Ref<HTMLElement | undefined>;
-    targetEl: Ref<HTMLElement | undefined>;
-    isActive: Ref<boolean>;
-    updateLocation: Ref<((e: Event) => void) | undefined>;
-}
-type ScrollStrategyFn = (data: ScrollStrategyData, props: StrategyProps$1, scope: EffectScope) => void;
-declare const scrollStrategies: {
-    none: null;
-    close: typeof closeScrollStrategy;
-    block: typeof blockScrollStrategy;
-    reposition: typeof repositionScrollStrategy;
-};
-interface StrategyProps$1 {
-    scrollStrategy: keyof typeof scrollStrategies | ScrollStrategyFn;
-    contained: boolean | undefined;
-}
-declare function closeScrollStrategy(data: ScrollStrategyData): void;
-declare function blockScrollStrategy(data: ScrollStrategyData, props: StrategyProps$1): void;
-declare function repositionScrollStrategy(data: ScrollStrategyData, props: StrategyProps$1, scope: EffectScope): void;
-
-interface LocationStrategyData {
-    contentEl: Ref<HTMLElement | undefined>;
-    target: Ref<HTMLElement | [x: number, y: number] | undefined>;
-    isActive: Ref<boolean>;
-    isRtl: Ref<boolean>;
-}
-type LocationStrategyFn = (data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>) => undefined | {
-    updateLocation: (e: Event) => void;
-};
-declare const locationStrategies: {
-    static: typeof staticLocationStrategy;
-    connected: typeof connectedLocationStrategy;
-};
-interface StrategyProps {
-    locationStrategy: keyof typeof locationStrategies | LocationStrategyFn;
-    location: Anchor;
-    origin: Anchor | 'auto' | 'overlap';
-    offset?: number | string | number[];
-    maxHeight?: number | string;
-    maxWidth?: number | string;
-    minHeight?: number | string;
-    minWidth?: number | string;
-}
-declare function staticLocationStrategy(): void;
-declare function connectedLocationStrategy(data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>): {
-    updateLocation: () => {
-        available: {
-            x: number;
-            y: number;
-        };
-        contentBox: Box;
-    } | undefined;
-};
-
 declare const VSpeedDial: {
     new (...args: any[]): vue.CreateComponentPublicInstance<{
         style: vue.StyleValue;
@@ -4458,10 +7076,10 @@ declare const VSpeedDial: {
         minWidth: NonNullable<string | number>;
         eager: boolean;
         location: NonNullable<Anchor>;
-        locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">;
-        scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
         closeDelay: NonNullable<NonNullable<string | number>>;
         openDelay: NonNullable<NonNullable<string | number>>;
         activatorProps: Record<string, any>;
@@ -4533,10 +7151,10 @@ declare const VSpeedDial: {
         minWidth: NonNullable<string | number>;
         eager: boolean;
         location: NonNullable<Anchor>;
-        locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">;
-        scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
         closeDelay: NonNullable<NonNullable<string | number>>;
         openDelay: NonNullable<NonNullable<string | number>>;
         activatorProps: Record<string, any>;
@@ -4608,10 +7226,10 @@ declare const VSpeedDial: {
         minWidth: NonNullable<string | number>;
         eager: boolean;
         location: NonNullable<Anchor>;
-        locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">;
-        scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
         closeDelay: NonNullable<NonNullable<string | number>>;
         openDelay: NonNullable<NonNullable<string | number>>;
         activatorProps: Record<string, any>;
@@ -4658,10 +7276,10 @@ declare const VSpeedDial: {
         minWidth: NonNullable<string | number>;
         eager: boolean;
         location: NonNullable<Anchor>;
-        locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">;
-        scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
         closeDelay: NonNullable<NonNullable<string | number>>;
         openDelay: NonNullable<NonNullable<string | number>>;
         activatorProps: Record<string, any>;
@@ -4733,10 +7351,10 @@ declare const VSpeedDial: {
         minWidth: NonNullable<string | number>;
         eager: boolean;
         location: NonNullable<Anchor>;
-        locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">;
-        scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
         closeDelay: NonNullable<NonNullable<string | number>>;
         openDelay: NonNullable<NonNullable<string | number>>;
         activatorProps: Record<string, any>;
@@ -4768,10 +7386,10 @@ declare const VSpeedDial: {
     minWidth: NonNullable<string | number>;
     eager: boolean;
     location: NonNullable<Anchor>;
-    locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+    locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
         updateLocation: (e: Event) => void;
     } | undefined) | "connected">;
-    scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+    scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
     closeDelay: NonNullable<NonNullable<string | number>>;
     openDelay: NonNullable<NonNullable<string | number>>;
     activatorProps: Record<string, any>;
@@ -4843,10 +7461,10 @@ declare const VSpeedDial: {
     minWidth: NonNullable<string | number>;
     eager: boolean;
     location: NonNullable<Anchor>;
-    locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+    locationStrategy: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
         updateLocation: (e: Event) => void;
     } | undefined) | "connected">;
-    scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+    scrollStrategy: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
     closeDelay: NonNullable<NonNullable<string | number>>;
     openDelay: NonNullable<NonNullable<string | number>>;
     activatorProps: Record<string, any>;
@@ -4943,26 +7561,26 @@ declare const VSpeedDial: {
     };
     activator: vue.PropType<Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined>;
     locationStrategy: Omit<{
-        type: vue.PropType<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        type: vue.PropType<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">;
         default: string;
         validator: (val: any) => boolean;
     }, "default" | "type"> & {
-        type: vue.PropType<NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        type: vue.PropType<NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">>;
-        default: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        default: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">;
     };
     scrollStrategy: Omit<{
-        type: vue.PropType<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        type: vue.PropType<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
         default: string;
         validator: (val: any) => boolean;
     }, "default" | "type"> & {
-        type: vue.PropType<NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">>;
-        default: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        type: vue.PropType<NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">>;
+        default: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
     };
     closeDelay: Omit<{
         type: vue.PropType<NonNullable<string | number>>;
@@ -5084,26 +7702,26 @@ declare const VSpeedDial: {
     };
     activator: vue.PropType<Element | (string & {}) | vue.ComponentPublicInstance | "parent" | undefined>;
     locationStrategy: Omit<{
-        type: vue.PropType<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        type: vue.PropType<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">;
         default: string;
         validator: (val: any) => boolean;
     }, "default" | "type"> & {
-        type: vue.PropType<NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        type: vue.PropType<NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">>;
-        default: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+        default: NonNullable<"static" | ((data: LocationStrategyData, props: StrategyProps$1, contentStyles: vue.Ref<Record<string, string>>) => {
             updateLocation: (e: Event) => void;
         } | undefined) | "connected">;
     };
     scrollStrategy: Omit<{
-        type: vue.PropType<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        type: vue.PropType<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
         default: string;
         validator: (val: any) => boolean;
     }, "default" | "type"> & {
-        type: vue.PropType<NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">>;
-        default: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+        type: vue.PropType<NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">>;
+        default: NonNullable<"close" | "none" | "block" | ((data: ScrollStrategyData, props: StrategyProps, scope: vue.EffectScope) => void) | "reposition">;
     };
     closeDelay: Omit<{
         type: vue.PropType<NonNullable<string | number>>;
@@ -5585,10 +8203,10 @@ declare const VTimePickerClock: {
         step: number;
         scrollable: boolean;
         ampm: boolean;
-        displayedValue: null;
     } & {
         color?: string | undefined;
         modelValue?: number | undefined;
+        displayedValue?: any;
         allowedValues?: ((value: number) => boolean) | undefined;
     } & {
         $children?: vue.VNodeChild | {
@@ -5616,10 +8234,10 @@ declare const VTimePickerClock: {
         step: number;
         scrollable: boolean;
         ampm: boolean;
-        displayedValue: null;
     } & {
         color?: string | undefined;
         modelValue?: number | undefined;
+        displayedValue?: any;
         allowedValues?: ((value: number) => boolean) | undefined;
     } & {
         $children?: vue.VNodeChild | {
@@ -5642,7 +8260,6 @@ declare const VTimePickerClock: {
         step: number;
         scrollable: boolean;
         ampm: boolean;
-        displayedValue: null;
     }, true, {}, vue.SlotsType<Partial<{
         default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
             [key: string]: any;
@@ -5665,10 +8282,10 @@ declare const VTimePickerClock: {
         step: number;
         scrollable: boolean;
         ampm: boolean;
-        displayedValue: null;
     } & {
         color?: string | undefined;
         modelValue?: number | undefined;
+        displayedValue?: any;
         allowedValues?: ((value: number) => boolean) | undefined;
     } & {
         $children?: vue.VNodeChild | {
@@ -5691,7 +8308,6 @@ declare const VTimePickerClock: {
         step: number;
         scrollable: boolean;
         ampm: boolean;
-        displayedValue: null;
     }>;
     __isFragment?: undefined;
     __isTeleport?: undefined;
@@ -5707,10 +8323,10 @@ declare const VTimePickerClock: {
     step: number;
     scrollable: boolean;
     ampm: boolean;
-    displayedValue: null;
 } & {
     color?: string | undefined;
     modelValue?: number | undefined;
+    displayedValue?: any;
     allowedValues?: ((value: number) => boolean) | undefined;
 } & {
     $children?: vue.VNodeChild | {
@@ -5736,7 +8352,6 @@ declare const VTimePickerClock: {
     step: number;
     scrollable: boolean;
     ampm: boolean;
-    displayedValue: null;
 }, {}, string, vue.SlotsType<Partial<{
     default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
         [key: string]: any;
@@ -5746,9 +8361,7 @@ declare const VTimePickerClock: {
     ampm: BooleanConstructor;
     color: StringConstructor;
     disabled: BooleanConstructor;
-    displayedValue: {
-        default: null;
-    };
+    displayedValue: null;
     double: BooleanConstructor;
     format: {
         type: FunctionConstructor;
@@ -5780,9 +8393,7 @@ declare const VTimePickerClock: {
     ampm: BooleanConstructor;
     color: StringConstructor;
     disabled: BooleanConstructor;
-    displayedValue: {
-        default: null;
-    };
+    displayedValue: null;
     double: BooleanConstructor;
     format: {
         type: FunctionConstructor;
@@ -7922,4 +10533,4 @@ declare const VTreeviewGroup: {
 }>>;
 type VTreeviewGroup = InstanceType<typeof VTreeviewGroup>;
 
-export { VCalendar, VCalendarDay, VCalendarHeader, VCalendarInterval, VCalendarIntervalEvent, VCalendarMonthDay, VConfirmEdit, VEmptyState, VFab, VNumberInput, VPicker, VPickerTitle, VSparkline, VSpeedDial, VTimePicker, VTimePickerClock, VTimePickerControls, VTreeview, VTreeviewGroup, VTreeviewItem };
+export { VCalendar, VCalendarDay, VCalendarHeader, VCalendarInterval, VCalendarIntervalEvent, VCalendarMonthDay, VConfirmEdit, VEmptyState, VFab, VNumberInput, VPicker, VPickerTitle, VSnackbarQueue, VSparkline, VSpeedDial, VTimePicker, VTimePickerClock, VTimePickerControls, VTreeview, VTreeviewGroup, VTreeviewItem };