@vuetify/nightly 3.7.18-dev.2025-03-19 → 3.7.18-dev.2025-03-20

package/lib/framework.d.ts

@@ -1,5 +1,6 @@
 import * as vue from 'vue';
-import { Ref, ComponentPublicInstance, DeepReadonly, FunctionalComponent, PropType, CSSProperties, App } from 'vue';
+import { Ref, ComponentPublicInstance, DeepReadonly, FunctionalComponent, ComponentPropsOptions, ExtractPropTypes, PropType, CSSProperties, EffectScope, nextTick, VNodeProps, App } from 'vue';
+import * as _vue_reactivity from '@vue/reactivity';
 
 interface LocaleMessages {
     [key: string]: LocaleMessages | string;
@@ -117,6 +118,29 @@ type InternalDateOptions = {
 type DateOptions = Partial<InternalDateOptions>;
 declare function useDate(): DateInstance;
 
+declare const block: readonly ["top", "bottom"];
+declare const inline: readonly ["start", "end", "left", "right"];
+type Tblock = typeof block[number];
+type Tinline = typeof inline[number];
+type Anchor = Tblock | Tinline | 'center' | 'center center' | `${Tblock} ${Tinline | 'center'}` | `${Tinline} ${Tblock | 'center'}`;
+
+declare class Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor({ x, y, width, height }: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    });
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+}
+
 type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
@@ -177,10 +201,25 @@ interface ThemeInstance {
 }
 declare function useTheme(): ThemeInstance;
 
+interface FilterPropsOptions<PropsOptions extends Readonly<ComponentPropsOptions>, Props = ExtractPropTypes<PropsOptions>> {
+    filterProps<T extends Partial<Props>, U extends Exclude<keyof Props, Exclude<keyof Props, keyof T>>>(props: T): Partial<Pick<T, U>>;
+}
 type JSXComponent<Props = any> = {
     new (): ComponentPublicInstance<Props>;
 } | FunctionalComponent<Props>;
 
