@vuetify/nightly 3.0.0-beta.3 → 3.0.0-beta.4

package/lib/components/index.d.ts

@@ -32,13 +32,17 @@ interface OnColors {
     'on-info': string;
 }
 interface ThemeInstance {
-    isDisabled: boolean;
-    name: Ref<string>;
-    themes: Ref<Record<string, InternalThemeDefinition>>;
+    readonly isDisabled: boolean;
+    readonly themes: Ref<Record<string, InternalThemeDefinition>>;
+    readonly name: Readonly<Ref<string>>;
     readonly current: DeepReadonly<Ref<InternalThemeDefinition>>;
     readonly computedThemes: DeepReadonly<Ref<Record<string, InternalThemeDefinition>>>;
-    themeClasses: Readonly<Ref<string | undefined>>;
-    styles: Readonly<Ref<string>>;
+    readonly themeClasses: Readonly<Ref<string | undefined>>;
+    readonly styles: Readonly<Ref<string>>;
+    readonly global: {
+        readonly name: Ref<string>;
+        readonly current: DeepReadonly<Ref<InternalThemeDefinition>>;
+    };
 }
 
 declare const VApp: vue.DefineComponent<{
@@ -333,12 +337,12 @@ declare type ContextualType = typeof allowedTypes[number];
 declare const VAlert: vue.DefineComponent<{
     color: StringConstructor;
     variant: Omit<{
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: {
@@ -403,12 +407,12 @@ declare const VAlert: vue.DefineComponent<{
 }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
     color: StringConstructor;
     variant: Omit<{
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: {
@@ -476,7 +480,7 @@ declare const VAlert: vue.DefineComponent<{
     rounded: string | number | boolean;
     prominent: boolean;
     density: "default" | "compact" | "comfortable" | null;
-    variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     modelValue: boolean;
     closable: boolean;
     closeIcon: IconValue;
@@ -558,6 +562,7 @@ declare const VInput: {
                 default: () => never[];
             };
             modelValue: null;
+            validationValue: null;
             density: {
                 type: PropType<"default" | "compact" | "comfortable" | null>;
                 default: string;
@@ -615,6 +620,7 @@ declare const VInput: {
                 default: () => never[];
             };
             modelValue: null;
+            validationValue: null;
             density: {
                 type: PropType<"default" | "compact" | "comfortable" | null>;
                 default: string;
@@ -694,6 +700,7 @@ declare const VInput: {
             default: () => never[];
         };
         modelValue: null;
+        validationValue: null;
         density: {
             type: PropType<"default" | "compact" | "comfortable" | null>;
             default: string;
@@ -745,6 +752,7 @@ declare const VInput: {
         default: () => never[];
     };
     modelValue: null;
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -819,7 +827,7 @@ declare const VField: {
             active: boolean;
             loading: boolean;
             disabled: boolean;
-            variant: "filled" | "outlined" | "plain" | "contained" | "underlined";
+            variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
             focused: boolean;
             clearable: boolean;
             clearIcon: IconValue;
@@ -847,7 +855,7 @@ declare const VField: {
             reverse: BooleanConstructor;
             singleLine: BooleanConstructor;
             variant: {
-                type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+                type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
                 default: string;
                 validator: (v: any) => boolean;
             };
@@ -899,7 +907,7 @@ declare const VField: {
             reverse: BooleanConstructor;
             singleLine: BooleanConstructor;
             variant: {
-                type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+                type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
                 default: string;
                 validator: (v: any) => boolean;
             };
@@ -929,7 +937,7 @@ declare const VField: {
             active: boolean;
             loading: boolean;
             disabled: boolean;
-            variant: "filled" | "outlined" | "plain" | "contained" | "underlined";
+            variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
             focused: boolean;
             clearable: boolean;
             clearIcon: IconValue;
@@ -977,7 +985,7 @@ declare const VField: {
         reverse: BooleanConstructor;
         singleLine: BooleanConstructor;
         variant: {
-            type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+            type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
             default: string;
             validator: (v: any) => boolean;
         };
@@ -1021,7 +1029,7 @@ declare const VField: {
     reverse: BooleanConstructor;
     singleLine: BooleanConstructor;
     variant: {
-        type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+        type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -1051,7 +1059,7 @@ declare const VField: {
     active: boolean;
     loading: boolean;
     disabled: boolean;
-    variant: "filled" | "outlined" | "plain" | "contained" | "underlined";
+    variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
     focused: boolean;
     clearable: boolean;
     clearIcon: IconValue;
@@ -1067,6 +1075,40 @@ declare const VField: {
 });
 declare type VField = InstanceType<typeof VField>;
 
+interface ScrollStrategyData {
+    root: Ref<HTMLElement | undefined>;
+    contentEl: Ref<HTMLElement | undefined>;
+    activatorEl: Ref<HTMLElement | undefined>;
+    isActive: Ref<boolean>;
+    updateLocation: Ref<((e: Event) => void) | undefined>;
+}
+
+interface LocationStrategyData {
+    contentEl: Ref<HTMLElement | undefined>;
+    activatorEl: Ref<HTMLElement | undefined>;
+    isActive: Ref<boolean>;
+}
+declare const locationStrategies: {
+    static: typeof staticLocationStrategy;
+    connected: typeof connectedLocationStrategy;
+};
+interface StrategyProps {
+    locationStrategy: keyof typeof locationStrategies | ((data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>) => undefined | {
+        updateLocation: (e: Event) => void;
+    });
+    location: Anchor;
+    origin: Anchor | 'auto' | 'overlap';
+    offset?: number | string;
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    minWidth?: number | string;
+}
+declare function staticLocationStrategy(): void;
+declare function connectedLocationStrategy(data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>): {
+    updateLocation: () => void;
+};
+
 interface InternalItem {
     title: string;
     value: any;
@@ -1076,7 +1118,7 @@ interface InternalItem {
         value: any;
     };
     children?: InternalItem[];
-    originalItem: any;
+    raw: any;
 }
 
 /**
@@ -1102,6 +1144,7 @@ declare const VAutocomplete: {
             transition: string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
             });
+            menu: boolean;
             eager: boolean;
             noDataText: string;
             itemTitle: SelectItemKey;
@@ -1161,10 +1204,176 @@ declare const VAutocomplete: {
             eager: BooleanConstructor;
             hideNoData: BooleanConstructor;
             hideSelected: BooleanConstructor;
+            menu: BooleanConstructor;
             menuIcon: {
                 type: vue.PropType<IconValue>;
                 default: string;
             };
+            menuProps: {
+                type: vue.PropType<Partial<{
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: vue.PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: vue.PropType<HTMLElement>;
+                        }>>, {}>;
+                    };
+                    modelValue: boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    transition: Omit<{
+                        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    }, "type" | "default"> & {
+                        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: vue.PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: vue.PropType<HTMLElement>;
+                            }>>, {}>;
+                        }>;
+                        default: string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: vue.PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: vue.PropType<HTMLElement>;
+                            }>>, {}>;
+                        };
+                    };
+                    modelValue: BooleanConstructor;
+                    id: StringConstructor;
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+                    absolute: boolean;
+                    location: Anchor;
+                    origin: "auto" | Anchor | "overlap";
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    });
+                    zIndex: string | number;
+                    eager: boolean;
+                    disabled: boolean;
+                    modelValue: boolean;
+                    activatorProps: Record<string, any>;
+                    openOnClick: boolean;
+                    openOnHover: boolean;
+                    openOnFocus: boolean;
+                    closeOnContentClick: boolean;
+                    locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined);
+                    scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                    contained: boolean;
+                    noClickAnimation: boolean;
+                    persistent: boolean;
+                    closeOnBack: boolean;
+                    scrim: string | boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    eager: BooleanConstructor;
+                    transition: {
+                        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    };
+                    theme: StringConstructor;
+                    scrollStrategy: {
+                        type: vue.PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    locationStrategy: {
+                        type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                            updateLocation: (e: Event) => void;
+                        } | undefined)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    location: {
+                        type: vue.PropType<Anchor>;
+                        default: string;
+                    };
+                    origin: {
+                        type: vue.PropType<"auto" | Anchor | "overlap">;
+                        default: string;
+                    };
+                    offset: (StringConstructor | NumberConstructor)[];
+                    height: (StringConstructor | NumberConstructor)[];
+                    maxHeight: (StringConstructor | NumberConstructor)[];
+                    maxWidth: (StringConstructor | NumberConstructor)[];
+                    minHeight: (StringConstructor | NumberConstructor)[];
+                    minWidth: (StringConstructor | NumberConstructor)[];
+                    width: (StringConstructor | NumberConstructor)[];
+                    closeDelay: (StringConstructor | NumberConstructor)[];
+                    openDelay: (StringConstructor | NumberConstructor)[];
+                    activator: vue.PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+                    activatorProps: {
+                        type: vue.PropType<Record<string, any>>;
+                        default: () => {};
+                    };
+                    openOnClick: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    openOnHover: BooleanConstructor;
+                    openOnFocus: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    closeOnContentClick: BooleanConstructor;
+                    absolute: BooleanConstructor;
+                    attach: vue.PropType<string | boolean | Element>;
+                    closeOnBack: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    contained: BooleanConstructor;
+                    contentClass: null;
+                    contentProps: null;
+                    disabled: BooleanConstructor;
+                    noClickAnimation: BooleanConstructor;
+                    modelValue: BooleanConstructor;
+                    persistent: BooleanConstructor;
+                    scrim: {
+                        type: (StringConstructor | BooleanConstructor)[];
+                        default: boolean;
+                    };
+                    zIndex: {
+                        type: (StringConstructor | NumberConstructor)[];
+                        default: number;
+                    };
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    onAfterLeave?: (() => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+            };
             modelValue: {
                 type: null;
                 default: () => never[];
@@ -1212,8 +1421,9 @@ declare const VAutocomplete: {
             'no-data': [];
         }>>>> & {
             "onClick:clear"?: ((e: MouseEvent) => any) | undefined;
+            "onUpdate:menu"?: ((val: boolean) => any) | undefined;
             "onUpdate:search"?: ((val: any) => any) | undefined;
-        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "eager" | "noDataText" | "itemTitle" | "itemValue" | "itemChildren" | "itemProps" | "chips" | "closableChips" | "hideNoData" | "hideSelected" | "menuIcon" | "openOnClear" | "filterMode" | "noFilter" | "filterKeys">;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "menu" | "eager" | "noDataText" | "itemTitle" | "itemValue" | "itemChildren" | "itemProps" | "chips" | "closableChips" | "hideNoData" | "hideSelected" | "menuIcon" | "openOnClear" | "filterMode" | "noFilter" | "filterKeys">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -1225,7 +1435,7 @@ declare const VAutocomplete: {
         }>;
         $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
         $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
-        $emit: ((event: "click:clear", e: MouseEvent) => void) & ((event: "update:search", val: any) => void);
+        $emit: ((event: "click:clear", e: MouseEvent) => void) & ((event: "update:menu", val: boolean) => void) & ((event: "update:search", val: any) => void);
         $el: any;
         $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
             transition: Omit<{
@@ -1271,10 +1481,176 @@ declare const VAutocomplete: {
             eager: BooleanConstructor;
             hideNoData: BooleanConstructor;
             hideSelected: BooleanConstructor;
+            menu: BooleanConstructor;
             menuIcon: {
                 type: vue.PropType<IconValue>;
                 default: string;
             };
+            menuProps: {
+                type: vue.PropType<Partial<{
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: vue.PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: vue.PropType<HTMLElement>;
+                        }>>, {}>;
+                    };
+                    modelValue: boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    transition: Omit<{
+                        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    }, "type" | "default"> & {
+                        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: vue.PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: vue.PropType<HTMLElement>;
+                            }>>, {}>;
+                        }>;
+                        default: string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: vue.PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: vue.PropType<HTMLElement>;
+                            }>>, {}>;
+                        };
+                    };
+                    modelValue: BooleanConstructor;
+                    id: StringConstructor;
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+                    absolute: boolean;
+                    location: Anchor;
+                    origin: "auto" | Anchor | "overlap";
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    });
+                    zIndex: string | number;
+                    eager: boolean;
+                    disabled: boolean;
+                    modelValue: boolean;
+                    activatorProps: Record<string, any>;
+                    openOnClick: boolean;
+                    openOnHover: boolean;
+                    openOnFocus: boolean;
+                    closeOnContentClick: boolean;
+                    locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined);
+                    scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                    contained: boolean;
+                    noClickAnimation: boolean;
+                    persistent: boolean;
+                    closeOnBack: boolean;
+                    scrim: string | boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    eager: BooleanConstructor;
+                    transition: {
+                        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    };
+                    theme: StringConstructor;
+                    scrollStrategy: {
+                        type: vue.PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    locationStrategy: {
+                        type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                            updateLocation: (e: Event) => void;
+                        } | undefined)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    location: {
+                        type: vue.PropType<Anchor>;
+                        default: string;
+                    };
+                    origin: {
+                        type: vue.PropType<"auto" | Anchor | "overlap">;
+                        default: string;
+                    };
+                    offset: (StringConstructor | NumberConstructor)[];
+                    height: (StringConstructor | NumberConstructor)[];
+                    maxHeight: (StringConstructor | NumberConstructor)[];
+                    maxWidth: (StringConstructor | NumberConstructor)[];
+                    minHeight: (StringConstructor | NumberConstructor)[];
+                    minWidth: (StringConstructor | NumberConstructor)[];
+                    width: (StringConstructor | NumberConstructor)[];
+                    closeDelay: (StringConstructor | NumberConstructor)[];
+                    openDelay: (StringConstructor | NumberConstructor)[];
+                    activator: vue.PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+                    activatorProps: {
+                        type: vue.PropType<Record<string, any>>;
+                        default: () => {};
+                    };
+                    openOnClick: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    openOnHover: BooleanConstructor;
+                    openOnFocus: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    closeOnContentClick: BooleanConstructor;
+                    absolute: BooleanConstructor;
+                    attach: vue.PropType<string | boolean | Element>;
+                    closeOnBack: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    contained: BooleanConstructor;
+                    contentClass: null;
+                    contentProps: null;
+                    disabled: BooleanConstructor;
+                    noClickAnimation: BooleanConstructor;
+                    modelValue: BooleanConstructor;
+                    persistent: BooleanConstructor;
+                    scrim: {
+                        type: (StringConstructor | BooleanConstructor)[];
+                        default: boolean;
+                    };
+                    zIndex: {
+                        type: (StringConstructor | NumberConstructor)[];
+                        default: number;
+                    };
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    onAfterLeave?: (() => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+            };
             modelValue: {
                 type: null;
                 default: () => never[];
@@ -1322,15 +1698,18 @@ declare const VAutocomplete: {
             'no-data': [];
         }>>>> & {
             "onClick:clear"?: ((e: MouseEvent) => any) | undefined;
+            "onUpdate:menu"?: ((val: boolean) => any) | undefined;
             "onUpdate:search"?: ((val: any) => any) | undefined;
         }, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
             'click:clear': (e: MouseEvent) => boolean;
             'update:search': (val: any) => boolean;
             'update:modelValue': (val: any) => boolean;
+            'update:menu': (val: boolean) => boolean;
         }, "multiple" | "items" | "update:modelValue" | "modelValue" | "returnObject">, string, {
             transition: string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
             });
+            menu: boolean;
             eager: boolean;
             noDataText: string;
             itemTitle: SelectItemKey;
@@ -1410,10 +1789,176 @@ declare const VAutocomplete: {
         eager: BooleanConstructor;
         hideNoData: BooleanConstructor;
         hideSelected: BooleanConstructor;
+        menu: BooleanConstructor;
         menuIcon: {
             type: vue.PropType<IconValue>;
             default: string;
         };
+        menuProps: {
+            type: vue.PropType<Partial<{
+                transition: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                }) | {
+                    readonly component: vue.DefineComponent<{
+                        target: vue.PropType<HTMLElement>;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                        target: vue.PropType<HTMLElement>;
+                    }>>, {}>;
+                };
+                modelValue: boolean;
+            }> & Omit<Readonly<vue.ExtractPropTypes<{
+                transition: Omit<{
+                    type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    })>;
+                    default: string;
+                    validator: (val: unknown) => boolean;
+                }, "type" | "default"> & {
+                    type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: vue.PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: vue.PropType<HTMLElement>;
+                        }>>, {}>;
+                    }>;
+                    default: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: vue.PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: vue.PropType<HTMLElement>;
+                        }>>, {}>;
+                    };
+                };
+                modelValue: BooleanConstructor;
+                id: StringConstructor;
+            } & SlotsToProps<MakeSlots<{
+                default: [{
+                    isActive: vue.Ref<boolean>;
+                }];
+                activator: [{
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }];
+            }>>>> & {
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+                absolute: boolean;
+                location: Anchor;
+                origin: "auto" | Anchor | "overlap";
+                transition: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                });
+                zIndex: string | number;
+                eager: boolean;
+                disabled: boolean;
+                modelValue: boolean;
+                activatorProps: Record<string, any>;
+                openOnClick: boolean;
+                openOnHover: boolean;
+                openOnFocus: boolean;
+                closeOnContentClick: boolean;
+                locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined);
+                scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                contained: boolean;
+                noClickAnimation: boolean;
+                persistent: boolean;
+                closeOnBack: boolean;
+                scrim: string | boolean;
+            }> & Omit<Readonly<vue.ExtractPropTypes<{
+                eager: BooleanConstructor;
+                transition: {
+                    type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    })>;
+                    default: string;
+                    validator: (val: unknown) => boolean;
+                };
+                theme: StringConstructor;
+                scrollStrategy: {
+                    type: vue.PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                    default: string;
+                    validator: (val: any) => boolean;
+                };
+                locationStrategy: {
+                    type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined)>;
+                    default: string;
+                    validator: (val: any) => boolean;
+                };
+                location: {
+                    type: vue.PropType<Anchor>;
+                    default: string;
+                };
+                origin: {
+                    type: vue.PropType<"auto" | Anchor | "overlap">;
+                    default: string;
+                };
+                offset: (StringConstructor | NumberConstructor)[];
+                height: (StringConstructor | NumberConstructor)[];
+                maxHeight: (StringConstructor | NumberConstructor)[];
+                maxWidth: (StringConstructor | NumberConstructor)[];
+                minHeight: (StringConstructor | NumberConstructor)[];
+                minWidth: (StringConstructor | NumberConstructor)[];
+                width: (StringConstructor | NumberConstructor)[];
+                closeDelay: (StringConstructor | NumberConstructor)[];
+                openDelay: (StringConstructor | NumberConstructor)[];
+                activator: vue.PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+                activatorProps: {
+                    type: vue.PropType<Record<string, any>>;
+                    default: () => {};
+                };
+                openOnClick: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                openOnHover: BooleanConstructor;
+                openOnFocus: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                closeOnContentClick: BooleanConstructor;
+                absolute: BooleanConstructor;
+                attach: vue.PropType<string | boolean | Element>;
+                closeOnBack: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                contained: BooleanConstructor;
+                contentClass: null;
+                contentProps: null;
+                disabled: BooleanConstructor;
+                noClickAnimation: BooleanConstructor;
+                modelValue: BooleanConstructor;
+                persistent: BooleanConstructor;
+                scrim: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                zIndex: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: number;
+                };
+            } & SlotsToProps<MakeSlots<{
+                default: [{
+                    isActive: vue.Ref<boolean>;
+                }];
+                activator: [{
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }];
+            }>>>> & {
+                onAfterLeave?: (() => any) | undefined;
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+        };
         modelValue: {
             type: null;
             default: () => never[];
@@ -1461,6 +2006,7 @@ declare const VAutocomplete: {
         'no-data': [];
     }>>>> & {
         "onClick:clear"?: ((e: MouseEvent) => any) | undefined;
+        "onUpdate:menu"?: ((val: boolean) => any) | undefined;
         "onUpdate:search"?: ((val: any) => any) | undefined;
     } & vue.ShallowUnwrapRef<any> & {} & vue.ComponentCustomProperties;
     __isFragment?: undefined;
@@ -1510,79 +2056,248 @@ declare const VAutocomplete: {
     eager: BooleanConstructor;
     hideNoData: BooleanConstructor;
     hideSelected: BooleanConstructor;
+    menu: BooleanConstructor;
     menuIcon: {
         type: vue.PropType<IconValue>;
         default: string;
     };
-    modelValue: {
-        type: null;
-        default: () => never[];
-    };
-    multiple: BooleanConstructor;
-    noDataText: {
-        type: StringConstructor;
-        default: string;
-    };
-    openOnClear: BooleanConstructor;
-    customFilter: vue.PropType<FilterFunction>;
-    customKeyFilter: vue.PropType<FilterKeyFunctions>;
-    filterKeys: {
-        type: vue.PropType<(string & {}) | FilterKeys>;
-        default: (string & {}) | FilterKeys;
-    };
-    filterMode: {
-        type: vue.PropType<FilterMode>;
-        default: string;
-    };
-    noFilter: BooleanConstructor;
-    search: StringConstructor;
-}, "multiple" | "items" | "onUpdate:modelValue" | "modelValue" | "returnObject"> & SlotsToProps<MakeSlots<{
-    default: [VInputSlot];
-    prepend: [VInputSlot];
-    append: [VInputSlot];
-    details: [VInputSlot];
-}> & MakeSlots<{
-    clear: [];
-    prependInner: [DefaultInputSlot & VInputSlot];
-    appendInner: [DefaultInputSlot & VInputSlot];
-    label: [DefaultInputSlot & VInputSlot];
-    loader: [LoaderSlotProps];
-    default: [VFieldSlot];
-}> & MakeSlots<{
-    chip: [{
-        item: unknown;
-        index: number;
-        props: Record<string, unknown>;
-    }];
-    selection: [{
-        item: unknown;
-        index: number;
-    }];
-    'no-data': [];
-}>>>> & {
-    "onClick:clear"?: ((e: MouseEvent) => any) | undefined;
-    "onUpdate:search"?: ((val: any) => any) | undefined;
-}, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
-    'click:clear': (e: MouseEvent) => boolean;
-    'update:search': (val: any) => boolean;
-    'update:modelValue': (val: any) => boolean;
-}, "multiple" | "items" | "update:modelValue" | "modelValue" | "returnObject">, string, {
-    transition: string | boolean | (vue.TransitionProps & {
-        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-    });
-    eager: boolean;
-    noDataText: string;
-    itemTitle: SelectItemKey;
-    itemValue: SelectItemKey;
-    itemChildren: SelectItemKey;
-    itemProps: SelectItemKey;
-    chips: boolean;
-    closableChips: boolean;
-    hideNoData: boolean;
-    hideSelected: boolean;
-    menuIcon: IconValue;
-    openOnClear: boolean;
-    filterMode: FilterMode;
+    menuProps: {
+        type: vue.PropType<Partial<{
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            }) | {
+                readonly component: vue.DefineComponent<{
+                    target: vue.PropType<HTMLElement>;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                    target: vue.PropType<HTMLElement>;
+                }>>, {}>;
+            };
+            modelValue: boolean;
+        }> & Omit<Readonly<vue.ExtractPropTypes<{
+            transition: Omit<{
+                type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                })>;
+                default: string;
+                validator: (val: unknown) => boolean;
+            }, "type" | "default"> & {
+                type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                }) | {
+                    readonly component: vue.DefineComponent<{
+                        target: vue.PropType<HTMLElement>;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                        target: vue.PropType<HTMLElement>;
+                    }>>, {}>;
+                }>;
+                default: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                }) | {
+                    readonly component: vue.DefineComponent<{
+                        target: vue.PropType<HTMLElement>;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                        target: vue.PropType<HTMLElement>;
+                    }>>, {}>;
+                };
+            };
+            modelValue: BooleanConstructor;
+            id: StringConstructor;
+        } & SlotsToProps<MakeSlots<{
+            default: [{
+                isActive: vue.Ref<boolean>;
+            }];
+            activator: [{
+                isActive: boolean;
+                props: Record<string, any>;
+            }];
+        }>>>> & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            closeOnBack: boolean;
+            scrim: string | boolean;
+        }> & Omit<Readonly<vue.ExtractPropTypes<{
+            eager: BooleanConstructor;
+            transition: {
+                type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                })>;
+                default: string;
+                validator: (val: unknown) => boolean;
+            };
+            theme: StringConstructor;
+            scrollStrategy: {
+                type: vue.PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                default: string;
+                validator: (val: any) => boolean;
+            };
+            locationStrategy: {
+                type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined)>;
+                default: string;
+                validator: (val: any) => boolean;
+            };
+            location: {
+                type: vue.PropType<Anchor>;
+                default: string;
+            };
+            origin: {
+                type: vue.PropType<"auto" | Anchor | "overlap">;
+                default: string;
+            };
+            offset: (StringConstructor | NumberConstructor)[];
+            height: (StringConstructor | NumberConstructor)[];
+            maxHeight: (StringConstructor | NumberConstructor)[];
+            maxWidth: (StringConstructor | NumberConstructor)[];
+            minHeight: (StringConstructor | NumberConstructor)[];
+            minWidth: (StringConstructor | NumberConstructor)[];
+            width: (StringConstructor | NumberConstructor)[];
+            closeDelay: (StringConstructor | NumberConstructor)[];
+            openDelay: (StringConstructor | NumberConstructor)[];
+            activator: vue.PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+            activatorProps: {
+                type: vue.PropType<Record<string, any>>;
+                default: () => {};
+            };
+            openOnClick: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            openOnHover: BooleanConstructor;
+            openOnFocus: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            closeOnContentClick: BooleanConstructor;
+            absolute: BooleanConstructor;
+            attach: vue.PropType<string | boolean | Element>;
+            closeOnBack: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            contained: BooleanConstructor;
+            contentClass: null;
+            contentProps: null;
+            disabled: BooleanConstructor;
+            noClickAnimation: BooleanConstructor;
+            modelValue: BooleanConstructor;
+            persistent: BooleanConstructor;
+            scrim: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            zIndex: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: number;
+            };
+        } & SlotsToProps<MakeSlots<{
+            default: [{
+                isActive: vue.Ref<boolean>;
+            }];
+            activator: [{
+                isActive: boolean;
+                props: Record<string, any>;
+            }];
+        }>>>> & {
+            onAfterLeave?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+    };
+    modelValue: {
+        type: null;
+        default: () => never[];
+    };
+    multiple: BooleanConstructor;
+    noDataText: {
+        type: StringConstructor;
+        default: string;
+    };
+    openOnClear: BooleanConstructor;
+    customFilter: vue.PropType<FilterFunction>;
+    customKeyFilter: vue.PropType<FilterKeyFunctions>;
+    filterKeys: {
+        type: vue.PropType<(string & {}) | FilterKeys>;
+        default: (string & {}) | FilterKeys;
+    };
+    filterMode: {
+        type: vue.PropType<FilterMode>;
+        default: string;
+    };
+    noFilter: BooleanConstructor;
+    search: StringConstructor;
+}, "multiple" | "items" | "onUpdate:modelValue" | "modelValue" | "returnObject"> & SlotsToProps<MakeSlots<{
+    default: [VInputSlot];
+    prepend: [VInputSlot];
+    append: [VInputSlot];
+    details: [VInputSlot];
+}> & MakeSlots<{
+    clear: [];
+    prependInner: [DefaultInputSlot & VInputSlot];
+    appendInner: [DefaultInputSlot & VInputSlot];
+    label: [DefaultInputSlot & VInputSlot];
+    loader: [LoaderSlotProps];
+    default: [VFieldSlot];
+}> & MakeSlots<{
+    chip: [{
+        item: unknown;
+        index: number;
+        props: Record<string, unknown>;
+    }];
+    selection: [{
+        item: unknown;
+        index: number;
+    }];
+    'no-data': [];
+}>>>> & {
+    "onClick:clear"?: ((e: MouseEvent) => any) | undefined;
+    "onUpdate:menu"?: ((val: boolean) => any) | undefined;
+    "onUpdate:search"?: ((val: any) => any) | undefined;
+}, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+    'click:clear': (e: MouseEvent) => boolean;
+    'update:search': (val: any) => boolean;
+    'update:modelValue': (val: any) => boolean;
+    'update:menu': (val: boolean) => boolean;
+}, "multiple" | "items" | "update:modelValue" | "modelValue" | "returnObject">, string, {
+    transition: string | boolean | (vue.TransitionProps & {
+        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+    });
+    menu: boolean;
+    eager: boolean;
+    noDataText: string;
+    itemTitle: SelectItemKey;
+    itemValue: SelectItemKey;
+    itemChildren: SelectItemKey;
+    itemProps: SelectItemKey;
+    chips: boolean;
+    closableChips: boolean;
+    hideNoData: boolean;
+    hideSelected: boolean;
+    menuIcon: IconValue;
+    openOnClear: boolean;
+    filterMode: FilterMode;
     noFilter: boolean;
     filterKeys: (string & {}) | FilterKeys;
 }> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T, ReturnObject extends boolean = false, Multiple extends boolean = false, V extends Value$2<T, ReturnObject, Multiple> = Value$2<T, ReturnObject, Multiple>>() => {
@@ -2321,12 +3036,12 @@ interface GroupItemProvide {
 declare const VBtn: vue.DefineComponent<{
     color: StringConstructor;
     variant: Omit<{
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: Omit<{
@@ -2382,6 +3097,7 @@ declare const VBtn: vue.DefineComponent<{
     appendIcon: PropType<IconValue>;
     block: BooleanConstructor;
     stacked: BooleanConstructor;
+    loading: BooleanConstructor;
     ripple: {
         type: BooleanConstructor;
         default: boolean;
@@ -2389,12 +3105,12 @@ declare const VBtn: vue.DefineComponent<{
 }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
     color: StringConstructor;
     variant: Omit<{
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: Omit<{
@@ -2450,6 +3166,7 @@ declare const VBtn: vue.DefineComponent<{
     appendIcon: PropType<IconValue>;
     block: BooleanConstructor;
     stacked: BooleanConstructor;
+    loading: BooleanConstructor;
     ripple: {
         type: BooleanConstructor;
         default: boolean;
@@ -2460,12 +3177,13 @@ declare const VBtn: vue.DefineComponent<{
     flat: boolean;
     active: boolean;
     block: boolean;
+    loading: boolean;
     disabled: boolean;
     size: string | number;
     tag: string;
     rounded: string | number | boolean;
     density: "default" | "compact" | "comfortable" | null;
-    variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     stacked: boolean;
     ripple: boolean;
 }>;
@@ -2474,7 +3192,7 @@ declare type VBtn = InstanceType<typeof VBtn>;
 declare const VBtnGroup: vue.DefineComponent<{
     color: StringConstructor;
     variant: {
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -2501,7 +3219,7 @@ declare const VBtnGroup: vue.DefineComponent<{
 }, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
     color: StringConstructor;
     variant: {
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -2529,7 +3247,7 @@ declare const VBtnGroup: vue.DefineComponent<{
     tag: string;
     rounded: string | number | boolean;
     density: "default" | "compact" | "comfortable" | null;
-    variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     divided: boolean;
 }>;
 
@@ -2686,12 +3404,12 @@ declare const VBtnToggle: {
 declare const VCard: vue.DefineComponent<{
     color: StringConstructor;
     variant: Omit<{
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     tag: {
         type: StringConstructor;
@@ -2742,12 +3460,12 @@ declare const VCard: vue.DefineComponent<{
 }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
     color: StringConstructor;
     variant: Omit<{
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     tag: {
         type: StringConstructor;
@@ -2803,7 +3521,7 @@ declare const VCard: vue.DefineComponent<{
     tag: string;
     rounded: string | number | boolean;
     density: "default" | "compact" | "comfortable" | null;
-    variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     ripple: boolean;
     hover: boolean;
 }>;
@@ -3013,14 +3731,6 @@ declare const VCarouselItem: vue.DefineComponent<{
 declare type VCarouselItem = InstanceType<typeof VCarouselItem>;
 
 declare const VCheckbox: vue.DefineComponent<{
-    falseIcon: {
-        type: vue.PropType<IconValue>;
-        default: string;
-    };
-    trueIcon: {
-        type: vue.PropType<IconValue>;
-        default: string;
-    };
     density: {
         type: vue.PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -3033,6 +3743,14 @@ declare const VCheckbox: vue.DefineComponent<{
     id: StringConstructor;
     inline: BooleanConstructor;
     label: StringConstructor;
+    falseIcon: {
+        type: vue.PropType<(string & {}) | IconValue>;
+        default: (string & {}) | IconValue;
+    };
+    trueIcon: {
+        type: vue.PropType<(string & {}) | IconValue>;
+        default: (string & {}) | IconValue;
+    };
     ripple: {
         type: BooleanConstructor;
         default: boolean;
@@ -3052,6 +3770,11 @@ declare const VCheckbox: vue.DefineComponent<{
         type: vue.PropType<typeof deepEqual>;
         default: typeof deepEqual;
     };
+    indeterminate: BooleanConstructor;
+    indeterminateIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
     errorMessages: {
         type: vue.PropType<string | string[]>;
         default: () => never[];
@@ -3064,6 +3787,7 @@ declare const VCheckbox: vue.DefineComponent<{
         type: vue.PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     appendIcon: vue.PropType<IconValue>;
     prependIcon: vue.PropType<IconValue>;
     hideDetails: vue.PropType<boolean | "auto">;
@@ -3076,24 +3800,9 @@ declare const VCheckbox: vue.DefineComponent<{
         default: string;
         validator: (v: any) => boolean;
     };
-    indeterminate: BooleanConstructor;
-    indeterminateIcon: {
-        type: vue.PropType<IconValue>;
-        default: string;
-    };
-}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
-    'update:indeterminate': (val: boolean) => true;
-}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-    falseIcon: {
-        type: vue.PropType<IconValue>;
-        default: string;
-    };
-    trueIcon: {
-        type: vue.PropType<IconValue>;
-        default: string;
-    };
-    density: {
-        type: vue.PropType<"default" | "compact" | "comfortable" | null>;
+}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+    density: {
+        type: vue.PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -3104,6 +3813,14 @@ declare const VCheckbox: vue.DefineComponent<{
     id: StringConstructor;
     inline: BooleanConstructor;
     label: StringConstructor;
+    falseIcon: {
+        type: vue.PropType<(string & {}) | IconValue>;
+        default: (string & {}) | IconValue;
+    };
+    trueIcon: {
+        type: vue.PropType<(string & {}) | IconValue>;
+        default: (string & {}) | IconValue;
+    };
     ripple: {
         type: BooleanConstructor;
         default: boolean;
@@ -3123,6 +3840,11 @@ declare const VCheckbox: vue.DefineComponent<{
         type: vue.PropType<typeof deepEqual>;
         default: typeof deepEqual;
     };
+    indeterminate: BooleanConstructor;
+    indeterminateIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
     errorMessages: {
         type: vue.PropType<string | string[]>;
         default: () => never[];
@@ -3135,6 +3857,7 @@ declare const VCheckbox: vue.DefineComponent<{
         type: vue.PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     appendIcon: vue.PropType<IconValue>;
     prependIcon: vue.PropType<IconValue>;
     hideDetails: vue.PropType<boolean | "auto">;
@@ -3147,43 +3870,148 @@ declare const VCheckbox: vue.DefineComponent<{
         default: string;
         validator: (v: any) => boolean;
     };
+}>>, {
+    inline: boolean;
+    error: boolean;
+    direction: "horizontal" | "vertical";
+    disabled: boolean;
+    multiple: boolean | null;
+    readonly: boolean;
+    indeterminate: boolean;
+    messages: string | string[];
+    density: "default" | "compact" | "comfortable" | null;
+    ripple: boolean;
+    errorMessages: string | string[];
+    maxErrors: string | number;
+    rules: ValidationRule[];
+    falseIcon: (string & {}) | IconValue;
+    trueIcon: (string & {}) | IconValue;
+    valueComparator: typeof deepEqual;
+    indeterminateIcon: IconValue;
+}>;
+declare type VCheckbox = InstanceType<typeof VCheckbox>;
+
+declare const VCheckboxBtn: vue.DefineComponent<{
+    density: {
+        type: vue.PropType<"default" | "compact" | "comfortable" | null>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    theme: StringConstructor;
+    color: StringConstructor;
+    disabled: BooleanConstructor;
+    error: BooleanConstructor;
+    id: StringConstructor;
+    inline: BooleanConstructor;
+    label: StringConstructor;
+    falseIcon: {
+        type: vue.PropType<(string & {}) | IconValue>;
+        default: (string & {}) | IconValue;
+    };
+    trueIcon: {
+        type: vue.PropType<(string & {}) | IconValue>;
+        default: (string & {}) | IconValue;
+    };
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    name: StringConstructor;
+    readonly: BooleanConstructor;
+    trueValue: null;
+    falseValue: null;
+    modelValue: null;
+    type: StringConstructor;
+    value: null;
+    valueComparator: {
+        type: vue.PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+    indeterminate: BooleanConstructor;
+    indeterminateIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (value: any) => true;
+    'update:indeterminate': (val: boolean) => true;
+}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{
+    density: {
+        type: vue.PropType<"default" | "compact" | "comfortable" | null>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    theme: StringConstructor;
+    color: StringConstructor;
+    disabled: BooleanConstructor;
+    error: BooleanConstructor;
+    id: StringConstructor;
+    inline: BooleanConstructor;
+    label: StringConstructor;
+    falseIcon: {
+        type: vue.PropType<(string & {}) | IconValue>;
+        default: (string & {}) | IconValue;
+    };
+    trueIcon: {
+        type: vue.PropType<(string & {}) | IconValue>;
+        default: (string & {}) | IconValue;
+    };
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    name: StringConstructor;
+    readonly: BooleanConstructor;
+    trueValue: null;
+    falseValue: null;
+    modelValue: null;
+    type: StringConstructor;
+    value: null;
+    valueComparator: {
+        type: vue.PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
     indeterminate: BooleanConstructor;
     indeterminateIcon: {
         type: vue.PropType<IconValue>;
         default: string;
     };
 }>> & {
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
     "onUpdate:indeterminate"?: ((val: boolean) => any) | undefined;
 }, {
     inline: boolean;
     error: boolean;
-    direction: "horizontal" | "vertical";
     disabled: boolean;
     multiple: boolean | null;
     readonly: boolean;
     indeterminate: boolean;
-    messages: string | string[];
     density: "default" | "compact" | "comfortable" | null;
     ripple: boolean;
+    falseIcon: (string & {}) | IconValue;
+    trueIcon: (string & {}) | IconValue;
     valueComparator: typeof deepEqual;
-    errorMessages: string | string[];
-    maxErrors: string | number;
-    rules: ValidationRule[];
-    falseIcon: IconValue;
-    trueIcon: IconValue;
     indeterminateIcon: IconValue;
 }>;
-declare type VCheckbox = InstanceType<typeof VCheckbox>;
+declare type VCheckboxBtn = InstanceType<typeof VCheckboxBtn>;
 
 declare const VChip: vue.DefineComponent<{
     color: StringConstructor;
     variant: Omit<{
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: Omit<{
@@ -3256,12 +4084,12 @@ declare const VChip: vue.DefineComponent<{
 }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
     color: StringConstructor;
     variant: Omit<{
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: Omit<{
@@ -3342,7 +4170,7 @@ declare const VChip: vue.DefineComponent<{
     tag: string;
     rounded: string | number | boolean;
     density: "default" | "compact" | "comfortable" | null;
-    variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     modelValue: boolean;
     ripple: boolean;
     closable: boolean;
@@ -3356,12 +4184,12 @@ declare type VChip = InstanceType<typeof VChip>;
 declare const VChipGroup: vue.DefineComponent<{
     color: StringConstructor;
     variant: Omit<{
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: {
@@ -3391,12 +4219,12 @@ declare const VChipGroup: vue.DefineComponent<{
 }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
     color: StringConstructor;
     variant: Omit<{
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: {
@@ -3429,7 +4257,7 @@ declare const VChipGroup: vue.DefineComponent<{
     multiple: boolean;
     tag: string;
     column: boolean;
-    variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     modelValue: any;
     selectedClass: string;
     valueComparator: typeof deepEqual;
@@ -3575,6 +4403,7 @@ declare const VCombobox: {
             transition: string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
             });
+            menu: boolean;
             eager: boolean;
             noDataText: string;
             itemTitle: SelectItemKey;
@@ -3640,10 +4469,176 @@ declare const VCombobox: {
                 default: boolean;
             };
             hideSelected: BooleanConstructor;
+            menu: BooleanConstructor;
             menuIcon: {
                 type: PropType<IconValue>;
                 default: string;
             };
+            menuProps: {
+                type: PropType<Partial<{
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: PropType<HTMLElement>;
+                        }>>, {}>;
+                    };
+                    modelValue: boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    transition: Omit<{
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    }, "type" | "default"> & {
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: PropType<HTMLElement>;
+                            }>>, {}>;
+                        }>;
+                        default: string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: PropType<HTMLElement>;
+                            }>>, {}>;
+                        };
+                    };
+                    modelValue: BooleanConstructor;
+                    id: StringConstructor;
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+                    absolute: boolean;
+                    location: Anchor;
+                    origin: "auto" | Anchor | "overlap";
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    });
+                    zIndex: string | number;
+                    eager: boolean;
+                    disabled: boolean;
+                    modelValue: boolean;
+                    activatorProps: Record<string, any>;
+                    openOnClick: boolean;
+                    openOnHover: boolean;
+                    openOnFocus: boolean;
+                    closeOnContentClick: boolean;
+                    locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined);
+                    scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                    contained: boolean;
+                    noClickAnimation: boolean;
+                    persistent: boolean;
+                    closeOnBack: boolean;
+                    scrim: string | boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    eager: BooleanConstructor;
+                    transition: {
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    };
+                    theme: StringConstructor;
+                    scrollStrategy: {
+                        type: PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    locationStrategy: {
+                        type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                            updateLocation: (e: Event) => void;
+                        } | undefined)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    location: {
+                        type: PropType<Anchor>;
+                        default: string;
+                    };
+                    origin: {
+                        type: PropType<"auto" | Anchor | "overlap">;
+                        default: string;
+                    };
+                    offset: (StringConstructor | NumberConstructor)[];
+                    height: (StringConstructor | NumberConstructor)[];
+                    maxHeight: (StringConstructor | NumberConstructor)[];
+                    maxWidth: (StringConstructor | NumberConstructor)[];
+                    minHeight: (StringConstructor | NumberConstructor)[];
+                    minWidth: (StringConstructor | NumberConstructor)[];
+                    width: (StringConstructor | NumberConstructor)[];
+                    closeDelay: (StringConstructor | NumberConstructor)[];
+                    openDelay: (StringConstructor | NumberConstructor)[];
+                    activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+                    activatorProps: {
+                        type: PropType<Record<string, any>>;
+                        default: () => {};
+                    };
+                    openOnClick: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    openOnHover: BooleanConstructor;
+                    openOnFocus: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    closeOnContentClick: BooleanConstructor;
+                    absolute: BooleanConstructor;
+                    attach: PropType<string | boolean | Element>;
+                    closeOnBack: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    contained: BooleanConstructor;
+                    contentClass: null;
+                    contentProps: null;
+                    disabled: BooleanConstructor;
+                    noClickAnimation: BooleanConstructor;
+                    modelValue: BooleanConstructor;
+                    persistent: BooleanConstructor;
+                    scrim: {
+                        type: (StringConstructor | BooleanConstructor)[];
+                        default: boolean;
+                    };
+                    zIndex: {
+                        type: (StringConstructor | NumberConstructor)[];
+                        default: number;
+                    };
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    onAfterLeave?: (() => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+            };
             modelValue: {
                 type: null;
                 default: () => never[];
@@ -3690,8 +4685,9 @@ declare const VCombobox: {
             }];
             'no-data': [];
         }>>>> & {
+            "onUpdate:menu"?: ((val: boolean) => any) | undefined;
             "onUpdate:searchInput"?: ((val: string) => any) | undefined;
-        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "eager" | "noDataText" | "itemTitle" | "itemValue" | "itemChildren" | "itemProps" | "chips" | "closableChips" | "hideNoData" | "hideSelected" | "menuIcon" | "openOnClear" | "filterMode" | "noFilter" | "filterKeys">;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "menu" | "eager" | "noDataText" | "itemTitle" | "itemValue" | "itemChildren" | "itemProps" | "chips" | "closableChips" | "hideNoData" | "hideSelected" | "menuIcon" | "openOnClear" | "filterMode" | "noFilter" | "filterKeys">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -3703,7 +4699,7 @@ declare const VCombobox: {
         }>;
         $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
         $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
-        $emit: (event: "update:searchInput", val: string) => void;
+        $emit: ((event: "update:menu", val: boolean) => void) & ((event: "update:searchInput", val: string) => void);
         $el: any;
         $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
             transition: Omit<{
@@ -3755,10 +4751,176 @@ declare const VCombobox: {
                 default: boolean;
             };
             hideSelected: BooleanConstructor;
+            menu: BooleanConstructor;
             menuIcon: {
                 type: PropType<IconValue>;
                 default: string;
             };
+            menuProps: {
+                type: PropType<Partial<{
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: PropType<HTMLElement>;
+                        }>>, {}>;
+                    };
+                    modelValue: boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    transition: Omit<{
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    }, "type" | "default"> & {
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: PropType<HTMLElement>;
+                            }>>, {}>;
+                        }>;
+                        default: string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: PropType<HTMLElement>;
+                            }>>, {}>;
+                        };
+                    };
+                    modelValue: BooleanConstructor;
+                    id: StringConstructor;
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+                    absolute: boolean;
+                    location: Anchor;
+                    origin: "auto" | Anchor | "overlap";
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    });
+                    zIndex: string | number;
+                    eager: boolean;
+                    disabled: boolean;
+                    modelValue: boolean;
+                    activatorProps: Record<string, any>;
+                    openOnClick: boolean;
+                    openOnHover: boolean;
+                    openOnFocus: boolean;
+                    closeOnContentClick: boolean;
+                    locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined);
+                    scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                    contained: boolean;
+                    noClickAnimation: boolean;
+                    persistent: boolean;
+                    closeOnBack: boolean;
+                    scrim: string | boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    eager: BooleanConstructor;
+                    transition: {
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    };
+                    theme: StringConstructor;
+                    scrollStrategy: {
+                        type: PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    locationStrategy: {
+                        type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                            updateLocation: (e: Event) => void;
+                        } | undefined)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    location: {
+                        type: PropType<Anchor>;
+                        default: string;
+                    };
+                    origin: {
+                        type: PropType<"auto" | Anchor | "overlap">;
+                        default: string;
+                    };
+                    offset: (StringConstructor | NumberConstructor)[];
+                    height: (StringConstructor | NumberConstructor)[];
+                    maxHeight: (StringConstructor | NumberConstructor)[];
+                    maxWidth: (StringConstructor | NumberConstructor)[];
+                    minHeight: (StringConstructor | NumberConstructor)[];
+                    minWidth: (StringConstructor | NumberConstructor)[];
+                    width: (StringConstructor | NumberConstructor)[];
+                    closeDelay: (StringConstructor | NumberConstructor)[];
+                    openDelay: (StringConstructor | NumberConstructor)[];
+                    activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+                    activatorProps: {
+                        type: PropType<Record<string, any>>;
+                        default: () => {};
+                    };
+                    openOnClick: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    openOnHover: BooleanConstructor;
+                    openOnFocus: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    closeOnContentClick: BooleanConstructor;
+                    absolute: BooleanConstructor;
+                    attach: PropType<string | boolean | Element>;
+                    closeOnBack: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    contained: BooleanConstructor;
+                    contentClass: null;
+                    contentProps: null;
+                    disabled: BooleanConstructor;
+                    noClickAnimation: BooleanConstructor;
+                    modelValue: BooleanConstructor;
+                    persistent: BooleanConstructor;
+                    scrim: {
+                        type: (StringConstructor | BooleanConstructor)[];
+                        default: boolean;
+                    };
+                    zIndex: {
+                        type: (StringConstructor | NumberConstructor)[];
+                        default: number;
+                    };
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    onAfterLeave?: (() => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+            };
             modelValue: {
                 type: null;
                 default: () => never[];
@@ -3805,14 +4967,17 @@ declare const VCombobox: {
             }];
             'no-data': [];
         }>>>> & {
+            "onUpdate:menu"?: ((val: boolean) => any) | undefined;
             "onUpdate:searchInput"?: ((val: string) => any) | undefined;
         }, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
             'update:modelValue': (val: any) => boolean;
             'update:searchInput': (val: string) => boolean;
+            'update:menu': (val: boolean) => boolean;
         }, "multiple" | "items" | "update:modelValue" | "modelValue" | "returnObject">, string, {
             transition: string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
             });
+            menu: boolean;
             eager: boolean;
             noDataText: string;
             itemTitle: SelectItemKey;
@@ -3898,10 +5063,176 @@ declare const VCombobox: {
             default: boolean;
         };
         hideSelected: BooleanConstructor;
+        menu: BooleanConstructor;
         menuIcon: {
             type: PropType<IconValue>;
             default: string;
         };
+        menuProps: {
+            type: PropType<Partial<{
+                transition: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                }) | {
+                    readonly component: vue.DefineComponent<{
+                        target: PropType<HTMLElement>;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                        target: PropType<HTMLElement>;
+                    }>>, {}>;
+                };
+                modelValue: boolean;
+            }> & Omit<Readonly<vue.ExtractPropTypes<{
+                transition: Omit<{
+                    type: PropType<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    })>;
+                    default: string;
+                    validator: (val: unknown) => boolean;
+                }, "type" | "default"> & {
+                    type: PropType<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: PropType<HTMLElement>;
+                        }>>, {}>;
+                    }>;
+                    default: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: PropType<HTMLElement>;
+                        }>>, {}>;
+                    };
+                };
+                modelValue: BooleanConstructor;
+                id: StringConstructor;
+            } & SlotsToProps<MakeSlots<{
+                default: [{
+                    isActive: vue.Ref<boolean>;
+                }];
+                activator: [{
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }];
+            }>>>> & {
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+                absolute: boolean;
+                location: Anchor;
+                origin: "auto" | Anchor | "overlap";
+                transition: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                });
+                zIndex: string | number;
+                eager: boolean;
+                disabled: boolean;
+                modelValue: boolean;
+                activatorProps: Record<string, any>;
+                openOnClick: boolean;
+                openOnHover: boolean;
+                openOnFocus: boolean;
+                closeOnContentClick: boolean;
+                locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined);
+                scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                contained: boolean;
+                noClickAnimation: boolean;
+                persistent: boolean;
+                closeOnBack: boolean;
+                scrim: string | boolean;
+            }> & Omit<Readonly<vue.ExtractPropTypes<{
+                eager: BooleanConstructor;
+                transition: {
+                    type: PropType<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    })>;
+                    default: string;
+                    validator: (val: unknown) => boolean;
+                };
+                theme: StringConstructor;
+                scrollStrategy: {
+                    type: PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                    default: string;
+                    validator: (val: any) => boolean;
+                };
+                locationStrategy: {
+                    type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined)>;
+                    default: string;
+                    validator: (val: any) => boolean;
+                };
+                location: {
+                    type: PropType<Anchor>;
+                    default: string;
+                };
+                origin: {
+                    type: PropType<"auto" | Anchor | "overlap">;
+                    default: string;
+                };
+                offset: (StringConstructor | NumberConstructor)[];
+                height: (StringConstructor | NumberConstructor)[];
+                maxHeight: (StringConstructor | NumberConstructor)[];
+                maxWidth: (StringConstructor | NumberConstructor)[];
+                minHeight: (StringConstructor | NumberConstructor)[];
+                minWidth: (StringConstructor | NumberConstructor)[];
+                width: (StringConstructor | NumberConstructor)[];
+                closeDelay: (StringConstructor | NumberConstructor)[];
+                openDelay: (StringConstructor | NumberConstructor)[];
+                activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+                activatorProps: {
+                    type: PropType<Record<string, any>>;
+                    default: () => {};
+                };
+                openOnClick: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                openOnHover: BooleanConstructor;
+                openOnFocus: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                closeOnContentClick: BooleanConstructor;
+                absolute: BooleanConstructor;
+                attach: PropType<string | boolean | Element>;
+                closeOnBack: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                contained: BooleanConstructor;
+                contentClass: null;
+                contentProps: null;
+                disabled: BooleanConstructor;
+                noClickAnimation: BooleanConstructor;
+                modelValue: BooleanConstructor;
+                persistent: BooleanConstructor;
+                scrim: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                zIndex: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: number;
+                };
+            } & SlotsToProps<MakeSlots<{
+                default: [{
+                    isActive: vue.Ref<boolean>;
+                }];
+                activator: [{
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }];
+            }>>>> & {
+                onAfterLeave?: (() => any) | undefined;
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+        };
         modelValue: {
             type: null;
             default: () => never[];
@@ -3948,6 +5279,7 @@ declare const VCombobox: {
         }];
         'no-data': [];
     }>>>> & {
+        "onUpdate:menu"?: ((val: boolean) => any) | undefined;
         "onUpdate:searchInput"?: ((val: string) => any) | undefined;
     } & vue.ShallowUnwrapRef<any> & {} & vue.ComponentCustomProperties;
     __isFragment?: undefined;
@@ -4003,10 +5335,176 @@ declare const VCombobox: {
         default: boolean;
     };
     hideSelected: BooleanConstructor;
+    menu: BooleanConstructor;
     menuIcon: {
         type: PropType<IconValue>;
         default: string;
     };
+    menuProps: {
+        type: PropType<Partial<{
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            }) | {
+                readonly component: vue.DefineComponent<{
+                    target: PropType<HTMLElement>;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                    target: PropType<HTMLElement>;
+                }>>, {}>;
+            };
+            modelValue: boolean;
+        }> & Omit<Readonly<vue.ExtractPropTypes<{
+            transition: Omit<{
+                type: PropType<string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                })>;
+                default: string;
+                validator: (val: unknown) => boolean;
+            }, "type" | "default"> & {
+                type: PropType<string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                }) | {
+                    readonly component: vue.DefineComponent<{
+                        target: PropType<HTMLElement>;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                        target: PropType<HTMLElement>;
+                    }>>, {}>;
+                }>;
+                default: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                }) | {
+                    readonly component: vue.DefineComponent<{
+                        target: PropType<HTMLElement>;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                        target: PropType<HTMLElement>;
+                    }>>, {}>;
+                };
+            };
+            modelValue: BooleanConstructor;
+            id: StringConstructor;
+        } & SlotsToProps<MakeSlots<{
+            default: [{
+                isActive: vue.Ref<boolean>;
+            }];
+            activator: [{
+                isActive: boolean;
+                props: Record<string, any>;
+            }];
+        }>>>> & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            closeOnBack: boolean;
+            scrim: string | boolean;
+        }> & Omit<Readonly<vue.ExtractPropTypes<{
+            eager: BooleanConstructor;
+            transition: {
+                type: PropType<string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                })>;
+                default: string;
+                validator: (val: unknown) => boolean;
+            };
+            theme: StringConstructor;
+            scrollStrategy: {
+                type: PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                default: string;
+                validator: (val: any) => boolean;
+            };
+            locationStrategy: {
+                type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined)>;
+                default: string;
+                validator: (val: any) => boolean;
+            };
+            location: {
+                type: PropType<Anchor>;
+                default: string;
+            };
+            origin: {
+                type: PropType<"auto" | Anchor | "overlap">;
+                default: string;
+            };
+            offset: (StringConstructor | NumberConstructor)[];
+            height: (StringConstructor | NumberConstructor)[];
+            maxHeight: (StringConstructor | NumberConstructor)[];
+            maxWidth: (StringConstructor | NumberConstructor)[];
+            minHeight: (StringConstructor | NumberConstructor)[];
+            minWidth: (StringConstructor | NumberConstructor)[];
+            width: (StringConstructor | NumberConstructor)[];
+            closeDelay: (StringConstructor | NumberConstructor)[];
+            openDelay: (StringConstructor | NumberConstructor)[];
+            activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+            activatorProps: {
+                type: PropType<Record<string, any>>;
+                default: () => {};
+            };
+            openOnClick: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            openOnHover: BooleanConstructor;
+            openOnFocus: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            closeOnContentClick: BooleanConstructor;
+            absolute: BooleanConstructor;
+            attach: PropType<string | boolean | Element>;
+            closeOnBack: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            contained: BooleanConstructor;
+            contentClass: null;
+            contentProps: null;
+            disabled: BooleanConstructor;
+            noClickAnimation: BooleanConstructor;
+            modelValue: BooleanConstructor;
+            persistent: BooleanConstructor;
+            scrim: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            zIndex: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: number;
+            };
+        } & SlotsToProps<MakeSlots<{
+            default: [{
+                isActive: vue.Ref<boolean>;
+            }];
+            activator: [{
+                isActive: boolean;
+                props: Record<string, any>;
+            }];
+        }>>>> & {
+            onAfterLeave?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+    };
     modelValue: {
         type: null;
         default: () => never[];
@@ -4053,14 +5551,17 @@ declare const VCombobox: {
     }];
     'no-data': [];
 }>>>> & {
+    "onUpdate:menu"?: ((val: boolean) => any) | undefined;
     "onUpdate:searchInput"?: ((val: string) => any) | undefined;
 }, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
     'update:modelValue': (val: any) => boolean;
     'update:searchInput': (val: string) => boolean;
+    'update:menu': (val: boolean) => boolean;
 }, "multiple" | "items" | "update:modelValue" | "modelValue" | "returnObject">, string, {
     transition: string | boolean | (vue.TransitionProps & {
         component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
     });
+    menu: boolean;
     eager: boolean;
     noDataText: string;
     itemTitle: SelectItemKey;
@@ -4353,40 +5854,6 @@ declare const VDefaultsProvider: vue.DefineComponent<{
     scoped: boolean;
 }>;
 
-interface ScrollStrategyData {
-    root: Ref<HTMLElement | undefined>;
-    contentEl: Ref<HTMLElement | undefined>;
-    activatorEl: Ref<HTMLElement | undefined>;
-    isActive: Ref<boolean>;
-    updateLocation: Ref<((e: Event) => void) | undefined>;
-}
-
-interface LocationStrategyData {
-    contentEl: Ref<HTMLElement | undefined>;
-    activatorEl: Ref<HTMLElement | undefined>;
-    isActive: Ref<boolean>;
-}
-declare const locationStrategies: {
-    static: typeof staticLocationStrategy;
-    connected: typeof connectedLocationStrategy;
-};
-interface StrategyProps {
-    locationStrategy: keyof typeof locationStrategies | ((data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>) => undefined | {
-        updateLocation: (e: Event) => void;
-    });
-    location: Anchor;
-    origin: Anchor | 'auto' | 'overlap';
-    offset?: number | string;
-    maxHeight?: number | string;
-    maxWidth?: number | string;
-    minHeight?: number | string;
-    minWidth?: number | string;
-}
-declare function staticLocationStrategy(): void;
-declare function connectedLocationStrategy(data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>): {
-    updateLocation: () => void;
-};
-
 declare type OverlaySlots = MakeSlots<{
     default: [{
         isActive: Ref<boolean>;
@@ -4411,7 +5878,6 @@ declare const VOverlay: {
             eager: boolean;
             disabled: boolean;
             modelValue: boolean;
-            contained: boolean;
             activatorProps: Record<string, any>;
             openOnClick: boolean;
             openOnHover: boolean;
@@ -4421,6 +5887,7 @@ declare const VOverlay: {
                 updateLocation: (e: Event) => void;
             } | undefined);
             scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+            contained: boolean;
             noClickAnimation: boolean;
             persistent: boolean;
             closeOnBack: boolean;
@@ -4512,7 +5979,7 @@ declare const VOverlay: {
             onAfterLeave?: (() => any) | undefined;
             "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
             "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
-        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "contained" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -4634,7 +6101,6 @@ declare const VOverlay: {
             eager: boolean;
             disabled: boolean;
             modelValue: boolean;
-            contained: boolean;
             activatorProps: Record<string, any>;
             openOnClick: boolean;
             openOnHover: boolean;
@@ -4644,6 +6110,7 @@ declare const VOverlay: {
                 updateLocation: (e: Event) => void;
             } | undefined);
             scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+            contained: boolean;
             noClickAnimation: boolean;
             persistent: boolean;
             closeOnBack: boolean;
@@ -4873,7 +6340,6 @@ declare const VOverlay: {
     eager: boolean;
     disabled: boolean;
     modelValue: boolean;
-    contained: boolean;
     activatorProps: Record<string, any>;
     openOnClick: boolean;
     openOnHover: boolean;
@@ -4883,6 +6349,7 @@ declare const VOverlay: {
         updateLocation: (e: Event) => void;
     } | undefined);
     scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+    contained: boolean;
     noClickAnimation: boolean;
     persistent: boolean;
     closeOnBack: boolean;
@@ -5462,7 +6929,7 @@ declare const VFileInput: vue.DefineComponent<{
     reverse: BooleanConstructor;
     singleLine: BooleanConstructor;
     variant: {
-        type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+        type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -5489,6 +6956,7 @@ declare const VFileInput: vue.DefineComponent<{
         type: PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -5525,7 +6993,7 @@ declare const VFileInput: vue.DefineComponent<{
         default: boolean;
         validator: (v: boolean | number) => boolean;
     };
-}, {
+}, HTMLInputElement & {
     $: vue.ComponentInternalInstance;
     $data: {};
     $props: Partial<{
@@ -5556,6 +7024,7 @@ declare const VFileInput: vue.DefineComponent<{
             default: () => never[];
         };
         modelValue: null;
+        validationValue: null;
         density: {
             type: PropType<"default" | "compact" | "comfortable" | null>;
             default: string;
@@ -5613,6 +7082,7 @@ declare const VFileInput: vue.DefineComponent<{
             default: () => never[];
         };
         modelValue: null;
+        validationValue: null;
         density: {
             type: PropType<"default" | "compact" | "comfortable" | null>;
             default: string;
@@ -5692,6 +7162,7 @@ declare const VFileInput: vue.DefineComponent<{
         default: () => never[];
     };
     modelValue: null;
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -5728,7 +7199,7 @@ declare const VFileInput: vue.DefineComponent<{
         append: [VInputSlot];
         details: [VInputSlot];
     }>;
-} & HTMLInputElement, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     'click:clear': (e: MouseEvent) => true;
     'click:control': (e: MouseEvent) => true;
     'update:modelValue': (files: File[]) => true;
@@ -5756,7 +7227,7 @@ declare const VFileInput: vue.DefineComponent<{
     reverse: BooleanConstructor;
     singleLine: BooleanConstructor;
     variant: {
-        type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+        type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -5783,6 +7254,7 @@ declare const VFileInput: vue.DefineComponent<{
         type: PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -5835,7 +7307,7 @@ declare const VFileInput: vue.DefineComponent<{
     messages: string | string[];
     counter: boolean;
     density: "default" | "compact" | "comfortable" | null;
-    variant: "filled" | "outlined" | "plain" | "contained" | "underlined";
+    variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
     modelValue: File[];
     prependIcon: IconValue;
     errorMessages: string | string[];
@@ -5927,14 +7399,15 @@ declare const VFooter: vue.DefineComponent<{
     app: boolean;
 }>;
 
-interface FormValidationResult {
+interface FieldValidationResult {
     id: number | string;
     errorMessages: string[];
 }
-interface SubmitEventPromise extends SubmitEvent, Promise<{
+interface FormValidationResult {
     valid: boolean;
-    errorMessages: FormValidationResult[];
-}> {
+    errors: FieldValidationResult[];
+}
+interface SubmitEventPromise extends SubmitEvent, Promise<FormValidationResult> {
 }
 
 declare const VForm: vue.DefineComponent<{
@@ -5947,7 +7420,7 @@ declare const VForm: vue.DefineComponent<{
         default: null;
     };
 }, {
-    errorMessages: vue.Ref<{
+    errors: vue.Ref<{
         id: string | number;
         errorMessages: string[];
     }[]>;
@@ -5963,7 +7436,7 @@ declare const VForm: vue.DefineComponent<{
     }[]>;
     validate: () => Promise<{
         valid: boolean;
-        errorMessages: {
+        errors: {
             id: string | number;
             errorMessages: string[];
         }[];
@@ -6802,7 +8275,7 @@ declare const VList: {
             mandatory: boolean;
             rounded: string | number | boolean;
             density: "default" | "compact" | "comfortable" | null;
-            variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+            variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
             selectStrategy: SelectStrategy | ("classic" & {}) | ("single-leaf" & {}) | ("leaf" & {}) | ("independent" & {}) | ("single-independent" & {});
             openStrategy: OpenStrategyProp | ("multiple" & {}) | ("single" & {}) | ("list" & {});
             lines: false | "one" | "two" | "three";
@@ -6815,12 +8288,12 @@ declare const VList: {
         }> & Omit<Readonly<vue.ExtractPropTypes<Omit<{
             color: StringConstructor;
             variant: Omit<{
-                type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+                type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
                 default: string;
                 validator: (v: any) => boolean;
             }, "type" | "default"> & {
-                type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-                default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+                type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+                default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
             };
             theme: StringConstructor;
             tag: {
@@ -6934,12 +8407,12 @@ declare const VList: {
         $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
             color: StringConstructor;
             variant: Omit<{
-                type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+                type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
                 default: string;
                 validator: (v: any) => boolean;
             }, "type" | "default"> & {
-                type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-                default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+                type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+                default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
             };
             theme: StringConstructor;
             tag: {
@@ -7051,7 +8524,7 @@ declare const VList: {
             mandatory: boolean;
             rounded: string | number | boolean;
             density: "default" | "compact" | "comfortable" | null;
-            variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+            variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
             selectStrategy: SelectStrategy | ("classic" & {}) | ("single-leaf" & {}) | ("leaf" & {}) | ("independent" & {}) | ("single-independent" & {});
             openStrategy: OpenStrategyProp | ("multiple" & {}) | ("single" & {}) | ("list" & {});
             lines: false | "one" | "two" | "three";
@@ -7084,12 +8557,12 @@ declare const VList: {
     } & Readonly<vue.ExtractPropTypes<Omit<{
         color: StringConstructor;
         variant: Omit<{
-            type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+            type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
             default: string;
             validator: (v: any) => boolean;
         }, "type" | "default"> & {
-            type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-            default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+            type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+            default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
         };
         theme: StringConstructor;
         tag: {
@@ -7188,12 +8661,12 @@ declare const VList: {
 } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
     color: StringConstructor;
     variant: Omit<{
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: {
@@ -7305,7 +8778,7 @@ declare const VList: {
     mandatory: boolean;
     rounded: string | number | boolean;
     density: "default" | "compact" | "comfortable" | null;
-    variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     selectStrategy: SelectStrategy | ("classic" & {}) | ("single-leaf" & {}) | ("leaf" & {}) | ("independent" & {}) | ("single-independent" & {});
     openStrategy: OpenStrategyProp | ("multiple" & {}) | ("single" & {}) | ("list" & {});
     lines: false | "one" | "two" | "three";
@@ -7392,16 +8865,16 @@ declare const VListItem: {
             tag: string;
             rounded: string | number | boolean;
             density: "default" | "compact" | "comfortable" | null;
-            variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+            variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
         }> & Omit<Readonly<vue.ExtractPropTypes<{
             color: StringConstructor;
             variant: Omit<{
-                type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+                type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
                 default: string;
                 validator: (v: any) => boolean;
             }, "type" | "default"> & {
-                type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-                default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+                type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+                default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
             };
             theme: StringConstructor;
             tag: {
@@ -7468,12 +8941,12 @@ declare const VListItem: {
         $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
             color: StringConstructor;
             variant: Omit<{
-                type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+                type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
                 default: string;
                 validator: (v: any) => boolean;
             }, "type" | "default"> & {
-                type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-                default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+                type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+                default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
             };
             theme: StringConstructor;
             tag: {
@@ -7532,7 +9005,7 @@ declare const VListItem: {
             tag: string;
             rounded: string | number | boolean;
             density: "default" | "compact" | "comfortable" | null;
-            variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+            variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
         }> & {
             beforeCreate?: ((() => void) | (() => void)[]) | undefined;
             created?: ((() => void) | (() => void)[]) | undefined;
@@ -7556,12 +9029,12 @@ declare const VListItem: {
     } & Readonly<vue.ExtractPropTypes<{
         color: StringConstructor;
         variant: Omit<{
-            type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+            type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
             default: string;
             validator: (v: any) => boolean;
         }, "type" | "default"> & {
-            type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-            default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+            type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+            default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
         };
         theme: StringConstructor;
         tag: {
@@ -7618,12 +9091,12 @@ declare const VListItem: {
 } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
     color: StringConstructor;
     variant: Omit<{
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: {
@@ -7682,7 +9155,7 @@ declare const VListItem: {
     tag: string;
     rounded: string | number | boolean;
     density: "default" | "compact" | "comfortable" | null;
-    variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
 }> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
     $slots: MakeSlots<{
         prepend: [ListItemSlot];
@@ -8041,7 +9514,6 @@ declare const VMenu: {
                 eager: boolean;
                 disabled: boolean;
                 modelValue: boolean;
-                contained: boolean;
                 activatorProps: Record<string, any>;
                 openOnClick: boolean;
                 openOnHover: boolean;
@@ -8051,6 +9523,7 @@ declare const VMenu: {
                     updateLocation: (e: Event) => void;
                 } | undefined);
                 scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                contained: boolean;
                 noClickAnimation: boolean;
                 persistent: boolean;
                 closeOnBack: boolean;
@@ -8142,7 +9615,7 @@ declare const VMenu: {
                 onAfterLeave?: (() => any) | undefined;
                 "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
                 "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
-            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "contained" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">;
+            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">;
             $attrs: {
                 [x: string]: unknown;
             };
@@ -8264,7 +9737,6 @@ declare const VMenu: {
                 eager: boolean;
                 disabled: boolean;
                 modelValue: boolean;
-                contained: boolean;
                 activatorProps: Record<string, any>;
                 openOnClick: boolean;
                 openOnHover: boolean;
@@ -8274,6 +9746,7 @@ declare const VMenu: {
                     updateLocation: (e: Event) => void;
                 } | undefined);
                 scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                contained: boolean;
                 noClickAnimation: boolean;
                 persistent: boolean;
                 closeOnBack: boolean;
@@ -8489,7 +9962,6 @@ declare const VMenu: {
             eager: boolean;
             disabled: boolean;
             modelValue: boolean;
-            contained: boolean;
             activatorProps: Record<string, any>;
             openOnClick: boolean;
             openOnHover: boolean;
@@ -8499,6 +9971,7 @@ declare const VMenu: {
                 updateLocation: (e: Event) => void;
             } | undefined);
             scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+            contained: boolean;
             noClickAnimation: boolean;
             persistent: boolean;
             closeOnBack: boolean;
@@ -8590,7 +10063,7 @@ declare const VMenu: {
             onAfterLeave?: (() => any) | undefined;
             "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
             "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
-        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "contained" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -8712,7 +10185,6 @@ declare const VMenu: {
             eager: boolean;
             disabled: boolean;
             modelValue: boolean;
-            contained: boolean;
             activatorProps: Record<string, any>;
             openOnClick: boolean;
             openOnHover: boolean;
@@ -8722,6 +10194,7 @@ declare const VMenu: {
                 updateLocation: (e: Event) => void;
             } | undefined);
             scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+            contained: boolean;
             noClickAnimation: boolean;
             persistent: boolean;
             closeOnBack: boolean;
@@ -8908,7 +10381,6 @@ declare const VMenu: {
         eager: boolean;
         disabled: boolean;
         modelValue: boolean;
-        contained: boolean;
         activatorProps: Record<string, any>;
         openOnClick: boolean;
         openOnHover: boolean;
@@ -8918,6 +10390,7 @@ declare const VMenu: {
             updateLocation: (e: Event) => void;
         } | undefined);
         scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+        contained: boolean;
         noClickAnimation: boolean;
         persistent: boolean;
         closeOnBack: boolean;
@@ -9009,7 +10482,7 @@ declare const VMenu: {
         onAfterLeave?: (() => any) | undefined;
         "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
         "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
-    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "contained" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">;
+    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">;
     $attrs: {
         [x: string]: unknown;
     };
@@ -9131,7 +10604,6 @@ declare const VMenu: {
         eager: boolean;
         disabled: boolean;
         modelValue: boolean;
-        contained: boolean;
         activatorProps: Record<string, any>;
         openOnClick: boolean;
         openOnHover: boolean;
@@ -9141,6 +10613,7 @@ declare const VMenu: {
             updateLocation: (e: Event) => void;
         } | undefined);
         scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+        contained: boolean;
         noClickAnimation: boolean;
         persistent: boolean;
         closeOnBack: boolean;
@@ -9653,12 +11126,12 @@ declare const VNoSsr: vue.DefineComponent<{}, () => false | vue.VNode<vue.Render
 declare const VPagination: vue.DefineComponent<{
     color: StringConstructor;
     variant: Omit<{
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: Omit<{
@@ -9759,12 +11232,12 @@ declare const VPagination: vue.DefineComponent<{
 }, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
     color: StringConstructor;
     variant: Omit<{
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
-        default: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     };
     theme: StringConstructor;
     tag: Omit<{
@@ -9872,7 +11345,7 @@ declare const VPagination: vue.DefineComponent<{
     ellipsis: string;
     rounded: string | number | boolean;
     density: "default" | "compact" | "comfortable" | null;
-    variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     modelValue: number;
     nextIcon: IconValue;
     prevIcon: IconValue;
@@ -10144,6 +11617,7 @@ declare const VRadioGroup: vue.DefineComponent<{
         type: vue.PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     appendIcon: vue.PropType<IconValue>;
     prependIcon: vue.PropType<IconValue>;
     hideDetails: vue.PropType<boolean | "auto">;
@@ -10215,6 +11689,7 @@ declare const VRadioGroup: vue.DefineComponent<{
         type: vue.PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     appendIcon: vue.PropType<IconValue>;
     prependIcon: vue.PropType<IconValue>;
     hideDetails: vue.PropType<boolean | "auto">;
@@ -10243,12 +11718,12 @@ declare const VRadioGroup: vue.DefineComponent<{
     messages: string | string[];
     density: "default" | "compact" | "comfortable" | null;
     ripple: boolean;
-    valueComparator: typeof deepEqual;
     errorMessages: string | string[];
     maxErrors: string | number;
     rules: ValidationRule[];
     falseIcon: IconValue;
     trueIcon: IconValue;
+    valueComparator: typeof deepEqual;
 }>;
 
 declare const VRangeSlider: vue.DefineComponent<{
@@ -10331,6 +11806,7 @@ declare const VRangeSlider: vue.DefineComponent<{
         type: PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -10428,6 +11904,7 @@ declare const VRangeSlider: vue.DefineComponent<{
         type: PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -10840,11 +12317,12 @@ declare const VSelect: {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
             }) | {
                 component: vue.DefineComponent<{
-                    target: vue.PropType<HTMLElement>;
+                    target: PropType<HTMLElement>;
                 }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                    target: vue.PropType<HTMLElement>;
+                    target: PropType<HTMLElement>;
                 }>>, {}>;
             };
+            menu: boolean;
             eager: boolean;
             noDataText: string;
             itemTitle: SelectItemKey;
@@ -10859,52 +12337,52 @@ declare const VSelect: {
             openOnClear: boolean;
         }> & Omit<Readonly<vue.ExtractPropTypes<Omit<{
             transition: Omit<{
-                type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                type: PropType<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
                 })>;
                 default: string;
                 validator: (val: unknown) => boolean;
             }, "type" | "default"> & {
-                type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                type: PropType<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
                 }) | {
                     component: vue.DefineComponent<{
-                        target: vue.PropType<HTMLElement>;
+                        target: PropType<HTMLElement>;
                     }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: vue.PropType<HTMLElement>;
+                        target: PropType<HTMLElement>;
                     }>>, {}>;
                 }>;
                 default: string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
                 }) | {
                     component: vue.DefineComponent<{
-                        target: vue.PropType<HTMLElement>;
+                        target: PropType<HTMLElement>;
                     }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: vue.PropType<HTMLElement>;
+                        target: PropType<HTMLElement>;
                     }>>, {}>;
                 };
             };
             items: {
-                type: vue.PropType<any[]>;
+                type: PropType<any[]>;
                 default: () => never[];
             };
             itemTitle: {
-                type: vue.PropType<SelectItemKey>;
+                type: PropType<SelectItemKey>;
                 default: string;
             };
             itemValue: {
-                type: vue.PropType<SelectItemKey>;
+                type: PropType<SelectItemKey>;
                 default: string;
             };
             itemChildren: Omit<{
-                type: vue.PropType<SelectItemKey>;
+                type: PropType<SelectItemKey>;
                 default: string;
             }, "type" | "default"> & {
-                type: vue.PropType<SelectItemKey>;
+                type: PropType<SelectItemKey>;
                 default: SelectItemKey;
             };
             itemProps: {
-                type: vue.PropType<SelectItemKey>;
+                type: PropType<SelectItemKey>;
                 default: string;
             };
             returnObject: BooleanConstructor;
@@ -10913,10 +12391,176 @@ declare const VSelect: {
             eager: BooleanConstructor;
             hideNoData: BooleanConstructor;
             hideSelected: BooleanConstructor;
+            menu: BooleanConstructor;
             menuIcon: {
-                type: vue.PropType<IconValue>;
+                type: PropType<IconValue>;
                 default: string;
             };
+            menuProps: {
+                type: PropType<Partial<{
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: PropType<HTMLElement>;
+                        }>>, {}>;
+                    };
+                    modelValue: boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    transition: Omit<{
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    }, "type" | "default"> & {
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: PropType<HTMLElement>;
+                            }>>, {}>;
+                        }>;
+                        default: string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: PropType<HTMLElement>;
+                            }>>, {}>;
+                        };
+                    };
+                    modelValue: BooleanConstructor;
+                    id: StringConstructor;
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+                    absolute: boolean;
+                    location: Anchor;
+                    origin: "auto" | Anchor | "overlap";
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    });
+                    zIndex: string | number;
+                    eager: boolean;
+                    disabled: boolean;
+                    modelValue: boolean;
+                    activatorProps: Record<string, any>;
+                    openOnClick: boolean;
+                    openOnHover: boolean;
+                    openOnFocus: boolean;
+                    closeOnContentClick: boolean;
+                    locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined);
+                    scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                    contained: boolean;
+                    noClickAnimation: boolean;
+                    persistent: boolean;
+                    closeOnBack: boolean;
+                    scrim: string | boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    eager: BooleanConstructor;
+                    transition: {
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    };
+                    theme: StringConstructor;
+                    scrollStrategy: {
+                        type: PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    locationStrategy: {
+                        type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                            updateLocation: (e: Event) => void;
+                        } | undefined)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    location: {
+                        type: PropType<Anchor>;
+                        default: string;
+                    };
+                    origin: {
+                        type: PropType<"auto" | Anchor | "overlap">;
+                        default: string;
+                    };
+                    offset: (StringConstructor | NumberConstructor)[];
+                    height: (StringConstructor | NumberConstructor)[];
+                    maxHeight: (StringConstructor | NumberConstructor)[];
+                    maxWidth: (StringConstructor | NumberConstructor)[];
+                    minHeight: (StringConstructor | NumberConstructor)[];
+                    minWidth: (StringConstructor | NumberConstructor)[];
+                    width: (StringConstructor | NumberConstructor)[];
+                    closeDelay: (StringConstructor | NumberConstructor)[];
+                    openDelay: (StringConstructor | NumberConstructor)[];
+                    activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+                    activatorProps: {
+                        type: PropType<Record<string, any>>;
+                        default: () => {};
+                    };
+                    openOnClick: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    openOnHover: BooleanConstructor;
+                    openOnFocus: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    closeOnContentClick: BooleanConstructor;
+                    absolute: BooleanConstructor;
+                    attach: PropType<string | boolean | Element>;
+                    closeOnBack: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    contained: BooleanConstructor;
+                    contentClass: null;
+                    contentProps: null;
+                    disabled: BooleanConstructor;
+                    noClickAnimation: BooleanConstructor;
+                    modelValue: BooleanConstructor;
+                    persistent: BooleanConstructor;
+                    scrim: {
+                        type: (StringConstructor | BooleanConstructor)[];
+                        default: boolean;
+                    };
+                    zIndex: {
+                        type: (StringConstructor | NumberConstructor)[];
+                        default: number;
+                    };
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    onAfterLeave?: (() => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+            };
             modelValue: {
                 type: null;
                 default: () => never[];
@@ -10950,7 +12594,9 @@ declare const VSelect: {
                 index: number;
             }];
             'no-data': [];
-        }>>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "eager" | "noDataText" | "itemTitle" | "itemValue" | "itemChildren" | "itemProps" | "chips" | "closableChips" | "hideNoData" | "hideSelected" | "menuIcon" | "openOnClear">;
+        }>>>> & {
+            "onUpdate:menu"?: ((val: boolean) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "menu" | "eager" | "noDataText" | "itemTitle" | "itemValue" | "itemChildren" | "itemProps" | "chips" | "closableChips" | "hideNoData" | "hideSelected" | "menuIcon" | "openOnClear">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -10962,56 +12608,56 @@ declare const VSelect: {
         }>;
         $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
         $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
-        $emit: (event: string, ...args: any[]) => void;
+        $emit: (event: "update:menu", val: boolean) => void;
         $el: any;
         $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
             transition: Omit<{
-                type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                type: PropType<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
                 })>;
                 default: string;
                 validator: (val: unknown) => boolean;
             }, "type" | "default"> & {
-                type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                type: PropType<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
                 }) | {
                     component: vue.DefineComponent<{
-                        target: vue.PropType<HTMLElement>;
+                        target: PropType<HTMLElement>;
                     }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: vue.PropType<HTMLElement>;
+                        target: PropType<HTMLElement>;
                     }>>, {}>;
                 }>;
                 default: string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
                 }) | {
                     component: vue.DefineComponent<{
-                        target: vue.PropType<HTMLElement>;
+                        target: PropType<HTMLElement>;
                     }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: vue.PropType<HTMLElement>;
+                        target: PropType<HTMLElement>;
                     }>>, {}>;
                 };
             };
             items: {
-                type: vue.PropType<any[]>;
+                type: PropType<any[]>;
                 default: () => never[];
             };
             itemTitle: {
-                type: vue.PropType<SelectItemKey>;
+                type: PropType<SelectItemKey>;
                 default: string;
             };
             itemValue: {
-                type: vue.PropType<SelectItemKey>;
+                type: PropType<SelectItemKey>;
                 default: string;
             };
             itemChildren: Omit<{
-                type: vue.PropType<SelectItemKey>;
+                type: PropType<SelectItemKey>;
                 default: string;
             }, "type" | "default"> & {
-                type: vue.PropType<SelectItemKey>;
+                type: PropType<SelectItemKey>;
                 default: SelectItemKey;
             };
             itemProps: {
-                type: vue.PropType<SelectItemKey>;
+                type: PropType<SelectItemKey>;
                 default: string;
             };
             returnObject: BooleanConstructor;
@@ -11020,10 +12666,176 @@ declare const VSelect: {
             eager: BooleanConstructor;
             hideNoData: BooleanConstructor;
             hideSelected: BooleanConstructor;
+            menu: BooleanConstructor;
             menuIcon: {
-                type: vue.PropType<IconValue>;
+                type: PropType<IconValue>;
                 default: string;
             };
+            menuProps: {
+                type: PropType<Partial<{
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: PropType<HTMLElement>;
+                        }>>, {}>;
+                    };
+                    modelValue: boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    transition: Omit<{
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    }, "type" | "default"> & {
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: PropType<HTMLElement>;
+                            }>>, {}>;
+                        }>;
+                        default: string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        }) | {
+                            readonly component: vue.DefineComponent<{
+                                target: PropType<HTMLElement>;
+                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                                target: PropType<HTMLElement>;
+                            }>>, {}>;
+                        };
+                    };
+                    modelValue: BooleanConstructor;
+                    id: StringConstructor;
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+                    absolute: boolean;
+                    location: Anchor;
+                    origin: "auto" | Anchor | "overlap";
+                    transition: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    });
+                    zIndex: string | number;
+                    eager: boolean;
+                    disabled: boolean;
+                    modelValue: boolean;
+                    activatorProps: Record<string, any>;
+                    openOnClick: boolean;
+                    openOnHover: boolean;
+                    openOnFocus: boolean;
+                    closeOnContentClick: boolean;
+                    locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined);
+                    scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                    contained: boolean;
+                    noClickAnimation: boolean;
+                    persistent: boolean;
+                    closeOnBack: boolean;
+                    scrim: string | boolean;
+                }> & Omit<Readonly<vue.ExtractPropTypes<{
+                    eager: BooleanConstructor;
+                    transition: {
+                        type: PropType<string | boolean | (vue.TransitionProps & {
+                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                        })>;
+                        default: string;
+                        validator: (val: unknown) => boolean;
+                    };
+                    theme: StringConstructor;
+                    scrollStrategy: {
+                        type: PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    locationStrategy: {
+                        type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                            updateLocation: (e: Event) => void;
+                        } | undefined)>;
+                        default: string;
+                        validator: (val: any) => boolean;
+                    };
+                    location: {
+                        type: PropType<Anchor>;
+                        default: string;
+                    };
+                    origin: {
+                        type: PropType<"auto" | Anchor | "overlap">;
+                        default: string;
+                    };
+                    offset: (StringConstructor | NumberConstructor)[];
+                    height: (StringConstructor | NumberConstructor)[];
+                    maxHeight: (StringConstructor | NumberConstructor)[];
+                    maxWidth: (StringConstructor | NumberConstructor)[];
+                    minHeight: (StringConstructor | NumberConstructor)[];
+                    minWidth: (StringConstructor | NumberConstructor)[];
+                    width: (StringConstructor | NumberConstructor)[];
+                    closeDelay: (StringConstructor | NumberConstructor)[];
+                    openDelay: (StringConstructor | NumberConstructor)[];
+                    activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+                    activatorProps: {
+                        type: PropType<Record<string, any>>;
+                        default: () => {};
+                    };
+                    openOnClick: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    openOnHover: BooleanConstructor;
+                    openOnFocus: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    closeOnContentClick: BooleanConstructor;
+                    absolute: BooleanConstructor;
+                    attach: PropType<string | boolean | Element>;
+                    closeOnBack: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    contained: BooleanConstructor;
+                    contentClass: null;
+                    contentProps: null;
+                    disabled: BooleanConstructor;
+                    noClickAnimation: BooleanConstructor;
+                    modelValue: BooleanConstructor;
+                    persistent: BooleanConstructor;
+                    scrim: {
+                        type: (StringConstructor | BooleanConstructor)[];
+                        default: boolean;
+                    };
+                    zIndex: {
+                        type: (StringConstructor | NumberConstructor)[];
+                        default: number;
+                    };
+                } & SlotsToProps<MakeSlots<{
+                    default: [{
+                        isActive: vue.Ref<boolean>;
+                    }];
+                    activator: [{
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }];
+                }>>>> & {
+                    onAfterLeave?: (() => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+            };
             modelValue: {
                 type: null;
                 default: () => never[];
@@ -11057,18 +12869,22 @@ declare const VSelect: {
                 index: number;
             }];
             'no-data': [];
-        }>>>>, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+        }>>>> & {
+            "onUpdate:menu"?: ((val: boolean) => any) | undefined;
+        }, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
             'update:modelValue': (val: any) => boolean;
+            'update:menu': (val: boolean) => boolean;
         }, "multiple" | "items" | "update:modelValue" | "modelValue" | "returnObject">, string, {
             transition: string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
             }) | {
                 component: vue.DefineComponent<{
-                    target: vue.PropType<HTMLElement>;
+                    target: PropType<HTMLElement>;
                 }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                    target: vue.PropType<HTMLElement>;
+                    target: PropType<HTMLElement>;
                 }>>, {}>;
             };
+            menu: boolean;
             eager: boolean;
             noDataText: string;
             itemTitle: SelectItemKey;
@@ -11103,52 +12919,52 @@ declare const VSelect: {
         $watch(source: string | Function, cb: Function, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
     } & Readonly<vue.ExtractPropTypes<Omit<{
         transition: Omit<{
-            type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            type: PropType<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
             })>;
             default: string;
             validator: (val: unknown) => boolean;
         }, "type" | "default"> & {
-            type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            type: PropType<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
             }) | {
                 component: vue.DefineComponent<{
-                    target: vue.PropType<HTMLElement>;
+                    target: PropType<HTMLElement>;
                 }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                    target: vue.PropType<HTMLElement>;
+                    target: PropType<HTMLElement>;
                 }>>, {}>;
             }>;
             default: string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
             }) | {
                 component: vue.DefineComponent<{
-                    target: vue.PropType<HTMLElement>;
+                    target: PropType<HTMLElement>;
                 }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                    target: vue.PropType<HTMLElement>;
+                    target: PropType<HTMLElement>;
                 }>>, {}>;
             };
         };
         items: {
-            type: vue.PropType<any[]>;
+            type: PropType<any[]>;
             default: () => never[];
         };
         itemTitle: {
-            type: vue.PropType<SelectItemKey>;
+            type: PropType<SelectItemKey>;
             default: string;
         };
         itemValue: {
-            type: vue.PropType<SelectItemKey>;
+            type: PropType<SelectItemKey>;
             default: string;
         };
         itemChildren: Omit<{
-            type: vue.PropType<SelectItemKey>;
+            type: PropType<SelectItemKey>;
             default: string;
         }, "type" | "default"> & {
-            type: vue.PropType<SelectItemKey>;
+            type: PropType<SelectItemKey>;
             default: SelectItemKey;
         };
         itemProps: {
-            type: vue.PropType<SelectItemKey>;
+            type: PropType<SelectItemKey>;
             default: string;
         };
         returnObject: BooleanConstructor;
@@ -11157,10 +12973,176 @@ declare const VSelect: {
         eager: BooleanConstructor;
         hideNoData: BooleanConstructor;
         hideSelected: BooleanConstructor;
+        menu: BooleanConstructor;
         menuIcon: {
-            type: vue.PropType<IconValue>;
+            type: PropType<IconValue>;
             default: string;
         };
+        menuProps: {
+            type: PropType<Partial<{
+                transition: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                }) | {
+                    readonly component: vue.DefineComponent<{
+                        target: PropType<HTMLElement>;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                        target: PropType<HTMLElement>;
+                    }>>, {}>;
+                };
+                modelValue: boolean;
+            }> & Omit<Readonly<vue.ExtractPropTypes<{
+                transition: Omit<{
+                    type: PropType<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    })>;
+                    default: string;
+                    validator: (val: unknown) => boolean;
+                }, "type" | "default"> & {
+                    type: PropType<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: PropType<HTMLElement>;
+                        }>>, {}>;
+                    }>;
+                    default: string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    }) | {
+                        readonly component: vue.DefineComponent<{
+                            target: PropType<HTMLElement>;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                            target: PropType<HTMLElement>;
+                        }>>, {}>;
+                    };
+                };
+                modelValue: BooleanConstructor;
+                id: StringConstructor;
+            } & SlotsToProps<MakeSlots<{
+                default: [{
+                    isActive: vue.Ref<boolean>;
+                }];
+                activator: [{
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }];
+            }>>>> & {
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+                absolute: boolean;
+                location: Anchor;
+                origin: "auto" | Anchor | "overlap";
+                transition: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                });
+                zIndex: string | number;
+                eager: boolean;
+                disabled: boolean;
+                modelValue: boolean;
+                activatorProps: Record<string, any>;
+                openOnClick: boolean;
+                openOnHover: boolean;
+                openOnFocus: boolean;
+                closeOnContentClick: boolean;
+                locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined);
+                scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+                contained: boolean;
+                noClickAnimation: boolean;
+                persistent: boolean;
+                closeOnBack: boolean;
+                scrim: string | boolean;
+            }> & Omit<Readonly<vue.ExtractPropTypes<{
+                eager: BooleanConstructor;
+                transition: {
+                    type: PropType<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    })>;
+                    default: string;
+                    validator: (val: unknown) => boolean;
+                };
+                theme: StringConstructor;
+                scrollStrategy: {
+                    type: PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                    default: string;
+                    validator: (val: any) => boolean;
+                };
+                locationStrategy: {
+                    type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined)>;
+                    default: string;
+                    validator: (val: any) => boolean;
+                };
+                location: {
+                    type: PropType<Anchor>;
+                    default: string;
+                };
+                origin: {
+                    type: PropType<"auto" | Anchor | "overlap">;
+                    default: string;
+                };
+                offset: (StringConstructor | NumberConstructor)[];
+                height: (StringConstructor | NumberConstructor)[];
+                maxHeight: (StringConstructor | NumberConstructor)[];
+                maxWidth: (StringConstructor | NumberConstructor)[];
+                minHeight: (StringConstructor | NumberConstructor)[];
+                minWidth: (StringConstructor | NumberConstructor)[];
+                width: (StringConstructor | NumberConstructor)[];
+                closeDelay: (StringConstructor | NumberConstructor)[];
+                openDelay: (StringConstructor | NumberConstructor)[];
+                activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+                activatorProps: {
+                    type: PropType<Record<string, any>>;
+                    default: () => {};
+                };
+                openOnClick: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                openOnHover: BooleanConstructor;
+                openOnFocus: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                closeOnContentClick: BooleanConstructor;
+                absolute: BooleanConstructor;
+                attach: PropType<string | boolean | Element>;
+                closeOnBack: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                contained: BooleanConstructor;
+                contentClass: null;
+                contentProps: null;
+                disabled: BooleanConstructor;
+                noClickAnimation: BooleanConstructor;
+                modelValue: BooleanConstructor;
+                persistent: BooleanConstructor;
+                scrim: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                zIndex: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: number;
+                };
+            } & SlotsToProps<MakeSlots<{
+                default: [{
+                    isActive: vue.Ref<boolean>;
+                }];
+                activator: [{
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }];
+            }>>>> & {
+                onAfterLeave?: (() => any) | undefined;
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+        };
         modelValue: {
             type: null;
             default: () => never[];
@@ -11194,58 +13176,60 @@ declare const VSelect: {
             index: number;
         }];
         'no-data': [];
-    }>>>> & vue.ShallowUnwrapRef<any> & {} & vue.ComponentCustomProperties;
+    }>>>> & {
+        "onUpdate:menu"?: ((val: boolean) => any) | undefined;
+    } & vue.ShallowUnwrapRef<any> & {} & vue.ComponentCustomProperties;
     __isFragment?: undefined;
     __isTeleport?: undefined;
     __isSuspense?: undefined;
 } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
     transition: Omit<{
-        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+        type: PropType<string | boolean | (vue.TransitionProps & {
             component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
         })>;
         default: string;
         validator: (val: unknown) => boolean;
     }, "type" | "default"> & {
-        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+        type: PropType<string | boolean | (vue.TransitionProps & {
             component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
         }) | {
             component: vue.DefineComponent<{
-                target: vue.PropType<HTMLElement>;
+                target: PropType<HTMLElement>;
             }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                target: vue.PropType<HTMLElement>;
+                target: PropType<HTMLElement>;
             }>>, {}>;
         }>;
         default: string | boolean | (vue.TransitionProps & {
             component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
         }) | {
             component: vue.DefineComponent<{
-                target: vue.PropType<HTMLElement>;
+                target: PropType<HTMLElement>;
             }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                target: vue.PropType<HTMLElement>;
+                target: PropType<HTMLElement>;
             }>>, {}>;
         };
     };
     items: {
-        type: vue.PropType<any[]>;
+        type: PropType<any[]>;
         default: () => never[];
     };
     itemTitle: {
-        type: vue.PropType<SelectItemKey>;
+        type: PropType<SelectItemKey>;
         default: string;
     };
     itemValue: {
-        type: vue.PropType<SelectItemKey>;
+        type: PropType<SelectItemKey>;
         default: string;
     };
     itemChildren: Omit<{
-        type: vue.PropType<SelectItemKey>;
+        type: PropType<SelectItemKey>;
         default: string;
     }, "type" | "default"> & {
-        type: vue.PropType<SelectItemKey>;
+        type: PropType<SelectItemKey>;
         default: SelectItemKey;
     };
     itemProps: {
-        type: vue.PropType<SelectItemKey>;
+        type: PropType<SelectItemKey>;
         default: string;
     };
     returnObject: BooleanConstructor;
@@ -11254,10 +13238,176 @@ declare const VSelect: {
     eager: BooleanConstructor;
     hideNoData: BooleanConstructor;
     hideSelected: BooleanConstructor;
+    menu: BooleanConstructor;
     menuIcon: {
-        type: vue.PropType<IconValue>;
+        type: PropType<IconValue>;
         default: string;
     };
+    menuProps: {
+        type: PropType<Partial<{
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            }) | {
+                readonly component: vue.DefineComponent<{
+                    target: PropType<HTMLElement>;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                    target: PropType<HTMLElement>;
+                }>>, {}>;
+            };
+            modelValue: boolean;
+        }> & Omit<Readonly<vue.ExtractPropTypes<{
+            transition: Omit<{
+                type: PropType<string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                })>;
+                default: string;
+                validator: (val: unknown) => boolean;
+            }, "type" | "default"> & {
+                type: PropType<string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                }) | {
+                    readonly component: vue.DefineComponent<{
+                        target: PropType<HTMLElement>;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                        target: PropType<HTMLElement>;
+                    }>>, {}>;
+                }>;
+                default: string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                }) | {
+                    readonly component: vue.DefineComponent<{
+                        target: PropType<HTMLElement>;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
+                        target: PropType<HTMLElement>;
+                    }>>, {}>;
+                };
+            };
+            modelValue: BooleanConstructor;
+            id: StringConstructor;
+        } & SlotsToProps<MakeSlots<{
+            default: [{
+                isActive: vue.Ref<boolean>;
+            }];
+            activator: [{
+                isActive: boolean;
+                props: Record<string, any>;
+            }];
+        }>>>> & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "transition" | "modelValue"> & Partial<{
+            absolute: boolean;
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            });
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            activatorProps: Record<string, any>;
+            openOnClick: boolean;
+            openOnHover: boolean;
+            openOnFocus: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined);
+            scrollStrategy: "none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void);
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            closeOnBack: boolean;
+            scrim: string | boolean;
+        }> & Omit<Readonly<vue.ExtractPropTypes<{
+            eager: BooleanConstructor;
+            transition: {
+                type: PropType<string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                })>;
+                default: string;
+                validator: (val: unknown) => boolean;
+            };
+            theme: StringConstructor;
+            scrollStrategy: {
+                type: PropType<"none" | "block" | "close" | "reposition" | ((data: ScrollStrategyData) => void)>;
+                default: string;
+                validator: (val: any) => boolean;
+            };
+            locationStrategy: {
+                type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined)>;
+                default: string;
+                validator: (val: any) => boolean;
+            };
+            location: {
+                type: PropType<Anchor>;
+                default: string;
+            };
+            origin: {
+                type: PropType<"auto" | Anchor | "overlap">;
+                default: string;
+            };
+            offset: (StringConstructor | NumberConstructor)[];
+            height: (StringConstructor | NumberConstructor)[];
+            maxHeight: (StringConstructor | NumberConstructor)[];
+            maxWidth: (StringConstructor | NumberConstructor)[];
+            minHeight: (StringConstructor | NumberConstructor)[];
+            minWidth: (StringConstructor | NumberConstructor)[];
+            width: (StringConstructor | NumberConstructor)[];
+            closeDelay: (StringConstructor | NumberConstructor)[];
+            openDelay: (StringConstructor | NumberConstructor)[];
+            activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
+            activatorProps: {
+                type: PropType<Record<string, any>>;
+                default: () => {};
+            };
+            openOnClick: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            openOnHover: BooleanConstructor;
+            openOnFocus: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            closeOnContentClick: BooleanConstructor;
+            absolute: BooleanConstructor;
+            attach: PropType<string | boolean | Element>;
+            closeOnBack: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            contained: BooleanConstructor;
+            contentClass: null;
+            contentProps: null;
+            disabled: BooleanConstructor;
+            noClickAnimation: BooleanConstructor;
+            modelValue: BooleanConstructor;
+            persistent: BooleanConstructor;
+            scrim: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            zIndex: {
+                type: (StringConstructor | NumberConstructor)[];
+                default: number;
+            };
+        } & SlotsToProps<MakeSlots<{
+            default: [{
+                isActive: vue.Ref<boolean>;
+            }];
+            activator: [{
+                isActive: boolean;
+                props: Record<string, any>;
+            }];
+        }>>>> & {
+            onAfterLeave?: (() => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            "onClick:outside"?: ((e: MouseEvent) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "absolute" | "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "contained" | "noClickAnimation" | "persistent" | "closeOnBack" | "scrim">>;
+    };
     modelValue: {
         type: null;
         default: () => never[];
@@ -11291,18 +13441,22 @@ declare const VSelect: {
         index: number;
     }];
     'no-data': [];
-}>>>>, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+}>>>> & {
+    "onUpdate:menu"?: ((val: boolean) => any) | undefined;
+}, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
     'update:modelValue': (val: any) => boolean;
+    'update:menu': (val: boolean) => boolean;
 }, "multiple" | "items" | "update:modelValue" | "modelValue" | "returnObject">, string, {
     transition: string | boolean | (vue.TransitionProps & {
         component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
     }) | {
         component: vue.DefineComponent<{
-            target: vue.PropType<HTMLElement>;
+            target: PropType<HTMLElement>;
         }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-            target: vue.PropType<HTMLElement>;
+            target: PropType<HTMLElement>;
         }>>, {}>;
     };
+    menu: boolean;
     eager: boolean;
     noDataText: string;
     itemTitle: SelectItemKey;
@@ -11837,6 +13991,7 @@ declare const VSlider: vue.DefineComponent<{
         type: vue.PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     density: {
         type: vue.PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -11933,6 +14088,7 @@ declare const VSlider: vue.DefineComponent<{
         type: vue.PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     density: {
         type: vue.PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -12051,7 +14207,7 @@ declare const VSnackbar: vue.DefineComponent<{
     };
     color: StringConstructor;
     variant: {
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -12098,7 +14254,7 @@ declare const VSnackbar: vue.DefineComponent<{
     };
     color: StringConstructor;
     variant: {
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -12137,7 +14293,7 @@ declare const VSnackbar: vue.DefineComponent<{
     vertical: boolean;
     contentClass: string;
     rounded: string | number | boolean;
-    variant: "text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text";
+    variant: "flat" | "text" | "elevated" | "tonal" | "outlined" | "plain";
     modelValue: boolean;
     app: boolean;
     multiLine: boolean;
@@ -12190,6 +14346,7 @@ declare const VSwitch: vue.DefineComponent<{
         type: vue.PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     appendIcon: vue.PropType<IconValue>;
     prependIcon: vue.PropType<IconValue>;
     hideDetails: vue.PropType<boolean | "auto">;
@@ -12257,6 +14414,7 @@ declare const VSwitch: vue.DefineComponent<{
         type: vue.PropType<ValidationRule[]>;
         default: () => never[];
     };
+    validationValue: null;
     appendIcon: vue.PropType<IconValue>;
     prependIcon: vue.PropType<IconValue>;
     hideDetails: vue.PropType<boolean | "auto">;
@@ -12292,10 +14450,10 @@ declare const VSwitch: vue.DefineComponent<{
     messages: string | string[];
     density: "default" | "compact" | "comfortable" | null;
     ripple: boolean;
-    valueComparator: typeof deepEqual;
     errorMessages: string | string[];
     maxErrors: string | number;
     rules: ValidationRule[];
+    valueComparator: typeof deepEqual;
 }>;
 declare type VSwitch = InstanceType<typeof VSwitch>;
 
@@ -12580,7 +14738,7 @@ declare const VTextarea: vue.DefineComponent<{
     reverse: BooleanConstructor;
     singleLine: BooleanConstructor;
     variant: {
-        type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+        type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -12599,6 +14757,7 @@ declare const VTextarea: vue.DefineComponent<{
         default: () => never[];
     };
     modelValue: null;
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -12638,7 +14797,7 @@ declare const VTextarea: vue.DefineComponent<{
         validator: (v: any) => boolean;
     };
     suffix: StringConstructor;
-}, {
+}, HTMLInputElement & {
     $: vue.ComponentInternalInstance;
     $data: {};
     $props: Partial<{
@@ -12669,6 +14828,7 @@ declare const VTextarea: vue.DefineComponent<{
             default: () => never[];
         };
         modelValue: null;
+        validationValue: null;
         density: {
             type: PropType<"default" | "compact" | "comfortable" | null>;
             default: string;
@@ -12726,6 +14886,7 @@ declare const VTextarea: vue.DefineComponent<{
             default: () => never[];
         };
         modelValue: null;
+        validationValue: null;
         density: {
             type: PropType<"default" | "compact" | "comfortable" | null>;
             default: string;
@@ -12805,6 +14966,7 @@ declare const VTextarea: vue.DefineComponent<{
         default: () => never[];
     };
     modelValue: null;
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -12841,7 +15003,7 @@ declare const VTextarea: vue.DefineComponent<{
         append: [VInputSlot];
         details: [VInputSlot];
     }>;
-} & HTMLInputElement, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     'click:clear': (e: MouseEvent) => true;
     'click:control': (e: MouseEvent) => true;
     'update:modelValue': (val: string) => true;
@@ -12866,7 +15028,7 @@ declare const VTextarea: vue.DefineComponent<{
     reverse: BooleanConstructor;
     singleLine: BooleanConstructor;
     variant: {
-        type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+        type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -12885,6 +15047,7 @@ declare const VTextarea: vue.DefineComponent<{
         default: () => never[];
     };
     modelValue: null;
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -12939,7 +15102,7 @@ declare const VTextarea: vue.DefineComponent<{
     readonly: boolean;
     messages: string | string[];
     density: "default" | "compact" | "comfortable" | null;
-    variant: "filled" | "outlined" | "plain" | "contained" | "underlined";
+    variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
     errorMessages: string | string[];
     maxErrors: string | number;
     rules: ValidationRule[];
@@ -12973,7 +15136,7 @@ declare const VTextField: {
             readonly: boolean;
             messages: string | string[];
             density: "default" | "compact" | "comfortable" | null;
-            variant: "filled" | "outlined" | "plain" | "contained" | "underlined";
+            variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
             errorMessages: string | string[];
             maxErrors: string | number;
             rules: ValidationRule[];
@@ -13006,7 +15169,7 @@ declare const VTextField: {
             reverse: BooleanConstructor;
             singleLine: BooleanConstructor;
             variant: {
-                type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+                type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
                 default: string;
                 validator: (v: any) => boolean;
             };
@@ -13025,6 +15188,7 @@ declare const VTextField: {
                 default: () => never[];
             };
             modelValue: null;
+            validationValue: null;
             density: {
                 type: PropType<"default" | "compact" | "comfortable" | null>;
                 default: string;
@@ -13109,7 +15273,7 @@ declare const VTextField: {
             reverse: BooleanConstructor;
             singleLine: BooleanConstructor;
             variant: {
-                type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+                type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
                 default: string;
                 validator: (v: any) => boolean;
             };
@@ -13128,6 +15292,7 @@ declare const VTextField: {
                 default: () => never[];
             };
             modelValue: null;
+            validationValue: null;
             density: {
                 type: PropType<"default" | "compact" | "comfortable" | null>;
                 default: string;
@@ -13177,7 +15342,7 @@ declare const VTextField: {
             "onClick:clear"?: ((e: MouseEvent) => any) | undefined;
             "onClick:control"?: ((e: MouseEvent) => any) | undefined;
             "onClick:input"?: ((e: MouseEvent) => any) | undefined;
-        }, {
+        }, HTMLInputElement & {
             $: vue.ComponentInternalInstance;
             $data: {};
             $props: Partial<{
@@ -13208,6 +15373,7 @@ declare const VTextField: {
                     default: () => never[];
                 };
                 modelValue: null;
+                validationValue: null;
                 density: {
                     type: PropType<"default" | "compact" | "comfortable" | null>;
                     default: string;
@@ -13265,6 +15431,7 @@ declare const VTextField: {
                     default: () => never[];
                 };
                 modelValue: null;
+                validationValue: null;
                 density: {
                     type: PropType<"default" | "compact" | "comfortable" | null>;
                     default: string;
@@ -13344,6 +15511,7 @@ declare const VTextField: {
                 default: () => never[];
             };
             modelValue: null;
+            validationValue: null;
             density: {
                 type: PropType<"default" | "compact" | "comfortable" | null>;
                 default: string;
@@ -13380,7 +15548,7 @@ declare const VTextField: {
                 append: [VInputSlot];
                 details: [VInputSlot];
             }>;
-        } & HTMLInputElement, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
             'click:clear': (e: MouseEvent) => boolean;
             'click:control': (e: MouseEvent) => boolean;
             'click:input': (e: MouseEvent) => boolean;
@@ -13397,7 +15565,7 @@ declare const VTextField: {
             readonly: boolean;
             messages: string | string[];
             density: "default" | "compact" | "comfortable" | null;
-            variant: "filled" | "outlined" | "plain" | "contained" | "underlined";
+            variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
             errorMessages: string | string[];
             maxErrors: string | number;
             rules: ValidationRule[];
@@ -13450,7 +15618,7 @@ declare const VTextField: {
         reverse: BooleanConstructor;
         singleLine: BooleanConstructor;
         variant: {
-            type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+            type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
             default: string;
             validator: (v: any) => boolean;
         };
@@ -13469,6 +15637,7 @@ declare const VTextField: {
             default: () => never[];
         };
         modelValue: null;
+        validationValue: null;
         density: {
             type: PropType<"default" | "compact" | "comfortable" | null>;
             default: string;
@@ -13518,7 +15687,7 @@ declare const VTextField: {
         "onClick:clear"?: ((e: MouseEvent) => any) | undefined;
         "onClick:control"?: ((e: MouseEvent) => any) | undefined;
         "onClick:input"?: ((e: MouseEvent) => any) | undefined;
-    } & vue.ShallowUnwrapRef<{
+    } & vue.ShallowUnwrapRef<HTMLInputElement & {
         $: vue.ComponentInternalInstance;
         $data: {};
         $props: Partial<{
@@ -13549,6 +15718,7 @@ declare const VTextField: {
                 default: () => never[];
             };
             modelValue: null;
+            validationValue: null;
             density: {
                 type: PropType<"default" | "compact" | "comfortable" | null>;
                 default: string;
@@ -13606,6 +15776,7 @@ declare const VTextField: {
                 default: () => never[];
             };
             modelValue: null;
+            validationValue: null;
             density: {
                 type: PropType<"default" | "compact" | "comfortable" | null>;
                 default: string;
@@ -13685,6 +15856,7 @@ declare const VTextField: {
             default: () => never[];
         };
         modelValue: null;
+        validationValue: null;
         density: {
             type: PropType<"default" | "compact" | "comfortable" | null>;
             default: string;
@@ -13721,7 +15893,7 @@ declare const VTextField: {
             append: [VInputSlot];
             details: [VInputSlot];
         }>;
-    } & HTMLInputElement> & {} & vue.ComponentCustomProperties;
+    }> & {} & vue.ComponentCustomProperties;
     __isFragment?: undefined;
     __isTeleport?: undefined;
     __isSuspense?: undefined;
@@ -13746,7 +15918,7 @@ declare const VTextField: {
     reverse: BooleanConstructor;
     singleLine: BooleanConstructor;
     variant: {
-        type: PropType<"filled" | "outlined" | "plain" | "contained" | "underlined">;
+        type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo">;
         default: string;
         validator: (v: any) => boolean;
     };
@@ -13765,6 +15937,7 @@ declare const VTextField: {
         default: () => never[];
     };
     modelValue: null;
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -13814,7 +15987,7 @@ declare const VTextField: {
     "onClick:clear"?: ((e: MouseEvent) => any) | undefined;
     "onClick:control"?: ((e: MouseEvent) => any) | undefined;
     "onClick:input"?: ((e: MouseEvent) => any) | undefined;
-}, {
+}, HTMLInputElement & {
     $: vue.ComponentInternalInstance;
     $data: {};
     $props: Partial<{
@@ -13845,6 +16018,7 @@ declare const VTextField: {
             default: () => never[];
         };
         modelValue: null;
+        validationValue: null;
         density: {
             type: PropType<"default" | "compact" | "comfortable" | null>;
             default: string;
@@ -13902,6 +16076,7 @@ declare const VTextField: {
             default: () => never[];
         };
         modelValue: null;
+        validationValue: null;
         density: {
             type: PropType<"default" | "compact" | "comfortable" | null>;
             default: string;
@@ -13981,6 +16156,7 @@ declare const VTextField: {
         default: () => never[];
     };
     modelValue: null;
+    validationValue: null;
     density: {
         type: PropType<"default" | "compact" | "comfortable" | null>;
         default: string;
@@ -14017,7 +16193,7 @@ declare const VTextField: {
         append: [VInputSlot];
         details: [VInputSlot];
     }>;
-} & HTMLInputElement, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     'click:clear': (e: MouseEvent) => boolean;
     'click:control': (e: MouseEvent) => boolean;
     'click:input': (e: MouseEvent) => boolean;
@@ -14034,7 +16210,7 @@ declare const VTextField: {
     readonly: boolean;
     messages: string | string[];
     density: "default" | "compact" | "comfortable" | null;
-    variant: "filled" | "outlined" | "plain" | "contained" | "underlined";
+    variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
     errorMessages: string | string[];
     maxErrors: string | number;
     rules: ValidationRule[];
@@ -14589,7 +16765,7 @@ declare type VToolbarTitle = InstanceType<typeof VToolbarTitle>;
 declare const VToolbarItems: vue.DefineComponent<{
     color: StringConstructor;
     variant: Omit<{
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
@@ -14601,7 +16777,7 @@ declare const VToolbarItems: vue.DefineComponent<{
 }>[] | undefined, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
     color: StringConstructor;
     variant: Omit<{
-        type: vue.PropType<"text" | "outlined" | "plain" | "contained" | "contained-flat" | "contained-text">;
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
         default: string;
         validator: (v: any) => boolean;
     }, "type" | "default"> & {
@@ -14847,6 +17023,7 @@ declare const VValidation: vue.DefineComponent<{
         default: () => never[];
     };
     modelValue: null;
+    validationValue: null;
 }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
 }>[] | undefined, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
@@ -14869,6 +17046,7 @@ declare const VValidation: vue.DefineComponent<{
         default: () => never[];
     };
     modelValue: null;
+    validationValue: null;
 }>> & {
     "onUpdate:modelValue"?: ((val: any) => any) | undefined;
 }, {
@@ -15872,4 +18050,4 @@ declare const VExpandXTransition: vue.DefineComponent<{
     mode: vue.Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;
 }>>, {}>;
 
-export { VAlert, VAlertTitle, VApp, VAppBar, VAppBarNavIcon, VAppBarTitle, VAutocomplete, VAvatar, VBadge, VBanner, VBannerActions, VBannerAvatar, VBannerIcon, VBannerText, VBottomNavigation, VBreadcrumbs, VBreadcrumbsDivider, VBreadcrumbsItem, VBtn, VBtnGroup, VBtnToggle, VCard, VCardActions, VCardAvatar, VCardContent, VCardHeader, VCardHeaderText, VCardImg, VCardSubtitle, VCardText, VCardTitle, VCarousel, VCarouselItem, VCarouselReverseTransition, VCarouselTransition, VCheckbox, VChip, VChipGroup, VClassIcon, VCode, VCol, VColorPicker, VCombobox, VComponentIcon, VContainer, VCounter, VDefaultsProvider, VDialog, VDialogBottomTransition, VDialogTopTransition, VDialogTransition, VDivider, VExpandTransition, VExpandXTransition, VExpansionPanel, VExpansionPanelText, VExpansionPanelTitle, VExpansionPanels, VFabTransition, VFadeTransition, VField, VFieldLabel, VFileInput, VFooter, VForm, VHover, VIcon, VImg, VInput, VItem, VItemGroup, VKbd, VLabel, VLayout, VLayoutItem, VLazy, VLigatureIcon, VList, VListGroup, VListImg, VListItem, VListItemAction, VListItemAvatar, VListItemHeader, VListItemIcon, VListItemMedia, VListItemSubtitle, VListItemTitle, VListSubheader, VLocaleProvider, VMain, VMenu, VMenuTransition, VMessages, VNavigationDrawer, VNoSsr, VOverlay, VPagination, VParallax, VProgressCircular, VProgressLinear, VRadio, VRadioGroup, VRangeSlider, VRating, VResponsive, VRow, VScaleTransition, VScrollXReverseTransition, VScrollXTransition, VScrollYReverseTransition, VScrollYTransition, VSelect, VSelectionControl, VSelectionControlGroup, VSheet, VSlideGroup, VSlideGroupItem, VSlideGroupSymbol, VSlideXReverseTransition, VSlideXTransition, VSlideYReverseTransition, VSlideYTransition, VSlider, VSnackbar, VSpacer, VSvgIcon, VSwitch, VSystemBar, VTab, VTabReverseTransition, VTabTransition, VTable, VTabs, VTextField, VTextarea, VThemeProvider, VTimeline, VTimelineItem, VToolbar, VToolbarItems, VToolbarTitle, VTooltip, VValidation, VWindow, VWindowItem };
+export { VAlert, VAlertTitle, VApp, VAppBar, VAppBarNavIcon, VAppBarTitle, VAutocomplete, VAvatar, VBadge, VBanner, VBannerActions, VBannerAvatar, VBannerIcon, VBannerText, VBottomNavigation, VBreadcrumbs, VBreadcrumbsDivider, VBreadcrumbsItem, VBtn, VBtnGroup, VBtnToggle, VCard, VCardActions, VCardAvatar, VCardContent, VCardHeader, VCardHeaderText, VCardImg, VCardSubtitle, VCardText, VCardTitle, VCarousel, VCarouselItem, VCarouselReverseTransition, VCarouselTransition, VCheckbox, VCheckboxBtn, VChip, VChipGroup, VClassIcon, VCode, VCol, VColorPicker, VCombobox, VComponentIcon, VContainer, VCounter, VDefaultsProvider, VDialog, VDialogBottomTransition, VDialogTopTransition, VDialogTransition, VDivider, VExpandTransition, VExpandXTransition, VExpansionPanel, VExpansionPanelText, VExpansionPanelTitle, VExpansionPanels, VFabTransition, VFadeTransition, VField, VFieldLabel, VFileInput, VFooter, VForm, VHover, VIcon, VImg, VInput, VItem, VItemGroup, VKbd, VLabel, VLayout, VLayoutItem, VLazy, VLigatureIcon, VList, VListGroup, VListImg, VListItem, VListItemAction, VListItemAvatar, VListItemHeader, VListItemIcon, VListItemMedia, VListItemSubtitle, VListItemTitle, VListSubheader, VLocaleProvider, VMain, VMenu, VMenuTransition, VMessages, VNavigationDrawer, VNoSsr, VOverlay, VPagination, VParallax, VProgressCircular, VProgressLinear, VRadio, VRadioGroup, VRangeSlider, VRating, VResponsive, VRow, VScaleTransition, VScrollXReverseTransition, VScrollXTransition, VScrollYReverseTransition, VScrollYTransition, VSelect, VSelectionControl, VSelectionControlGroup, VSheet, VSlideGroup, VSlideGroupItem, VSlideGroupSymbol, VSlideXReverseTransition, VSlideXTransition, VSlideYReverseTransition, VSlideYTransition, VSlider, VSnackbar, VSpacer, VSvgIcon, VSwitch, VSystemBar, VTab, VTabReverseTransition, VTabTransition, VTable, VTabs, VTextField, VTextarea, VThemeProvider, VTimeline, VTimelineItem, VToolbar, VToolbarItems, VToolbarTitle, VTooltip, VValidation, VWindow, VWindowItem };