+type ClassValue = any;
+
+declare function deepEqual(a: any, b: any): boolean;
+type SelectItemKey<T = Record<string, any>> = boolean | null | undefined | string | readonly (string | number)[] | ((item: T, fallback?: any) => any);
+type EventProp<T extends any[] = any[], F = (...args: T) => void> = F;
+declare const EventProp: <T extends any[] = any[]>() => PropType<EventProp<T>>;
+type TemplateRef = {
+    (target: Element | ComponentPublicInstance | null): void;
+    value: HTMLElement | ComponentPublicInstance | null | undefined;
+    readonly el: HTMLElement | undefined;
+};
+
 type IconValue = string | (string | [path: string, opacity: number])[] | JSXComponent;
 declare const IconValue: PropType<IconValue>;
 interface IconAliases {
@@ -350,6 +389,25 @@ declare function useLayout(): {
     mainStyles: Ref<CSSProperties, CSSProperties>;
 };
 
+/**
+ * - boolean: match without highlight
+ * - number: single match (index), length already known
+ * - []: single match (start, end)
+ * - [][]: multiple matches (start, end), shouldn't overlap
+ */
+type FilterMatchArraySingle = readonly [number, number];
+type FilterMatchArrayMultiple = readonly FilterMatchArraySingle[];
+type FilterMatchArray = FilterMatchArraySingle | FilterMatchArrayMultiple;
+type FilterMatch = boolean | number | FilterMatchArray;
+type FilterFunction = (value: string, query: string, item?: InternalItem) => FilterMatch;
+interface InternalItem<T = any> {
+    value: any;
+    raw: T;
+}
+
+type ValidationResult = string | boolean;
+type ValidationRule = ValidationResult | PromiseLike<ValidationResult> | ((value: any) => ValidationResult) | ((value: any) => PromiseLike<ValidationResult>);
+
 interface FieldValidationResult {
     id: number | string;
     errorMessages: string[];
@@ -361,6 +419,2025 @@ interface FormValidationResult {
 interface SubmitEventPromise extends SubmitEvent, Promise<FormValidationResult> {
 }
 
+type ActiveStrategyFunction = (data: {
+    id: unknown;
+    value: boolean;
+    activated: Set<unknown>;
+    children: Map<unknown, unknown[]>;
+    parents: Map<unknown, unknown>;
+    event?: Event;
+}) => Set<unknown>;
+type ActiveStrategyTransformInFunction = (v: unknown | undefined, children: Map<unknown, unknown[]>, parents: Map<unknown, unknown>) => Set<unknown>;
+type ActiveStrategyTransformOutFunction = (v: Set<unknown>, children: Map<unknown, unknown[]>, parents: Map<unknown, unknown>) => unknown;
+type ActiveStrategy = {
+    activate: ActiveStrategyFunction;
+    in: ActiveStrategyTransformInFunction;
+    out: ActiveStrategyTransformOutFunction;
+};
+
+type OpenStrategyFunction = (data: {
+    id: unknown;
+    value: boolean;
+    opened: Set<unknown>;
+    children: Map<unknown, unknown[]>;
+    parents: Map<unknown, unknown>;
+    event?: Event;
+}) => Set<unknown>;
+type OpenSelectStrategyFunction = (data: {
+    id: unknown;
+    value: boolean;
+    opened: Set<unknown>;
+    selected: Map<unknown, 'on' | 'off' | 'indeterminate'>;
+    children: Map<unknown, unknown[]>;
+    parents: Map<unknown, unknown>;
+    event?: Event;
+}) => Set<unknown> | null;
+type OpenStrategy = {
+    open: OpenStrategyFunction;
+    select: OpenSelectStrategyFunction;
+};
+
+type SelectStrategyFunction = (data: {
+    id: unknown;
+    value: boolean;
+    selected: Map<unknown, 'on' | 'off' | 'indeterminate'>;
+    children: Map<unknown, unknown[]>;
+    parents: Map<unknown, unknown>;
+    event?: Event;
+}) => Map<unknown, 'on' | 'off' | 'indeterminate'>;
+type SelectStrategyTransformInFunction = (v: readonly unknown[] | undefined, children: Map<unknown, unknown[]>, parents: Map<unknown, unknown>) => Map<unknown, 'on' | 'off' | 'indeterminate'>;
+type SelectStrategyTransformOutFunction = (v: Map<unknown, 'on' | 'off' | 'indeterminate'>, children: Map<unknown, unknown[]>, parents: Map<unknown, unknown>) => unknown[];
+type SelectStrategy = {
+    select: SelectStrategyFunction;
+    in: SelectStrategyTransformInFunction;
+    out: SelectStrategyTransformOutFunction;
+};
+
+type ExpandProps = {
+    expandOnClick: boolean;
+    expanded: readonly string[];
+    'onUpdate:expanded': ((value: any[]) => void) | undefined;
+};
+declare function provideExpanded(props: ExpandProps): {
+    expand: (item: DataTableItem, value: boolean) => void;
+    expanded: Ref<Set<string>, Set<string>> & {
+        readonly externalValue: readonly string[];
+    };
+    expandOnClick: Ref<boolean, boolean>;
+    isExpanded: (item: DataTableItem) => boolean;
+    toggleExpand: (item: DataTableItem) => void;
+};
+
+type SortItem = {
+    key: string;
+    order?: boolean | 'asc' | 'desc';
+};
+
+interface GroupableItem<T = any> {
+    type: 'item';
+    raw: T;
+}
+
+interface DataTableItemProps {
+    items: any[];
+    itemValue: SelectItemKey;
+    itemSelectable: SelectItemKey;
+    returnObject: boolean;
+}
+
+interface SelectableItem {
+    value: any;
+    selectable: boolean;
+}
+interface DataTableSelectStrategy {
+    showSelectAll: boolean;
+    allSelected: (data: {
+        allItems: SelectableItem[];
+        currentPage: SelectableItem[];
+    }) => SelectableItem[];
+    select: (data: {
+        items: SelectableItem[];
+        value: boolean;
+        selected: Set<unknown>;
+    }) => Set<unknown>;
+    selectAll: (data: {
+        value: boolean;
+        allItems: SelectableItem[];
+        currentPage: SelectableItem[];
+        selected: Set<unknown>;
+    }) => Set<unknown>;
+}
+type SelectionProps = Pick<DataTableItemProps, 'itemValue'> & {
+    modelValue: readonly any[];
+    selectStrategy: 'single' | 'page' | 'all';
+    valueComparator: typeof deepEqual;
+    'onUpdate:modelValue': EventProp<[any[]]> | undefined;
+};
+declare function provideSelection(props: SelectionProps, { allItems, currentPage }: {
+    allItems: Ref<SelectableItem[]>;
+    currentPage: Ref<SelectableItem[]>;
+}): {
+    toggleSelect: (item: SelectableItem, index?: number, event?: MouseEvent) => void;
+    select: (items: SelectableItem[], value: boolean) => void;
+    selectAll: (value: boolean) => void;
+    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+    isSomeSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+    someSelected: vue.ComputedRef<boolean>;
+    allSelected: vue.ComputedRef<boolean>;
+    showSelectAll: vue.ComputedRef<boolean>;
+    lastSelectedIndex: vue.ShallowRef<number | null, number | null>;
+    selectStrategy: vue.ComputedRef<DataTableSelectStrategy>;
+};
+
+type DataTableCompareFunction<T = any> = (a: T, b: T) => number | null;
+type DataTableHeader<T = Record<string, any>> = {
+    key?: 'data-table-group' | 'data-table-select' | 'data-table-expand' | (string & {});
+    value?: SelectItemKey<T>;
+    title?: string;
+    fixed?: boolean;
+    align?: 'start' | 'end' | 'center';
+    width?: number | string;
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    nowrap?: boolean;
+    headerProps?: Record<string, any>;
+    cellProps?: HeaderCellProps;
+    sortable?: boolean;
+    sort?: DataTableCompareFunction;
+    sortRaw?: DataTableCompareFunction;
+    filter?: FilterFunction;
+    children?: DataTableHeader<T>[];
+};
+type InternalDataTableHeader = Omit<DataTableHeader, 'key' | 'value' | 'children'> & {
+    key: string | null;
+    value: SelectItemKey | null;
+    sortable: boolean;
+    fixedOffset?: number;
+    lastFixed?: boolean;
+    nowrap?: boolean;
+    colspan?: number;
+    rowspan?: number;
+    children?: InternalDataTableHeader[];
+};
+interface DataTableItem<T = any> extends InternalItem<T>, GroupableItem<T>, SelectableItem {
+    key: any;
+    index: number;
+    columns: {
+        [key: string]: any;
+    };
+}
+type ItemSlotBase<T> = {
+    index: number;
+    item: T;
+    internalItem: DataTableItem<T>;
+    isExpanded: ReturnType<typeof provideExpanded>['isExpanded'];
+    toggleExpand: ReturnType<typeof provideExpanded>['toggleExpand'];
+    isSelected: ReturnType<typeof provideSelection>['isSelected'];
+    toggleSelect: ReturnType<typeof provideSelection>['toggleSelect'];
+};
+type ItemKeySlot<T> = ItemSlotBase<T> & {
+    value: any;
+    column: InternalDataTableHeader;
+};
+type RowPropsFunction<T> = (data: Pick<ItemKeySlot<T>, 'index' | 'item' | 'internalItem'>) => Record<string, any>;
+type CellPropsFunction<T> = (data: Pick<ItemKeySlot<T>, 'index' | 'item' | 'internalItem' | 'value' | 'column'>) => Record<string, any>;
+type HeaderCellProps = Record<string, any> | HeaderCellPropsFunction;
+type HeaderCellPropsFunction = (data: Pick<ItemKeySlot<any>, 'index' | 'item' | 'internalItem' | 'value'>) => Record<string, any>;
+
+interface LocationStrategyData {
+    contentEl: Ref<HTMLElement | undefined>;
+    target: Ref<HTMLElement | [x: number, y: number] | undefined>;
+    isActive: Ref<boolean>;
+    isRtl: Ref<boolean>;
+}
+type LocationStrategyFunction = (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 | LocationStrategyFunction;
+    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 ScrollStrategyFunction = (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 | ScrollStrategyFunction;
+    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 allowedVariants: readonly ["elevated", "flat", "tonal", "outlined", "text", "plain"];
+type Variant = typeof allowedVariants[number];
+
+declare const VSnackbar: {
+    new (...args: any[]): vue.CreateComponentPublicInstanceWithMixins<{
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        timeout: string | number;
+        vertical: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        tile: boolean;
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        multiLine: boolean;
+    } & {
+        offset?: string | number | number[] | undefined;
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        color?: string | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        opacity?: string | number | undefined;
+        position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+        text?: string | undefined;
+        target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+        class?: any;
+        theme?: string | undefined;
+        timer?: string | boolean | undefined;
+        rounded?: string | number | boolean | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentClass?: any;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            default?: (() => vue.VNodeChild) | undefined;
+            actions?: ((arg: {
+                isActive: Ref<boolean>;
+            }) => 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 | ((arg: {
+                isActive: Ref<boolean>;
+            }) => 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 | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:text"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: boolean) => any) | undefined;
+    }, Omit<Omit<{
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component;
+            });
+            zIndex: string | number;
+            style: vue.StyleValue;
+            eager: boolean;
+            disabled: boolean;
+            persistent: boolean;
+            modelValue: boolean;
+            locationStrategy: "connected" | "static" | LocationStrategyFunction;
+            scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }> & Omit<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component;
+            });
+            zIndex: string | number;
+            style: vue.StyleValue;
+            eager: boolean;
+            disabled: boolean;
+            persistent: boolean;
+            modelValue: boolean;
+            locationStrategy: "connected" | "static" | LocationStrategyFunction;
+            scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+            offset?: string | number | number[] | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            opacity?: string | number | undefined;
+            target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+            class?: any;
+            theme?: string | undefined;
+            closeDelay?: string | number | undefined;
+            openDelay?: string | number | undefined;
+            activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentClass?: any;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+            $children?: vue.VNodeChild | {
+                default?: ((arg: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                    targetRef: TemplateRef;
+                }) => vue.VNodeChild) | undefined;
+            } | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild);
+            'v-slots'?: {
+                default?: false | ((arg: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                    targetRef: TemplateRef;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+            "v-slot:default"?: false | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+            onAfterEnter?: (() => any) | undefined;
+            onAfterLeave?: (() => any) | undefined;
+            onKeydown?: ((e: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "style" | "eager" | "disabled" | "persistent" | "modelValue" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "scrim" | "_disableGlobalStack">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            default?: ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNode[]) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNode[]) | undefined;
+        }>;
+        $root: vue.ComponentPublicInstance | null;
+        $parent: vue.ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "keydown", e: KeyboardEvent) => void) & ((event: "update:modelValue", value: boolean) => void) & ((event: "click:outside", e: MouseEvent) => void) & ((event: "afterEnter") => void) & ((event: "afterLeave") => void);
+        $el: any;
+        $options: vue.ComponentOptionsBase<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component;
+            });
+            zIndex: string | number;
+            style: vue.StyleValue;
+            eager: boolean;
+            disabled: boolean;
+            persistent: boolean;
+            modelValue: boolean;
+            locationStrategy: "connected" | "static" | LocationStrategyFunction;
+            scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            offset?: string | number | number[] | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            opacity?: string | number | undefined;
+            target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+            class?: any;
+            theme?: string | undefined;
+            closeDelay?: string | number | undefined;
+            openDelay?: string | number | undefined;
+            activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentClass?: any;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } & {
+            $children?: vue.VNodeChild | {
+                default?: ((arg: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                    targetRef: TemplateRef;
+                }) => vue.VNodeChild) | undefined;
+            } | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild);
+            'v-slots'?: {
+                default?: false | ((arg: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                    targetRef: TemplateRef;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            onAfterEnter?: (() => any) | undefined;
+            onAfterLeave?: (() => any) | undefined;
+            onKeydown?: ((e: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        }, {
+            activatorEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scrimEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            target: vue.ComputedRef<HTMLElement | [x: number, y: number] | undefined>;
+            animateClick: () => void;
+            contentEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            globalTop: Readonly<Ref<boolean, boolean>>;
+            localTop: vue.ComputedRef<boolean>;
+            updateLocation: Ref<((e: Event) => void) | undefined, ((e: Event) => void) | undefined>;
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+            'click:outside': (e: MouseEvent) => true;
+            'update:modelValue': (value: boolean) => true;
+            keydown: (e: KeyboardEvent) => true;
+            afterEnter: () => true;
+            afterLeave: () => true;
+        }, string, {
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component;
+            });
+            zIndex: string | number;
+            style: vue.StyleValue;
+            eager: boolean;
+            disabled: boolean;
+            persistent: boolean;
+            modelValue: boolean;
+            locationStrategy: "connected" | "static" | LocationStrategyFunction;
+            scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }, {}, string, vue.SlotsType<Partial<{
+            default: (arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNode[];
+            activator: (arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNode[];
+        }>>, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
+    } & Readonly<{
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        persistent: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    }> & Omit<{
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        persistent: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    } & {
+        offset?: string | number | number[] | undefined;
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        opacity?: string | number | undefined;
+        target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+        class?: any;
+        theme?: string | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentClass?: any;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+            targetRef: TemplateRef;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        onAfterEnter?: (() => any) | undefined;
+        onAfterLeave?: (() => any) | undefined;
+        onKeydown?: ((e: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    }, "target" | "contentEl" | "activatorEl" | ("absolute" | "location" | "origin" | "transition" | "zIndex" | "style" | "eager" | "disabled" | "persistent" | "modelValue" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "scrim" | "_disableGlobalStack") | "scrimEl" | "animateClick" | "globalTop" | "localTop" | "updateLocation"> & vue.ShallowUnwrapRef<{
+        activatorEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scrimEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        target: vue.ComputedRef<HTMLElement | [x: number, y: number] | undefined>;
+        animateClick: () => void;
+        contentEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        globalTop: Readonly<Ref<boolean, boolean>>;
+        localTop: vue.ComputedRef<boolean>;
+        updateLocation: Ref<((e: Event) => void) | undefined, ((e: Event) => void) | undefined>;
+    }> & {} & vue.ComponentCustomProperties & {}, "offset" | "height" | "width" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "opacity" | "target" | "class" | "theme" | "onAfterEnter" | "onAfterLeave" | "onKeydown" | "$children" | "v-slots" | "v-slot:default" | keyof vue.VNodeProps | "onUpdate:modelValue" | "closeDelay" | "openDelay" | "activator" | "contentClass" | "contentProps" | "attach" | "onClick:outside" | ("absolute" | "location" | "origin" | "transition" | "zIndex" | "style" | "eager" | "disabled" | "persistent" | "modelValue" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "scrim" | "_disableGlobalStack") | "v-slot:activator">, `$${any}`> & {
+        _allExposed: {
+            activatorEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scrimEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            target: vue.ComputedRef<HTMLElement | [x: number, y: number] | undefined>;
+            animateClick: () => void;
+            contentEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            globalTop: Readonly<Ref<boolean, boolean>>;
+            localTop: vue.ComputedRef<boolean>;
+            updateLocation: Ref<((e: Event) => void) | undefined, ((e: Event) => void) | undefined>;
+        } | {};
+    }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        'update:modelValue': (v: boolean) => true;
+    }, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        timeout: string | number;
+        vertical: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        rounded: string | number | boolean;
+        tile: boolean;
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        multiLine: boolean;
+    }, true, {}, vue.SlotsType<Partial<{
+        activator: (arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNode[];
+        default: () => vue.VNode[];
+        actions: (arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNode[];
+        text: () => vue.VNode[];
+    }>>, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        timeout: string | number;
+        vertical: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        tile: boolean;
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        multiLine: boolean;
+    } & {
+        offset?: string | number | number[] | undefined;
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        color?: string | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        opacity?: string | number | undefined;
+        position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+        text?: string | undefined;
+        target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+        class?: any;
+        theme?: string | undefined;
+        timer?: string | boolean | undefined;
+        rounded?: string | number | boolean | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentClass?: any;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            default?: (() => vue.VNodeChild) | undefined;
+            actions?: ((arg: {
+                isActive: Ref<boolean>;
+            }) => 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 | ((arg: {
+                isActive: Ref<boolean>;
+            }) => 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 | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:text"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: boolean) => any) | undefined;
+    }, Omit<Omit<{
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component;
+            });
+            zIndex: string | number;
+            style: vue.StyleValue;
+            eager: boolean;
+            disabled: boolean;
+            persistent: boolean;
+            modelValue: boolean;
+            locationStrategy: "connected" | "static" | LocationStrategyFunction;
+            scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }> & Omit<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component;
+            });
+            zIndex: string | number;
+            style: vue.StyleValue;
+            eager: boolean;
+            disabled: boolean;
+            persistent: boolean;
+            modelValue: boolean;
+            locationStrategy: "connected" | "static" | LocationStrategyFunction;
+            scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+            offset?: string | number | number[] | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            opacity?: string | number | undefined;
+            target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+            class?: any;
+            theme?: string | undefined;
+            closeDelay?: string | number | undefined;
+            openDelay?: string | number | undefined;
+            activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentClass?: any;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+            $children?: vue.VNodeChild | {
+                default?: ((arg: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                    targetRef: TemplateRef;
+                }) => vue.VNodeChild) | undefined;
+            } | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild);
+            'v-slots'?: {
+                default?: false | ((arg: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                    targetRef: TemplateRef;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+            "v-slot:default"?: false | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+            onAfterEnter?: (() => any) | undefined;
+            onAfterLeave?: (() => any) | undefined;
+            onKeydown?: ((e: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "style" | "eager" | "disabled" | "persistent" | "modelValue" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "scrim" | "_disableGlobalStack">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            default?: ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNode[]) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNode[]) | undefined;
+        }>;
+        $root: vue.ComponentPublicInstance | null;
+        $parent: vue.ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "keydown", e: KeyboardEvent) => void) & ((event: "update:modelValue", value: boolean) => void) & ((event: "click:outside", e: MouseEvent) => void) & ((event: "afterEnter") => void) & ((event: "afterLeave") => void);
+        $el: any;
+        $options: vue.ComponentOptionsBase<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component;
+            });
+            zIndex: string | number;
+            style: vue.StyleValue;
+            eager: boolean;
+            disabled: boolean;
+            persistent: boolean;
+            modelValue: boolean;
+            locationStrategy: "connected" | "static" | LocationStrategyFunction;
+            scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        } & {
+            offset?: string | number | number[] | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            opacity?: string | number | undefined;
+            target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+            class?: any;
+            theme?: string | undefined;
+            closeDelay?: string | number | undefined;
+            openDelay?: string | number | undefined;
+            activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentClass?: any;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } & {
+            $children?: vue.VNodeChild | {
+                default?: ((arg: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                    targetRef: TemplateRef;
+                }) => vue.VNodeChild) | undefined;
+            } | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild);
+            'v-slots'?: {
+                default?: false | ((arg: {
+                    isActive: Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                activator?: false | ((arg: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                    targetRef: TemplateRef;
+                }) => vue.VNodeChild) | undefined;
+            } | undefined;
+        } & {
+            "v-slot:default"?: false | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            "v-slot:activator"?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+        } & {
+            onAfterEnter?: (() => any) | undefined;
+            onAfterLeave?: (() => any) | undefined;
+            onKeydown?: ((e: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        }, {
+            activatorEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scrimEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            target: vue.ComputedRef<HTMLElement | [x: number, y: number] | undefined>;
+            animateClick: () => void;
+            contentEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            globalTop: Readonly<Ref<boolean, boolean>>;
+            localTop: vue.ComputedRef<boolean>;
+            updateLocation: Ref<((e: Event) => void) | undefined, ((e: Event) => void) | undefined>;
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+            'click:outside': (e: MouseEvent) => true;
+            'update:modelValue': (value: boolean) => true;
+            keydown: (e: KeyboardEvent) => true;
+            afterEnter: () => true;
+            afterLeave: () => true;
+        }, string, {
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component;
+            });
+            zIndex: string | number;
+            style: vue.StyleValue;
+            eager: boolean;
+            disabled: boolean;
+            persistent: boolean;
+            modelValue: boolean;
+            locationStrategy: "connected" | "static" | LocationStrategyFunction;
+            scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            scrim: string | boolean;
+            _disableGlobalStack: boolean;
+        }, {}, string, vue.SlotsType<Partial<{
+            default: (arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNode[];
+            activator: (arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNode[];
+        }>>, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
+    } & Readonly<{
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        persistent: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    }> & Omit<{
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        persistent: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    } & {
+        offset?: string | number | number[] | undefined;
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        opacity?: string | number | undefined;
+        target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+        class?: any;
+        theme?: string | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentClass?: any;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+            targetRef: TemplateRef;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        onAfterEnter?: (() => any) | undefined;
+        onAfterLeave?: (() => any) | undefined;
+        onKeydown?: ((e: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    }, "target" | "contentEl" | "activatorEl" | ("absolute" | "location" | "origin" | "transition" | "zIndex" | "style" | "eager" | "disabled" | "persistent" | "modelValue" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "scrim" | "_disableGlobalStack") | "scrimEl" | "animateClick" | "globalTop" | "localTop" | "updateLocation"> & vue.ShallowUnwrapRef<{
+        activatorEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scrimEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        target: vue.ComputedRef<HTMLElement | [x: number, y: number] | undefined>;
+        animateClick: () => void;
+        contentEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        globalTop: Readonly<Ref<boolean, boolean>>;
+        localTop: vue.ComputedRef<boolean>;
+        updateLocation: Ref<((e: Event) => void) | undefined, ((e: Event) => void) | undefined>;
+    }> & {} & vue.ComponentCustomProperties & {}, "offset" | "height" | "width" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "opacity" | "target" | "class" | "theme" | "onAfterEnter" | "onAfterLeave" | "onKeydown" | "$children" | "v-slots" | "v-slot:default" | keyof vue.VNodeProps | "onUpdate:modelValue" | "closeDelay" | "openDelay" | "activator" | "contentClass" | "contentProps" | "attach" | "onClick:outside" | ("absolute" | "location" | "origin" | "transition" | "zIndex" | "style" | "eager" | "disabled" | "persistent" | "modelValue" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "scrim" | "_disableGlobalStack") | "v-slot:activator">, `$${any}`> & {
+        _allExposed: {
+            activatorEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            scrimEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            target: vue.ComputedRef<HTMLElement | [x: number, y: number] | undefined>;
+            animateClick: () => void;
+            contentEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            globalTop: Readonly<Ref<boolean, boolean>>;
+            localTop: vue.ComputedRef<boolean>;
+            updateLocation: Ref<((e: Event) => void) | undefined, ((e: Event) => void) | undefined>;
+        } | {};
+    }, {}, {}, {}, {
+        variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        timeout: string | number;
+        vertical: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        rounded: string | number | boolean;
+        tile: boolean;
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        multiLine: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & vue.ComponentOptionsBase<{
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+    absolute: boolean;
+    location: Anchor;
+    origin: "auto" | Anchor | "overlap";
+    transition: string | boolean | (vue.TransitionProps & {
+        component?: vue.Component;
+    });
+    zIndex: string | number;
+    style: vue.StyleValue;
+    eager: boolean;
+    disabled: boolean;
+    timeout: string | number;
+    vertical: boolean;
+    modelValue: boolean;
+    locationStrategy: "connected" | "static" | LocationStrategyFunction;
+    tile: boolean;
+    activatorProps: Record<string, any>;
+    openOnHover: boolean;
+    closeOnContentClick: boolean;
+    closeOnBack: boolean;
+    contained: boolean;
+    multiLine: boolean;
+} & {
+    offset?: string | number | number[] | undefined;
+    height?: string | number | undefined;
+    width?: string | number | undefined;
+    color?: string | undefined;
+    maxHeight?: string | number | undefined;
+    maxWidth?: string | number | undefined;
+    minHeight?: string | number | undefined;
+    minWidth?: string | number | undefined;
+    opacity?: string | number | undefined;
+    position?: "fixed" | "absolute" | "relative" | "static" | "sticky" | undefined;
+    text?: string | undefined;
+    target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+    class?: any;
+    theme?: string | undefined;
+    timer?: string | boolean | undefined;
+    rounded?: string | number | boolean | undefined;
+    closeDelay?: string | number | undefined;
+    openDelay?: string | number | undefined;
+    activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+    openOnClick?: boolean | undefined;
+    openOnFocus?: boolean | undefined;
+    contentClass?: any;
+    contentProps?: any;
+    attach?: string | boolean | Element | undefined;
+} & {
+    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+        activator?: ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+        default?: (() => vue.VNodeChild) | undefined;
+        actions?: ((arg: {
+            isActive: Ref<boolean>;
+        }) => 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 | ((arg: {
+            isActive: Ref<boolean>;
+        }) => 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 | ((arg: {
+        isActive: Ref<boolean>;
+    }) => vue.VNodeChild) | undefined;
+    "v-slot:text"?: false | (() => vue.VNodeChild) | undefined;
+} & {
+    "onUpdate:modelValue"?: ((v: boolean) => any) | undefined;
+}, Omit<Omit<{
+    $: vue.ComponentInternalInstance;
+    $data: {};
+    $props: Partial<{
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        persistent: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    }> & Omit<{
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        persistent: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+        offset?: string | number | number[] | undefined;
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        opacity?: string | number | undefined;
+        target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+        class?: any;
+        theme?: string | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentClass?: any;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+        $children?: vue.VNodeChild | {
+            default?: ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+        "v-slot:default"?: false | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+            targetRef: TemplateRef;
+        }) => vue.VNodeChild) | undefined;
+        onAfterEnter?: (() => any) | undefined;
+        onAfterLeave?: (() => any) | undefined;
+        onKeydown?: ((e: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "style" | "eager" | "disabled" | "persistent" | "modelValue" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "scrim" | "_disableGlobalStack">;
+    $attrs: {
+        [x: string]: unknown;
+    };
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        default?: ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNode[]) | undefined;
+        activator?: ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+            targetRef: TemplateRef;
+        }) => vue.VNode[]) | undefined;
+    }>;
+    $root: vue.ComponentPublicInstance | null;
+    $parent: vue.ComponentPublicInstance | null;
+    $host: Element | null;
+    $emit: ((event: "keydown", e: KeyboardEvent) => void) & ((event: "update:modelValue", value: boolean) => void) & ((event: "click:outside", e: MouseEvent) => void) & ((event: "afterEnter") => void) & ((event: "afterLeave") => void);
+    $el: any;
+    $options: vue.ComponentOptionsBase<{
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        persistent: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+        activatorProps: Record<string, any>;
+        openOnHover: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    } & {
+        offset?: string | number | number[] | undefined;
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        opacity?: string | number | undefined;
+        target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+        class?: any;
+        theme?: string | undefined;
+        closeDelay?: string | number | undefined;
+        openDelay?: string | number | undefined;
+        activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+        openOnClick?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        contentClass?: any;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isActive: Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((arg: {
+                isActive: boolean;
+                props: Record<string, any>;
+                targetRef: TemplateRef;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:activator"?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+            targetRef: TemplateRef;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        onAfterEnter?: (() => any) | undefined;
+        onAfterLeave?: (() => any) | undefined;
+        onKeydown?: ((e: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+    }, {
+        activatorEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scrimEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        target: vue.ComputedRef<HTMLElement | [x: number, y: number] | undefined>;
+        animateClick: () => void;
+        contentEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        globalTop: Readonly<Ref<boolean, boolean>>;
+        localTop: vue.ComputedRef<boolean>;
+        updateLocation: Ref<((e: Event) => void) | undefined, ((e: Event) => void) | undefined>;
+    }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        'click:outside': (e: MouseEvent) => true;
+        'update:modelValue': (value: boolean) => true;
+        keydown: (e: KeyboardEvent) => true;
+        afterEnter: () => true;
+        afterLeave: () => true;
+    }, string, {
+        absolute: boolean;
+        location: Anchor;
+        origin: "auto" | Anchor | "overlap";
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        });
+        zIndex: string | number;
+        style: vue.StyleValue;
+        eager: boolean;
+        disabled: boolean;
+        persistent: boolean;
+        modelValue: boolean;
+        locationStrategy: "connected" | "static" | LocationStrategyFunction;
+        scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+        activatorProps: Record<string, any>;
+        openOnClick: boolean;
+        openOnHover: boolean;
+        openOnFocus: boolean;
+        closeOnContentClick: boolean;
+        closeOnBack: boolean;
+        contained: boolean;
+        noClickAnimation: boolean;
+        scrim: string | boolean;
+        _disableGlobalStack: boolean;
+    }, {}, string, vue.SlotsType<Partial<{
+        default: (arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNode[];
+        activator: (arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+            targetRef: TemplateRef;
+        }) => vue.VNode[];
+    }>>, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
+        beforeCreate?: (() => void) | (() => void)[];
+        created?: (() => void) | (() => void)[];
+        beforeMount?: (() => void) | (() => void)[];
+        mounted?: (() => void) | (() => void)[];
+        beforeUpdate?: (() => void) | (() => void)[];
+        updated?: (() => void) | (() => void)[];
+        activated?: (() => void) | (() => void)[];
+        deactivated?: (() => void) | (() => void)[];
+        beforeDestroy?: (() => void) | (() => void)[];
+        beforeUnmount?: (() => void) | (() => void)[];
+        destroyed?: (() => void) | (() => void)[];
+        unmounted?: (() => void) | (() => void)[];
+        renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+        renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+        errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
+    };
+    $forceUpdate: () => void;
+    $nextTick: typeof nextTick;
+    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
+} & Readonly<{
+    absolute: boolean;
+    location: Anchor;
+    origin: "auto" | Anchor | "overlap";
+    transition: string | boolean | (vue.TransitionProps & {
+        component?: vue.Component;
+    });
+    zIndex: string | number;
+    style: vue.StyleValue;
+    eager: boolean;
+    disabled: boolean;
+    persistent: boolean;
+    modelValue: boolean;
+    locationStrategy: "connected" | "static" | LocationStrategyFunction;
+    scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+    activatorProps: Record<string, any>;
+    openOnClick: boolean;
+    openOnHover: boolean;
+    openOnFocus: boolean;
+    closeOnContentClick: boolean;
+    closeOnBack: boolean;
+    contained: boolean;
+    noClickAnimation: boolean;
+    scrim: string | boolean;
+    _disableGlobalStack: boolean;
+}> & Omit<{
+    absolute: boolean;
+    location: Anchor;
+    origin: "auto" | Anchor | "overlap";
+    transition: string | boolean | (vue.TransitionProps & {
+        component?: vue.Component;
+    });
+    zIndex: string | number;
+    style: vue.StyleValue;
+    eager: boolean;
+    disabled: boolean;
+    persistent: boolean;
+    modelValue: boolean;
+    locationStrategy: "connected" | "static" | LocationStrategyFunction;
+    scrollStrategy: "none" | "block" | "close" | ScrollStrategyFunction | "reposition";
+    activatorProps: Record<string, any>;
+    openOnHover: boolean;
+    closeOnContentClick: boolean;
+    closeOnBack: boolean;
+    contained: boolean;
+    noClickAnimation: boolean;
+    scrim: string | boolean;
+    _disableGlobalStack: boolean;
+} & {
+    offset?: string | number | number[] | undefined;
+    height?: string | number | undefined;
+    width?: string | number | undefined;
+    maxHeight?: string | number | undefined;
+    maxWidth?: string | number | undefined;
+    minHeight?: string | number | undefined;
+    minWidth?: string | number | undefined;
+    opacity?: string | number | undefined;
+    target?: Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined;
+    class?: any;
+    theme?: string | undefined;
+    closeDelay?: string | number | undefined;
+    openDelay?: string | number | undefined;
+    activator?: Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined;
+    openOnClick?: boolean | undefined;
+    openOnFocus?: boolean | undefined;
+    contentClass?: any;
+    contentProps?: any;
+    attach?: string | boolean | Element | undefined;
+} & {
+    $children?: vue.VNodeChild | {
+        default?: ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        activator?: ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+            targetRef: TemplateRef;
+        }) => vue.VNodeChild) | undefined;
+    } | ((arg: {
+        isActive: Ref<boolean>;
+    }) => vue.VNodeChild);
+    'v-slots'?: {
+        default?: false | ((arg: {
+            isActive: Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        activator?: false | ((arg: {
+            isActive: boolean;
+            props: Record<string, any>;
+            targetRef: TemplateRef;
+        }) => vue.VNodeChild) | undefined;
+    } | undefined;
+} & {
+    "v-slot:default"?: false | ((arg: {
+        isActive: Ref<boolean>;
+    }) => vue.VNodeChild) | undefined;
+    "v-slot:activator"?: false | ((arg: {
+        isActive: boolean;
+        props: Record<string, any>;
+        targetRef: TemplateRef;
+    }) => vue.VNodeChild) | undefined;
+} & {
+    onAfterEnter?: (() => any) | undefined;
+    onAfterLeave?: (() => any) | undefined;
+    onKeydown?: ((e: KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+}, "target" | "contentEl" | "activatorEl" | ("absolute" | "location" | "origin" | "transition" | "zIndex" | "style" | "eager" | "disabled" | "persistent" | "modelValue" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "scrim" | "_disableGlobalStack") | "scrimEl" | "animateClick" | "globalTop" | "localTop" | "updateLocation"> & vue.ShallowUnwrapRef<{
+    activatorEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    scrimEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    target: vue.ComputedRef<HTMLElement | [x: number, y: number] | undefined>;
+    animateClick: () => void;
+    contentEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    globalTop: Readonly<Ref<boolean, boolean>>;
+    localTop: vue.ComputedRef<boolean>;
+    updateLocation: Ref<((e: Event) => void) | undefined, ((e: Event) => void) | undefined>;
+}> & {} & vue.ComponentCustomProperties & {}, "offset" | "height" | "width" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "opacity" | "target" | "class" | "theme" | "onAfterEnter" | "onAfterLeave" | "onKeydown" | "$children" | "v-slots" | "v-slot:default" | keyof vue.VNodeProps | "onUpdate:modelValue" | "closeDelay" | "openDelay" | "activator" | "contentClass" | "contentProps" | "attach" | "onClick:outside" | ("absolute" | "location" | "origin" | "transition" | "zIndex" | "style" | "eager" | "disabled" | "persistent" | "modelValue" | "locationStrategy" | "scrollStrategy" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "closeOnBack" | "contained" | "noClickAnimation" | "scrim" | "_disableGlobalStack") | "v-slot:activator">, `$${any}`> & {
+    _allExposed: {
+        activatorEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scrimEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        target: vue.ComputedRef<HTMLElement | [x: number, y: number] | undefined>;
+        animateClick: () => void;
+        contentEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        globalTop: Readonly<Ref<boolean, boolean>>;
+        localTop: vue.ComputedRef<boolean>;
+        updateLocation: Ref<((e: Event) => void) | undefined, ((e: Event) => void) | undefined>;
+    } | {};
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (v: boolean) => true;
+}, string, {
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
+    absolute: boolean;
+    location: Anchor;
+    origin: "auto" | Anchor | "overlap";
+    transition: string | boolean | (vue.TransitionProps & {
+        component?: vue.Component;
+    });
+    zIndex: string | number;
+    style: vue.StyleValue;
+    eager: boolean;
+    disabled: boolean;
+    timeout: string | number;
+    vertical: boolean;
+    modelValue: boolean;
+    locationStrategy: "connected" | "static" | LocationStrategyFunction;
+    rounded: string | number | boolean;
+    tile: boolean;
+    activatorProps: Record<string, any>;
+    openOnClick: boolean;
+    openOnHover: boolean;
+    openOnFocus: boolean;
+    closeOnContentClick: boolean;
+    closeOnBack: boolean;
+    contained: boolean;
+    multiLine: boolean;
+}, {}, string, vue.SlotsType<Partial<{
+    activator: (arg: {
+        isActive: boolean;
+        props: Record<string, any>;
+    }) => vue.VNode[];
+    default: () => vue.VNode[];
+    actions: (arg: {
+        isActive: Ref<boolean>;
+    }) => vue.VNode[];
+    text: () => vue.VNode[];
+}>>, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    offset: vue.PropType<StrategyProps$1["offset"]>;
+    absolute: BooleanConstructor;
+    location: {
+        type: vue.PropType<StrategyProps$1["location"]>;
+        default: string;
+    };
+    origin: {
+        type: vue.PropType<StrategyProps$1["origin"]>;
+        default: string;
+    };
+    height: (StringConstructor | NumberConstructor)[];
+    width: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    opacity: (StringConstructor | NumberConstructor)[];
+    transition: Omit<{
+        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        })>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        })>;
+    };
+    zIndex: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    target: vue.PropType<Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined>;
+    eager: BooleanConstructor;
+    disabled: BooleanConstructor;
+    class: vue.PropType<ClassValue>;
+    theme: StringConstructor;
+    modelValue: BooleanConstructor;
+    locationStrategy: {
+        type: vue.PropType<StrategyProps$1["locationStrategy"]>;
+        default: string;
+        validator: (val: any) => boolean;
+    };
+    closeDelay: (StringConstructor | NumberConstructor)[];
+    openDelay: (StringConstructor | NumberConstructor)[];
+    activator: vue.PropType<Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined>;
+    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;
+    contentClass: null;
+    contentProps: null;
+    attach: vue.PropType<boolean | string | Element>;
+    color: StringConstructor;
+    variant: {
+        type: vue.PropType<Variant>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    rounded: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        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<{
+    offset: vue.PropType<StrategyProps$1["offset"]>;
+    absolute: BooleanConstructor;
+    location: {
+        type: vue.PropType<StrategyProps$1["location"]>;
+        default: string;
+    };
+    origin: {
+        type: vue.PropType<StrategyProps$1["origin"]>;
+        default: string;
+    };
+    height: (StringConstructor | NumberConstructor)[];
+    width: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    opacity: (StringConstructor | NumberConstructor)[];
+    transition: Omit<{
+        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        })>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component;
+        })>;
+    };
+    zIndex: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    target: vue.PropType<Element | "cursor" | "parent" | (string & {}) | vue.ComponentPublicInstance | [x: number, y: number] | undefined>;
+    eager: BooleanConstructor;
+    disabled: BooleanConstructor;
+    class: vue.PropType<ClassValue>;
+    theme: StringConstructor;
+    modelValue: BooleanConstructor;
+    locationStrategy: {
+        type: vue.PropType<StrategyProps$1["locationStrategy"]>;
+        default: string;
+        validator: (val: any) => boolean;
+    };
+    closeDelay: (StringConstructor | NumberConstructor)[];
+    openDelay: (StringConstructor | NumberConstructor)[];
+    activator: vue.PropType<Element | "parent" | (string & {}) | vue.ComponentPublicInstance | undefined>;
+    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;
+    contentClass: null;
+    contentProps: null;
+    attach: vue.PropType<boolean | string | Element>;
+    color: StringConstructor;
+    variant: {
+        type: vue.PropType<Variant>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    rounded: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        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 SnackbarMessage = string | Omit<VSnackbar['$props'], 'modelValue' | 'onUpdate:modelValue' | 'activator' | 'activatorProps' | 'closeDelay' | 'openDelay' | 'openOnClick' | 'openOnFocus' | 'openOnHover' | '$children' | 'v-slots' | `v-slot:${string}` | keyof VNodeProps>;
+
 interface VuetifyOptions {
     aliases?: Record<string, any>;
     blueprint?: Blueprint;
@@ -453,7 +2530,7 @@ declare namespace createVuetify {
 }
 declare const version: string;
 
-export { type Blueprint, type DateInstance, DateModule, type DateOptions, type DefaultsInstance, type DisplayBreakpoint, type DisplayInstance, type DisplayThresholds, type GoToInstance, type IconAliases, type IconOptions, type IconProps, type IconSet, type JSXComponent, type LocaleInstance, type LocaleMessages, type LocaleOptions, type RtlInstance, type RtlOptions, type SubmitEventPromise, type ThemeDefinition, type ThemeInstance, type VuetifyOptions, createVuetify, useDate, useDefaults, useDisplay, useGoTo, useLayout, useLocale, useRtl, useTheme, version };
+export { type ActiveStrategy, type Anchor, type Blueprint, type CellPropsFunction as DataTableCellPropsFunction, type DataTableCompareFunction, type DataTableHeader, type HeaderCellPropsFunction as DataTableHeaderCellPropsFunction, type RowPropsFunction as DataTableRowPropsFunction, type SortItem as DataTableSortItem, type DateInstance, DateModule, type DateOptions, type DefaultsInstance, type DisplayBreakpoint, type DisplayInstance, type DisplayThresholds, type FilterFunction, type FilterMatch, type GoToInstance, type IconAliases, type IconOptions, type IconProps, type IconSet, type InternalItem, type JSXComponent, type LocaleInstance, type LocaleMessages, type LocaleOptions, type LocationStrategyFunction, type OpenStrategy, type RtlInstance, type RtlOptions, type ScrollStrategyFunction, type SelectStrategy, type SnackbarMessage as SnackbarQueueMessage, type SubmitEventPromise, type ThemeDefinition, type ThemeInstance, type ValidationRule, type VuetifyOptions, createVuetify, useDate, useDefaults, useDisplay, useGoTo, useLayout, useLocale, useRtl, useTheme, version };
 
 /* eslint-disable local-rules/sort-imports */
 
@@ -490,48 +2567,41 @@ declare module 'vue' {
     $children?: VNodeChild
   }
   export interface GlobalComponents {
-    VAutocomplete: typeof import('vuetify/components')['VAutocomplete']
+    VApp: typeof import('vuetify/components')['VApp']
+    VAlert: typeof import('vuetify/components')['VAlert']
+    VAlertTitle: typeof import('vuetify/components')['VAlertTitle']
     VAppBar: typeof import('vuetify/components')['VAppBar']
     VAppBarNavIcon: typeof import('vuetify/components')['VAppBarNavIcon']
     VAppBarTitle: typeof import('vuetify/components')['VAppBarTitle']
-    VBadge: typeof import('vuetify/components')['VBadge']
-    VApp: typeof import('vuetify/components')['VApp']
-    VBottomNavigation: typeof import('vuetify/components')['VBottomNavigation']
     VAvatar: typeof import('vuetify/components')['VAvatar']
-    VBottomSheet: typeof import('vuetify/components')['VBottomSheet']
-    VAlert: typeof import('vuetify/components')['VAlert']
-    VAlertTitle: typeof import('vuetify/components')['VAlertTitle']
     VBanner: typeof import('vuetify/components')['VBanner']
     VBannerActions: typeof import('vuetify/components')['VBannerActions']
     VBannerText: typeof import('vuetify/components')['VBannerText']
+    VBottomSheet: typeof import('vuetify/components')['VBottomSheet']
+    VAutocomplete: typeof import('vuetify/components')['VAutocomplete']
+    VBadge: typeof import('vuetify/components')['VBadge']
     VBreadcrumbs: typeof import('vuetify/components')['VBreadcrumbs']
     VBreadcrumbsItem: typeof import('vuetify/components')['VBreadcrumbsItem']
     VBreadcrumbsDivider: typeof import('vuetify/components')['VBreadcrumbsDivider']
-    VBtn: typeof import('vuetify/components')['VBtn']
-    VBtnGroup: typeof import('vuetify/components')['VBtnGroup']
     VBtnToggle: typeof import('vuetify/components')['VBtnToggle']
-    VCarousel: typeof import('vuetify/components')['VCarousel']
-    VCarouselItem: typeof import('vuetify/components')['VCarouselItem']
+    VBtnGroup: typeof import('vuetify/components')['VBtnGroup']
     VCard: typeof import('vuetify/components')['VCard']
     VCardActions: typeof import('vuetify/components')['VCardActions']
     VCardItem: typeof import('vuetify/components')['VCardItem']
     VCardSubtitle: typeof import('vuetify/components')['VCardSubtitle']
     VCardText: typeof import('vuetify/components')['VCardText']
     VCardTitle: typeof import('vuetify/components')['VCardTitle']
+    VBottomNavigation: typeof import('vuetify/components')['VBottomNavigation']
+    VCarousel: typeof import('vuetify/components')['VCarousel']
+    VCarouselItem: typeof import('vuetify/components')['VCarouselItem']
+    VBtn: typeof import('vuetify/components')['VBtn']
+    VChip: typeof import('vuetify/components')['VChip']
     VCheckbox: typeof import('vuetify/components')['VCheckbox']
     VCheckboxBtn: typeof import('vuetify/components')['VCheckboxBtn']
+    VCode: typeof import('vuetify/components')['VCode']
     VChipGroup: typeof import('vuetify/components')['VChipGroup']
     VColorPicker: typeof import('vuetify/components')['VColorPicker']
     VCombobox: typeof import('vuetify/components')['VCombobox']
-    VChip: typeof import('vuetify/components')['VChip']
-    VCode: typeof import('vuetify/components')['VCode']
-    VDataTable: typeof import('vuetify/components')['VDataTable']
-    VDataTableHeaders: typeof import('vuetify/components')['VDataTableHeaders']
-    VDataTableFooter: typeof import('vuetify/components')['VDataTableFooter']
-    VDataTableRows: typeof import('vuetify/components')['VDataTableRows']
-    VDataTableRow: typeof import('vuetify/components')['VDataTableRow']
-    VDataTableVirtual: typeof import('vuetify/components')['VDataTableVirtual']
-    VDataTableServer: typeof import('vuetify/components')['VDataTableServer']
     VCounter: typeof import('vuetify/components')['VCounter']
     VDatePicker: typeof import('vuetify/components')['VDatePicker']
     VDatePickerControls: typeof import('vuetify/components')['VDatePickerControls']
@@ -539,30 +2609,37 @@ declare module 'vue' {
     VDatePickerMonth: typeof import('vuetify/components')['VDatePickerMonth']
     VDatePickerMonths: typeof import('vuetify/components')['VDatePickerMonths']
     VDatePickerYears: typeof import('vuetify/components')['VDatePickerYears']
-    VEmptyState: typeof import('vuetify/components')['VEmptyState']
-    VFab: typeof import('vuetify/components')['VFab']
+    VDataTable: typeof import('vuetify/components')['VDataTable']
+    VDataTableHeaders: typeof import('vuetify/components')['VDataTableHeaders']
+    VDataTableFooter: typeof import('vuetify/components')['VDataTableFooter']
+    VDataTableRows: typeof import('vuetify/components')['VDataTableRows']
+    VDataTableRow: typeof import('vuetify/components')['VDataTableRow']
+    VDataTableVirtual: typeof import('vuetify/components')['VDataTableVirtual']
+    VDataTableServer: typeof import('vuetify/components')['VDataTableServer']
     VDialog: typeof import('vuetify/components')['VDialog']
     VDivider: typeof import('vuetify/components')['VDivider']
+    VEmptyState: typeof import('vuetify/components')['VEmptyState']
     VExpansionPanels: typeof import('vuetify/components')['VExpansionPanels']
     VExpansionPanel: typeof import('vuetify/components')['VExpansionPanel']
     VExpansionPanelText: typeof import('vuetify/components')['VExpansionPanelText']
     VExpansionPanelTitle: typeof import('vuetify/components')['VExpansionPanelTitle']
+    VFooter: typeof import('vuetify/components')['VFooter']
+    VFab: typeof import('vuetify/components')['VFab']
+    VImg: typeof import('vuetify/components')['VImg']
+    VInfiniteScroll: typeof import('vuetify/components')['VInfiniteScroll']
     VField: typeof import('vuetify/components')['VField']
     VFieldLabel: typeof import('vuetify/components')['VFieldLabel']
-    VFileInput: typeof import('vuetify/components')['VFileInput']
     VIcon: typeof import('vuetify/components')['VIcon']
     VComponentIcon: typeof import('vuetify/components')['VComponentIcon']
     VSvgIcon: typeof import('vuetify/components')['VSvgIcon']
     VLigatureIcon: typeof import('vuetify/components')['VLigatureIcon']
     VClassIcon: typeof import('vuetify/components')['VClassIcon']
-    VInfiniteScroll: typeof import('vuetify/components')['VInfiniteScroll']
-    VFooter: typeof import('vuetify/components')['VFooter']
-    VImg: typeof import('vuetify/components')['VImg']
+    VLabel: typeof import('vuetify/components')['VLabel']
+    VFileInput: typeof import('vuetify/components')['VFileInput']
     VInput: typeof import('vuetify/components')['VInput']
     VItemGroup: typeof import('vuetify/components')['VItemGroup']
     VItem: typeof import('vuetify/components')['VItem']
     VKbd: typeof import('vuetify/components')['VKbd']
-    VLabel: typeof import('vuetify/components')['VLabel']
     VList: typeof import('vuetify/components')['VList']
     VListGroup: typeof import('vuetify/components')['VListGroup']
     VListImg: typeof import('vuetify/components')['VListImg']
@@ -573,25 +2650,25 @@ declare module 'vue' {
     VListItemTitle: typeof import('vuetify/components')['VListItemTitle']
     VListSubheader: typeof import('vuetify/components')['VListSubheader']
     VMain: typeof import('vuetify/components')['VMain']
+    VMessages: typeof import('vuetify/components')['VMessages']
     VMenu: typeof import('vuetify/components')['VMenu']
     VNavigationDrawer: typeof import('vuetify/components')['VNavigationDrawer']
     VNumberInput: typeof import('vuetify/components')['VNumberInput']
-    VMessages: typeof import('vuetify/components')['VMessages']
-    VPagination: typeof import('vuetify/components')['VPagination']
-    VProgressLinear: typeof import('vuetify/components')['VProgressLinear']
     VOverlay: typeof import('vuetify/components')['VOverlay']
-    VOtpInput: typeof import('vuetify/components')['VOtpInput']
     VProgressCircular: typeof import('vuetify/components')['VProgressCircular']
-    VSelectionControlGroup: typeof import('vuetify/components')['VSelectionControlGroup']
+    VOtpInput: typeof import('vuetify/components')['VOtpInput']
+    VPagination: typeof import('vuetify/components')['VPagination']
+    VProgressLinear: typeof import('vuetify/components')['VProgressLinear']
     VRadioGroup: typeof import('vuetify/components')['VRadioGroup']
-    VRating: typeof import('vuetify/components')['VRating']
+    VSelect: typeof import('vuetify/components')['VSelect']
+    VSelectionControlGroup: typeof import('vuetify/components')['VSelectionControlGroup']
     VSelectionControl: typeof import('vuetify/components')['VSelectionControl']
     VSheet: typeof import('vuetify/components')['VSheet']
-    VSelect: typeof import('vuetify/components')['VSelect']
-    VSkeletonLoader: typeof import('vuetify/components')['VSkeletonLoader']
-    VSlider: typeof import('vuetify/components')['VSlider']
+    VRating: typeof import('vuetify/components')['VRating']
     VSlideGroup: typeof import('vuetify/components')['VSlideGroup']
     VSlideGroupItem: typeof import('vuetify/components')['VSlideGroupItem']
+    VSkeletonLoader: typeof import('vuetify/components')['VSkeletonLoader']
+    VSlider: typeof import('vuetify/components')['VSlider']
     VSnackbar: typeof import('vuetify/components')['VSnackbar']
     VSwitch: typeof import('vuetify/components')['VSwitch']
     VStepper: typeof import('vuetify/components')['VStepper']
@@ -604,39 +2681,39 @@ declare module 'vue' {
     VTabs: typeof import('vuetify/components')['VTabs']
     VTabsWindow: typeof import('vuetify/components')['VTabsWindow']
     VTabsWindowItem: typeof import('vuetify/components')['VTabsWindowItem']
-    VTextarea: typeof import('vuetify/components')['VTextarea']
-    VTextField: typeof import('vuetify/components')['VTextField']
+    VSystemBar: typeof import('vuetify/components')['VSystemBar']
     VTable: typeof import('vuetify/components')['VTable']
     VTimeline: typeof import('vuetify/components')['VTimeline']
     VTimelineItem: typeof import('vuetify/components')['VTimelineItem']
-    VToolbar: typeof import('vuetify/components')['VToolbar']
-    VToolbarTitle: typeof import('vuetify/components')['VToolbarTitle']
-    VToolbarItems: typeof import('vuetify/components')['VToolbarItems']
-    VSystemBar: typeof import('vuetify/components')['VSystemBar']
+    VTextarea: typeof import('vuetify/components')['VTextarea']
+    VTextField: typeof import('vuetify/components')['VTextField']
     VTooltip: typeof import('vuetify/components')['VTooltip']
     VWindow: typeof import('vuetify/components')['VWindow']
     VWindowItem: typeof import('vuetify/components')['VWindowItem']
+    VToolbar: typeof import('vuetify/components')['VToolbar']
+    VToolbarTitle: typeof import('vuetify/components')['VToolbarTitle']
+    VToolbarItems: typeof import('vuetify/components')['VToolbarItems']
     VConfirmEdit: typeof import('vuetify/components')['VConfirmEdit']
-    VDataIterator: typeof import('vuetify/components')['VDataIterator']
     VDefaultsProvider: typeof import('vuetify/components')['VDefaultsProvider']
+    VDataIterator: typeof import('vuetify/components')['VDataIterator']
+    VHover: typeof import('vuetify/components')['VHover']
     VForm: typeof import('vuetify/components')['VForm']
     VContainer: typeof import('vuetify/components')['VContainer']
     VCol: typeof import('vuetify/components')['VCol']
     VRow: typeof import('vuetify/components')['VRow']
     VSpacer: typeof import('vuetify/components')['VSpacer']
-    VHover: typeof import('vuetify/components')['VHover']
-    VLazy: typeof import('vuetify/components')['VLazy']
-    VLocaleProvider: typeof import('vuetify/components')['VLocaleProvider']
     VLayout: typeof import('vuetify/components')['VLayout']
     VLayoutItem: typeof import('vuetify/components')['VLayoutItem']
+    VLazy: typeof import('vuetify/components')['VLazy']
+    VLocaleProvider: typeof import('vuetify/components')['VLocaleProvider']
     VNoSsr: typeof import('vuetify/components')['VNoSsr']
     VParallax: typeof import('vuetify/components')['VParallax']
     VRadio: typeof import('vuetify/components')['VRadio']
     VRangeSlider: typeof import('vuetify/components')['VRangeSlider']
-    VSnackbarQueue: typeof import('vuetify/components')['VSnackbarQueue']
+    VResponsive: typeof import('vuetify/components')['VResponsive']
     VSparkline: typeof import('vuetify/components')['VSparkline']
+    VSnackbarQueue: typeof import('vuetify/components')['VSnackbarQueue']
     VSpeedDial: typeof import('vuetify/components')['VSpeedDial']
-    VResponsive: typeof import('vuetify/components')['VResponsive']
     VThemeProvider: typeof import('vuetify/components')['VThemeProvider']
     VValidation: typeof import('vuetify/components')['VValidation']
     VVirtualScroll: typeof import('vuetify/components')['VVirtualScroll']
@@ -664,17 +2741,17 @@ declare module 'vue' {
     VCalendarMonthDay: typeof import('vuetify/labs/components')['VCalendarMonthDay']
     VPicker: typeof import('vuetify/labs/components')['VPicker']
     VPickerTitle: typeof import('vuetify/labs/components')['VPickerTitle']
-    VFileUpload: typeof import('vuetify/labs/components')['VFileUpload']
-    VFileUploadItem: typeof import('vuetify/labs/components')['VFileUploadItem']
-    VTimePicker: typeof import('vuetify/labs/components')['VTimePicker']
-    VTimePickerClock: typeof import('vuetify/labs/components')['VTimePickerClock']
-    VTimePickerControls: typeof import('vuetify/labs/components')['VTimePickerControls']
-    VTreeview: typeof import('vuetify/labs/components')['VTreeview']
-    VTreeviewItem: typeof import('vuetify/labs/components')['VTreeviewItem']
-    VTreeviewGroup: typeof import('vuetify/labs/components')['VTreeviewGroup']
     VStepperVertical: typeof import('vuetify/labs/components')['VStepperVertical']
     VStepperVerticalItem: typeof import('vuetify/labs/components')['VStepperVerticalItem']
     VStepperVerticalActions: typeof import('vuetify/labs/components')['VStepperVerticalActions']
+    VTreeview: typeof import('vuetify/labs/components')['VTreeview']
+    VTreeviewItem: typeof import('vuetify/labs/components')['VTreeviewItem']
+    VTreeviewGroup: typeof import('vuetify/labs/components')['VTreeviewGroup']
+    VTimePicker: typeof import('vuetify/labs/components')['VTimePicker']
+    VTimePickerClock: typeof import('vuetify/labs/components')['VTimePickerClock']
+    VTimePickerControls: typeof import('vuetify/labs/components')['VTimePickerControls']
+    VFileUpload: typeof import('vuetify/labs/components')['VFileUpload']
+    VFileUploadItem: typeof import('vuetify/labs/components')['VFileUploadItem']
     VDateInput: typeof import('vuetify/labs/components')['VDateInput']
     VPullToRefresh: typeof import('vuetify/labs/components')['VPullToRefresh']
   }