vuetify 3.1.4 → 3.1.5

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

@@ -3,9 +3,9 @@ import { PropType, JSXComponent, ComputedRef, Ref, EffectScope, nextTick } from
 
 declare const block: readonly ["top", "bottom"];
 declare const inline: readonly ["start", "end", "left", "right"];
-declare type Tblock = typeof block[number];
-declare type Tinline = typeof inline[number];
-declare type Anchor = Tblock | Tinline | 'center' | 'center center' | `${Tblock} ${Tinline | 'center'}` | `${Tinline} ${Tblock | 'center'}`;
+type Tblock = typeof block[number];
+type Tinline = typeof inline[number];
+type Anchor = Tblock | Tinline | 'center' | 'center center' | `${Tblock} ${Tinline | 'center'}` | `${Tinline} ${Tblock | 'center'}`;
 
 declare class Box {
     x: number;
@@ -25,8 +25,8 @@ declare class Box {
 }
 
 declare function deepEqual(a: any, b: any): boolean;
-declare type SelectItemKey = boolean | string | (string | number)[] | ((item: Record<string, any>, fallback?: any) => any);
-declare type EventProp<T = (...args: any[]) => any> = T | T[];
+type SelectItemKey = boolean | string | (string | number)[] | ((item: Record<string, any>, fallback?: any) => any);
+type EventProp<T = (...args: any[]) => any> = T | T[];
 declare const EventProp: PropType<EventProp<(...args: any[]) => any>>;
 
 interface LoaderSlotProps {
@@ -34,13 +34,13 @@ interface LoaderSlotProps {
     isActive: boolean;
 }
 
-declare type IconValue = string | JSXComponent;
+type IconValue = string | JSXComponent;
 declare const IconValue: PropType<IconValue>;
 
-declare type Density = null | 'default' | 'comfortable' | 'compact';
+type Density = null | 'default' | 'comfortable' | 'compact';
 
-declare type ValidationResult = string | boolean;
-declare type ValidationRule = ValidationResult | PromiseLike<ValidationResult> | ((value: any) => ValidationResult) | ((value: any) => PromiseLike<ValidationResult>);
+type ValidationResult = string | boolean;
+type ValidationRule = ValidationResult | PromiseLike<ValidationResult> | ((value: any) => ValidationResult) | ((value: any) => PromiseLike<ValidationResult>);
 
 interface VInputSlot {
     id: ComputedRef<string>;
@@ -71,7 +71,7 @@ interface ScrollStrategyData {
     isActive: Ref<boolean>;
     updateLocation: Ref<((e: Event) => void) | undefined>;
 }
-declare type ScrollStrategyFn = (data: ScrollStrategyData, props: StrategyProps$1, scope: EffectScope) => void;
+type ScrollStrategyFn = (data: ScrollStrategyData, props: StrategyProps$1, scope: EffectScope) => void;
 declare const scrollStrategies: {
     none: null;
     close: typeof closeScrollStrategy;
@@ -92,7 +92,7 @@ interface LocationStrategyData {
     isActive: Ref<boolean>;
     isRtl: Ref<boolean>;
 }
-declare type LocationStrategyFn = (data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>) => undefined | {
+type LocationStrategyFn = (data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>) => undefined | {
     updateLocation: (e: Event) => void;
 };
 declare const locationStrategies: {
@@ -138,15 +138,15 @@ interface InternalItem<T = any> {
  * - single match (start, end)
  * - multiple matches (start, end), probably shouldn't overlap
  */
-declare type FilterMatch = boolean | number | [number, number] | [number, number][];
-declare type FilterFunction = (value: string, query: string, item?: any) => FilterMatch;
-declare type FilterKeyFunctions = Record<string, FilterFunction>;
-declare type FilterKeys = string | string[];
-declare type FilterMode = 'some' | 'every' | 'union' | 'intersection';
+type FilterMatch = boolean | number | [number, number] | [number, number][];
+type FilterFunction = (value: string, query: string, item?: any) => FilterMatch;
+type FilterKeyFunctions = Record<string, FilterFunction>;
+type FilterKeys = string | string[];
+type FilterMode = 'some' | 'every' | 'union' | 'intersection';
 
-declare type Primitive = string | number | boolean | symbol;
-declare type Val<T, ReturnObject extends boolean> = T extends Primitive ? T : (ReturnObject extends true ? T : any);
-declare type Value<T, ReturnObject extends boolean, Multiple extends boolean> = Multiple extends true ? readonly Val<T, ReturnObject>[] : Val<T, ReturnObject>;
+type Primitive = string | number | boolean | symbol;
+type Val<T, ReturnObject extends boolean> = T extends Primitive ? T : (ReturnObject extends true ? T : any);
+type Value<T, ReturnObject extends boolean, Multiple extends boolean> = Multiple extends true ? readonly Val<T, ReturnObject>[] : Val<T, ReturnObject>;
 declare const VAutocomplete: {
     new (...args: any[]): {
         $: vue.ComponentInternalInstance;
@@ -157,16 +157,16 @@ declare const VAutocomplete: {
             error: boolean;
             active: boolean;
             direction: "horizontal" | "vertical";
-            transition: string | boolean | (vue.TransitionProps & {
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-            });
+            })>;
             menu: boolean;
             autofocus: boolean;
             eager: boolean;
             disabled: boolean;
             readonly: boolean;
-            messages: string | string[];
             noDataText: string;
+            messages: string | string[];
             density: Density;
             variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
             clearIcon: IconValue;
@@ -183,7 +183,7 @@ declare const VAutocomplete: {
             valueComparator: typeof deepEqual;
             itemTitle: SelectItemKey;
             itemValue: SelectItemKey;
-            itemChildren: SelectItemKey;
+            itemChildren: NonNullable<SelectItemKey>;
             itemProps: SelectItemKey;
             chips: boolean;
             closableChips: boolean;
@@ -193,7 +193,7 @@ declare const VAutocomplete: {
             openOnClear: boolean;
             filterMode: FilterMode;
             noFilter: boolean;
-            filterKeys: (string & {}) | FilterKeys;
+            filterKeys: NonNullable<FilterKeys>;
         }> & Omit<Readonly<vue.ExtractPropTypes<Omit<{
             transition: Omit<{
                 type: vue.PropType<string | boolean | (vue.TransitionProps & {
@@ -202,12 +202,12 @@ declare const VAutocomplete: {
                 default: string;
                 validator: (val: unknown) => boolean;
             }, "type" | "default"> & {
-                type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                type: vue.PropType<NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                })>;
-                default: string | boolean | (vue.TransitionProps & {
+                })>>;
+                default: NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                });
+                })>;
             };
             reverse: BooleanConstructor;
             type: {
@@ -232,11 +232,11 @@ declare const VAutocomplete: {
             readonly: BooleanConstructor;
             placeholder: StringConstructor;
             theme: StringConstructor;
+            counter: vue.PropType<string | number | true>;
             messages: {
                 type: vue.PropType<string | string[]>;
                 default: () => never[];
             };
-            counter: vue.PropType<string | number | true>;
             density: {
                 type: vue.PropType<Density>;
                 default: string;
@@ -304,8 +304,8 @@ declare const VAutocomplete: {
                 type: vue.PropType<SelectItemKey>;
                 default: string;
             }, "type" | "default"> & {
-                type: vue.PropType<SelectItemKey>;
-                default: SelectItemKey;
+                type: vue.PropType<NonNullable<SelectItemKey>>;
+                default: NonNullable<SelectItemKey>;
             };
             itemProps: {
                 type: vue.PropType<SelectItemKey>;
@@ -326,154 +326,118 @@ declare const VAutocomplete: {
                 type: vue.PropType<Partial<{
                     location: Anchor;
                     origin: "auto" | Anchor | "overlap";
-                    transition: string | boolean | (vue.TransitionProps & {
+                    transition: NonNullable<string | boolean | (vue.TransitionProps & {
                         component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                    }) | {
-                        component: vue.DefineComponent<{
-                            target: vue.PropType<HTMLElement>;
-                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                            target: vue.PropType<HTMLElement>;
-                        }>>, {}>;
+                    })> | {
+                        component: vue.DefineComponent<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, {}>;
                     };
                     zIndex: string | number;
                     eager: boolean;
                     disabled: boolean;
                     modelValue: boolean;
-                    closeDelay: string | number;
-                    openDelay: string | number;
+                    closeDelay: NonNullable<string | number>;
+                    openDelay: NonNullable<string | number>;
                     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>>) => {
+                    locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
                         updateLocation: (e: Event) => void;
-                    } | undefined);
-                    scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+                    } | undefined)>;
+                    scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
                     closeOnBack: boolean;
                     contained: boolean;
                     noClickAnimation: boolean;
                     persistent: boolean;
-                    scrim: string | boolean;
-                }> & Omit<Readonly<vue.ExtractPropTypes<Omit<{
-                    offset: vue.PropType<string | number | number[] | undefined>;
-                    location: {
-                        type: vue.PropType<Anchor>;
-                        default: string;
-                    };
-                    origin: {
-                        type: vue.PropType<"auto" | Anchor | "overlap">;
-                        default: string;
-                    };
-                    height: (StringConstructor | NumberConstructor)[];
-                    width: (StringConstructor | NumberConstructor)[];
-                    maxHeight: (StringConstructor | NumberConstructor)[];
-                    maxWidth: (StringConstructor | NumberConstructor)[];
-                    minHeight: (StringConstructor | NumberConstructor)[];
-                    minWidth: (StringConstructor | NumberConstructor)[];
-                    transition: Omit<{
-                        type: vue.PropType<string | boolean | (vue.TransitionProps & {
-                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                        })>;
-                        default: string;
-                        validator: (val: unknown) => boolean;
-                    }, "type" | "default"> & {
-                        type: vue.PropType<string | boolean | (vue.TransitionProps & {
-                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                        }) | {
-                            component: vue.DefineComponent<{
-                                target: vue.PropType<HTMLElement>;
-                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, 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;
-                        }) | {
-                            component: vue.DefineComponent<{
-                                target: vue.PropType<HTMLElement>;
-                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                                target: vue.PropType<HTMLElement>;
-                            }>>, {}>;
-                        };
-                    };
-                    zIndex: {
-                        type: (StringConstructor | NumberConstructor)[];
-                        default: number;
-                    };
-                    eager: BooleanConstructor;
-                    disabled: BooleanConstructor;
-                    theme: StringConstructor;
-                    contentClass: null;
-                    modelValue: BooleanConstructor;
-                    activator: vue.PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
-                    closeDelay: {
-                        type: vue.PropType<string | number>;
-                        default: string | number;
-                    };
-                    openDelay: {
-                        type: vue.PropType<string | number>;
-                        default: string | number;
-                    };
-                    activatorProps: {
-                        type: vue.PropType<Record<string, any>>;
-                        default: () => {};
-                    };
-                    openOnClick: {
-                        type: BooleanConstructor;
-                        default: undefined;
-                    };
-                    openOnHover: BooleanConstructor;
-                    openOnFocus: {
-                        type: BooleanConstructor;
-                        default: undefined;
-                    };
-                    closeOnContentClick: {
-                        type: vue.PropType<boolean>;
-                        default: boolean;
-                    };
-                    locationStrategy: Omit<{
-                        type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                            updateLocation: (e: Event) => void;
-                        } | undefined)>;
-                        default: string;
-                        validator: (val: any) => boolean;
-                    }, "type" | "default"> & {
-                        type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                            updateLocation: (e: Event) => void;
-                        } | undefined)>;
-                        default: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                            updateLocation: (e: Event) => void;
-                        } | undefined);
-                    };
-                    scrollStrategy: Omit<{
-                        type: vue.PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                        default: string;
-                        validator: (val: any) => boolean;
-                    }, "type" | "default"> & {
-                        type: vue.PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                        default: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
-                    };
-                    closeOnBack: {
-                        type: BooleanConstructor;
-                        default: boolean;
-                    };
-                    contained: BooleanConstructor;
-                    contentProps: null;
-                    noClickAnimation: BooleanConstructor;
-                    persistent: BooleanConstructor;
-                    scrim: Omit<{
-                        type: (StringConstructor | BooleanConstructor)[];
-                        default: boolean;
-                    }, "type" | "default"> & {
-                        type: vue.PropType<string | boolean>;
-                        default: string | boolean;
+                    scrim: NonNullable<string | boolean>;
+                }> & Omit<{
+                    location: Anchor;
+                    origin: "auto" | Anchor | "overlap";
+                    transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    })> | {
+                        component: vue.DefineComponent<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, {}>;
                     };
-                    attach: vue.PropType<string | boolean | Element>;
-                    id: StringConstructor;
-                }, "$children" | "v-slots" | "v-slot:default" | "v-slot:activator">>> & {
-                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim"> & {
+                    zIndex: string | number;
+                    eager: boolean;
+                    disabled: boolean;
+                    modelValue: boolean;
+                    closeDelay: NonNullable<string | number>;
+                    openDelay: NonNullable<string | number>;
+                    activatorProps: Record<string, any>;
+                    openOnHover: boolean;
+                    closeOnContentClick: boolean;
+                    locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined)>;
+                    scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+                    closeOnBack: boolean;
+                    contained: boolean;
+                    noClickAnimation: boolean;
+                    persistent: boolean;
+                    scrim: NonNullable<string | boolean>;
+                } & {
+                    offset?: string | number | number[] | undefined;
+                    id?: string | undefined;
+                    height?: string | number | undefined;
+                    width?: string | number | undefined;
+                    maxHeight?: string | number | undefined;
+                    maxWidth?: string | number | undefined;
+                    minHeight?: string | number | undefined;
+                    minWidth?: string | number | undefined;
+                    theme?: string | undefined;
+                    contentClass?: any;
+                    activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+                    openOnClick?: boolean | undefined;
+                    openOnFocus?: boolean | undefined;
+                    contentProps?: any;
+                    attach?: string | boolean | Element | undefined;
+                } & {
                     $children?: {} | vue.VNodeChild | {
                         default?: ((args_0: {
                             isActive: vue.Ref<boolean>;
@@ -500,7 +464,9 @@ declare const VAutocomplete: {
                         isActive: boolean;
                         props: Record<string, any>;
                     }) => vue.VNodeChild) | undefined;
-                }>;
+                } & {
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">>;
             };
             multiple: BooleanConstructor;
             noDataText: {
@@ -515,8 +481,8 @@ declare const VAutocomplete: {
             customFilter: vue.PropType<FilterFunction>;
             customKeyFilter: vue.PropType<FilterKeyFunctions>;
             filterKeys: {
-                type: vue.PropType<(string & {}) | FilterKeys>;
-                default: (string & {}) | FilterKeys;
+                type: vue.PropType<NonNullable<FilterKeys>>;
+                default: NonNullable<FilterKeys>;
             };
             filterMode: {
                 type: vue.PropType<FilterMode>;
@@ -524,10 +490,10 @@ declare const VAutocomplete: {
             };
             noFilter: BooleanConstructor;
             search: StringConstructor;
-        }, "multiple" | "$children" | "items" | "v-slots" | "v-slot:prepend" | "v-slot:append" | "modelValue" | "onUpdate:modelValue" | "v-slot:details" | "v-slot:clear" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:label" | "v-slot:loader" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">>> & {
+        }, "multiple" | "$children" | "items" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "onUpdate:modelValue" | "v-slot:loader" | "v-slot:details" | "v-slot:clear" | "v-slot:label" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">>> & {
             "onUpdate:menu"?: ((val: boolean) => any) | undefined;
             "onUpdate:search"?: ((val: any) => any) | undefined;
-        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "reverse" | "type" | "error" | "active" | "direction" | "transition" | "menu" | "autofocus" | "eager" | "disabled" | "readonly" | "messages" | "noDataText" | "density" | "variant" | "clearIcon" | "focused" | "errorMessages" | "maxErrors" | "rules" | "clearable" | "persistentClear" | "singleLine" | "persistentHint" | "persistentPlaceholder" | "persistentCounter" | "valueComparator" | "itemTitle" | "itemValue" | "itemChildren" | "itemProps" | "chips" | "closableChips" | "hideNoData" | "hideSelected" | "menuIcon" | "openOnClear" | "filterMode" | "noFilter" | "filterKeys">;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "reverse" | "type" | "error" | "active" | "direction" | "transition" | "menu" | "autofocus" | "eager" | "disabled" | "readonly" | "noDataText" | "messages" | "density" | "variant" | "clearIcon" | "focused" | "errorMessages" | "maxErrors" | "rules" | "clearable" | "persistentClear" | "singleLine" | "persistentHint" | "persistentPlaceholder" | "persistentCounter" | "valueComparator" | "itemTitle" | "itemValue" | "itemChildren" | "itemProps" | "chips" | "closableChips" | "hideNoData" | "hideSelected" | "menuIcon" | "openOnClear" | "filterMode" | "noFilter" | "filterKeys">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -537,8 +503,8 @@ declare const VAutocomplete: {
         $slots: Readonly<{
             [name: string]: vue.Slot | undefined;
         }>;
-        $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;
+        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
         $emit: ((event: "update:menu", val: boolean) => void) & ((event: "update:search", val: any) => void);
         $el: any;
         $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
@@ -549,12 +515,12 @@ declare const VAutocomplete: {
                 default: string;
                 validator: (val: unknown) => boolean;
             }, "type" | "default"> & {
-                type: vue.PropType<string | boolean | (vue.TransitionProps & {
+                type: vue.PropType<NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                })>;
-                default: string | boolean | (vue.TransitionProps & {
+                })>>;
+                default: NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                });
+                })>;
             };
             reverse: BooleanConstructor;
             type: {
@@ -579,11 +545,11 @@ declare const VAutocomplete: {
             readonly: BooleanConstructor;
             placeholder: StringConstructor;
             theme: StringConstructor;
+            counter: vue.PropType<string | number | true>;
             messages: {
                 type: vue.PropType<string | string[]>;
                 default: () => never[];
             };
-            counter: vue.PropType<string | number | true>;
             density: {
                 type: vue.PropType<Density>;
                 default: string;
@@ -651,8 +617,8 @@ declare const VAutocomplete: {
                 type: vue.PropType<SelectItemKey>;
                 default: string;
             }, "type" | "default"> & {
-                type: vue.PropType<SelectItemKey>;
-                default: SelectItemKey;
+                type: vue.PropType<NonNullable<SelectItemKey>>;
+                default: NonNullable<SelectItemKey>;
             };
             itemProps: {
                 type: vue.PropType<SelectItemKey>;
@@ -673,154 +639,118 @@ declare const VAutocomplete: {
                 type: vue.PropType<Partial<{
                     location: Anchor;
                     origin: "auto" | Anchor | "overlap";
-                    transition: string | boolean | (vue.TransitionProps & {
+                    transition: NonNullable<string | boolean | (vue.TransitionProps & {
                         component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                    }) | {
-                        component: vue.DefineComponent<{
-                            target: vue.PropType<HTMLElement>;
-                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                            target: vue.PropType<HTMLElement>;
-                        }>>, {}>;
+                    })> | {
+                        component: vue.DefineComponent<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, {}>;
                     };
                     zIndex: string | number;
                     eager: boolean;
                     disabled: boolean;
                     modelValue: boolean;
-                    closeDelay: string | number;
-                    openDelay: string | number;
+                    closeDelay: NonNullable<string | number>;
+                    openDelay: NonNullable<string | number>;
                     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>>) => {
+                    locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
                         updateLocation: (e: Event) => void;
-                    } | undefined);
-                    scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+                    } | undefined)>;
+                    scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
                     closeOnBack: boolean;
                     contained: boolean;
                     noClickAnimation: boolean;
                     persistent: boolean;
-                    scrim: string | boolean;
-                }> & Omit<Readonly<vue.ExtractPropTypes<Omit<{
-                    offset: vue.PropType<string | number | number[] | undefined>;
-                    location: {
-                        type: vue.PropType<Anchor>;
-                        default: string;
-                    };
-                    origin: {
-                        type: vue.PropType<"auto" | Anchor | "overlap">;
-                        default: string;
-                    };
-                    height: (StringConstructor | NumberConstructor)[];
-                    width: (StringConstructor | NumberConstructor)[];
-                    maxHeight: (StringConstructor | NumberConstructor)[];
-                    maxWidth: (StringConstructor | NumberConstructor)[];
-                    minHeight: (StringConstructor | NumberConstructor)[];
-                    minWidth: (StringConstructor | NumberConstructor)[];
-                    transition: Omit<{
-                        type: vue.PropType<string | boolean | (vue.TransitionProps & {
-                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                        })>;
-                        default: string;
-                        validator: (val: unknown) => boolean;
-                    }, "type" | "default"> & {
-                        type: vue.PropType<string | boolean | (vue.TransitionProps & {
-                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                        }) | {
-                            component: vue.DefineComponent<{
-                                target: vue.PropType<HTMLElement>;
-                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, 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;
-                        }) | {
-                            component: vue.DefineComponent<{
-                                target: vue.PropType<HTMLElement>;
-                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                                target: vue.PropType<HTMLElement>;
-                            }>>, {}>;
-                        };
-                    };
-                    zIndex: {
-                        type: (StringConstructor | NumberConstructor)[];
-                        default: number;
-                    };
-                    eager: BooleanConstructor;
-                    disabled: BooleanConstructor;
-                    theme: StringConstructor;
-                    contentClass: null;
-                    modelValue: BooleanConstructor;
-                    activator: vue.PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
-                    closeDelay: {
-                        type: vue.PropType<string | number>;
-                        default: string | number;
-                    };
-                    openDelay: {
-                        type: vue.PropType<string | number>;
-                        default: string | number;
-                    };
-                    activatorProps: {
-                        type: vue.PropType<Record<string, any>>;
-                        default: () => {};
-                    };
-                    openOnClick: {
-                        type: BooleanConstructor;
-                        default: undefined;
-                    };
-                    openOnHover: BooleanConstructor;
-                    openOnFocus: {
-                        type: BooleanConstructor;
-                        default: undefined;
-                    };
-                    closeOnContentClick: {
-                        type: vue.PropType<boolean>;
-                        default: boolean;
-                    };
-                    locationStrategy: Omit<{
-                        type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                            updateLocation: (e: Event) => void;
-                        } | undefined)>;
-                        default: string;
-                        validator: (val: any) => boolean;
-                    }, "type" | "default"> & {
-                        type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                            updateLocation: (e: Event) => void;
-                        } | undefined)>;
-                        default: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                            updateLocation: (e: Event) => void;
-                        } | undefined);
-                    };
-                    scrollStrategy: Omit<{
-                        type: vue.PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                        default: string;
-                        validator: (val: any) => boolean;
-                    }, "type" | "default"> & {
-                        type: vue.PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                        default: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
-                    };
-                    closeOnBack: {
-                        type: BooleanConstructor;
-                        default: boolean;
-                    };
-                    contained: BooleanConstructor;
-                    contentProps: null;
-                    noClickAnimation: BooleanConstructor;
-                    persistent: BooleanConstructor;
-                    scrim: Omit<{
-                        type: (StringConstructor | BooleanConstructor)[];
-                        default: boolean;
-                    }, "type" | "default"> & {
-                        type: vue.PropType<string | boolean>;
-                        default: string | boolean;
+                    scrim: NonNullable<string | boolean>;
+                }> & Omit<{
+                    location: Anchor;
+                    origin: "auto" | Anchor | "overlap";
+                    transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                    })> | {
+                        component: vue.DefineComponent<{} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
+                            target?: HTMLElement | undefined;
+                        } & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, {}>;
                     };
-                    attach: vue.PropType<string | boolean | Element>;
-                    id: StringConstructor;
-                }, "$children" | "v-slots" | "v-slot:default" | "v-slot:activator">>> & {
-                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim"> & {
+                    zIndex: string | number;
+                    eager: boolean;
+                    disabled: boolean;
+                    modelValue: boolean;
+                    closeDelay: NonNullable<string | number>;
+                    openDelay: NonNullable<string | number>;
+                    activatorProps: Record<string, any>;
+                    openOnHover: boolean;
+                    closeOnContentClick: boolean;
+                    locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                        updateLocation: (e: Event) => void;
+                    } | undefined)>;
+                    scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+                    closeOnBack: boolean;
+                    contained: boolean;
+                    noClickAnimation: boolean;
+                    persistent: boolean;
+                    scrim: NonNullable<string | boolean>;
+                } & {
+                    offset?: string | number | number[] | undefined;
+                    id?: string | undefined;
+                    height?: string | number | undefined;
+                    width?: string | number | undefined;
+                    maxHeight?: string | number | undefined;
+                    maxWidth?: string | number | undefined;
+                    minHeight?: string | number | undefined;
+                    minWidth?: string | number | undefined;
+                    theme?: string | undefined;
+                    contentClass?: any;
+                    activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+                    openOnClick?: boolean | undefined;
+                    openOnFocus?: boolean | undefined;
+                    contentProps?: any;
+                    attach?: string | boolean | Element | undefined;
+                } & {
                     $children?: {} | vue.VNodeChild | {
                         default?: ((args_0: {
                             isActive: vue.Ref<boolean>;
@@ -847,7 +777,9 @@ declare const VAutocomplete: {
                         isActive: boolean;
                         props: Record<string, any>;
                     }) => vue.VNodeChild) | undefined;
-                }>;
+                } & {
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">>;
             };
             multiple: BooleanConstructor;
             noDataText: {
@@ -862,8 +794,8 @@ declare const VAutocomplete: {
             customFilter: vue.PropType<FilterFunction>;
             customKeyFilter: vue.PropType<FilterKeyFunctions>;
             filterKeys: {
-                type: vue.PropType<(string & {}) | FilterKeys>;
-                default: (string & {}) | FilterKeys;
+                type: vue.PropType<NonNullable<FilterKeys>>;
+                default: NonNullable<FilterKeys>;
             };
             filterMode: {
                 type: vue.PropType<FilterMode>;
@@ -871,40 +803,38 @@ declare const VAutocomplete: {
             };
             noFilter: BooleanConstructor;
             search: StringConstructor;
-        }, "multiple" | "$children" | "items" | "v-slots" | "v-slot:prepend" | "v-slot:append" | "modelValue" | "onUpdate:modelValue" | "v-slot:details" | "v-slot:clear" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:label" | "v-slot:loader" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">>> & {
+        }, "multiple" | "$children" | "items" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "onUpdate:modelValue" | "v-slot:loader" | "v-slot:details" | "v-slot:clear" | "v-slot:label" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">>> & {
             "onUpdate:menu"?: ((val: boolean) => any) | undefined;
             "onUpdate:search"?: ((val: any) => any) | undefined;
         }, {
             isFocused: vue.Ref<boolean>;
             isPristine: vue.Ref<boolean>;
-            menu: vue.Ref<boolean> & {
-                readonly externalValue: boolean;
-            };
+            menu: vue.WritableComputedRef<boolean>;
             search: vue.Ref<string | undefined> & {
                 readonly externalValue: string | undefined;
             };
             filteredItems: vue.Ref<InternalItem<any>[]>;
             select: (item: InternalItem) => void;
         } & Omit<any, string | number | symbol>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
-            'update:search': (val: any) => boolean;
+            'update:search': (val: any) => true;
             'update:modelValue': (val: any) => boolean;
-            'update:menu': (val: boolean) => boolean;
-        }, "multiple" | "$children" | "items" | "v-slots" | "v-slot:prepend" | "v-slot:append" | "modelValue" | "update:modelValue" | "v-slot:details" | "v-slot:clear" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:label" | "v-slot:loader" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">, string, {
+            'update:menu': (val: boolean) => true;
+        }, "multiple" | "$children" | "items" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "update:modelValue" | "v-slot:loader" | "v-slot:details" | "v-slot:clear" | "v-slot:label" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">, string, {
             reverse: boolean;
             type: string;
             error: boolean;
             active: boolean;
             direction: "horizontal" | "vertical";
-            transition: string | boolean | (vue.TransitionProps & {
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-            });
+            })>;
             menu: boolean;
             autofocus: boolean;
             eager: boolean;
             disabled: boolean;
             readonly: boolean;
-            messages: string | string[];
             noDataText: string;
+            messages: string | string[];
             density: Density;
             variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
             clearIcon: IconValue;
@@ -921,7 +851,7 @@ declare const VAutocomplete: {
             valueComparator: typeof deepEqual;
             itemTitle: SelectItemKey;
             itemValue: SelectItemKey;
-            itemChildren: SelectItemKey;
+            itemChildren: NonNullable<SelectItemKey>;
             itemProps: SelectItemKey;
             chips: boolean;
             closableChips: boolean;
@@ -931,8 +861,8 @@ declare const VAutocomplete: {
             openOnClear: boolean;
             filterMode: FilterMode;
             noFilter: boolean;
-            filterKeys: (string & {}) | FilterKeys;
-        }> & {
+            filterKeys: NonNullable<FilterKeys>;
+        }, {}, string> & {
             beforeCreate?: ((() => void) | (() => void)[]) | undefined;
             created?: ((() => void) | (() => void)[]) | undefined;
             beforeMount?: ((() => void) | (() => void)[]) | undefined;
@@ -947,11 +877,11 @@ declare const VAutocomplete: {
             unmounted?: ((() => void) | (() => void)[]) | undefined;
             renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
             renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
         };
         $forceUpdate: () => void;
         $nextTick: typeof nextTick;
-        $watch(source: string | Function, cb: Function, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
     } & Readonly<vue.ExtractPropTypes<Omit<{
         transition: Omit<{
             type: vue.PropType<string | boolean | (vue.TransitionProps & {
@@ -960,12 +890,12 @@ declare const VAutocomplete: {
             default: string;
             validator: (val: unknown) => boolean;
         }, "type" | "default"> & {
-            type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            type: vue.PropType<NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-            })>;
-            default: string | boolean | (vue.TransitionProps & {
+            })>>;
+            default: NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-            });
+            })>;
         };
         reverse: BooleanConstructor;
         type: {
@@ -990,11 +920,11 @@ declare const VAutocomplete: {
         readonly: BooleanConstructor;
         placeholder: StringConstructor;
         theme: StringConstructor;
+        counter: vue.PropType<string | number | true>;
         messages: {
             type: vue.PropType<string | string[]>;
             default: () => never[];
         };
-        counter: vue.PropType<string | number | true>;
         density: {
             type: vue.PropType<Density>;
             default: string;
@@ -1062,8 +992,8 @@ declare const VAutocomplete: {
             type: vue.PropType<SelectItemKey>;
             default: string;
         }, "type" | "default"> & {
-            type: vue.PropType<SelectItemKey>;
-            default: SelectItemKey;
+            type: vue.PropType<NonNullable<SelectItemKey>>;
+            default: NonNullable<SelectItemKey>;
         };
         itemProps: {
             type: vue.PropType<SelectItemKey>;
@@ -1084,154 +1014,118 @@ declare const VAutocomplete: {
             type: vue.PropType<Partial<{
                 location: Anchor;
                 origin: "auto" | Anchor | "overlap";
-                transition: string | boolean | (vue.TransitionProps & {
+                transition: NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                }) | {
-                    component: vue.DefineComponent<{
-                        target: vue.PropType<HTMLElement>;
-                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: vue.PropType<HTMLElement>;
-                    }>>, {}>;
+                })> | {
+                    component: vue.DefineComponent<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, {}>;
                 };
                 zIndex: string | number;
                 eager: boolean;
                 disabled: boolean;
                 modelValue: boolean;
-                closeDelay: string | number;
-                openDelay: string | number;
+                closeDelay: NonNullable<string | number>;
+                openDelay: NonNullable<string | number>;
                 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>>) => {
+                locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
                     updateLocation: (e: Event) => void;
-                } | undefined);
-                scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+                } | undefined)>;
+                scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
                 closeOnBack: boolean;
                 contained: boolean;
                 noClickAnimation: boolean;
                 persistent: boolean;
-                scrim: string | boolean;
-            }> & Omit<Readonly<vue.ExtractPropTypes<Omit<{
-                offset: vue.PropType<string | number | number[] | undefined>;
-                location: {
-                    type: vue.PropType<Anchor>;
-                    default: string;
-                };
-                origin: {
-                    type: vue.PropType<"auto" | Anchor | "overlap">;
-                    default: string;
-                };
-                height: (StringConstructor | NumberConstructor)[];
-                width: (StringConstructor | NumberConstructor)[];
-                maxHeight: (StringConstructor | NumberConstructor)[];
-                maxWidth: (StringConstructor | NumberConstructor)[];
-                minHeight: (StringConstructor | NumberConstructor)[];
-                minWidth: (StringConstructor | NumberConstructor)[];
-                transition: Omit<{
-                    type: vue.PropType<string | boolean | (vue.TransitionProps & {
-                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                    })>;
-                    default: string;
-                    validator: (val: unknown) => boolean;
-                }, "type" | "default"> & {
-                    type: vue.PropType<string | boolean | (vue.TransitionProps & {
-                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                    }) | {
-                        component: vue.DefineComponent<{
-                            target: vue.PropType<HTMLElement>;
-                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, 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;
-                    }) | {
-                        component: vue.DefineComponent<{
-                            target: vue.PropType<HTMLElement>;
-                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                            target: vue.PropType<HTMLElement>;
-                        }>>, {}>;
-                    };
-                };
-                zIndex: {
-                    type: (StringConstructor | NumberConstructor)[];
-                    default: number;
-                };
-                eager: BooleanConstructor;
-                disabled: BooleanConstructor;
-                theme: StringConstructor;
-                contentClass: null;
-                modelValue: BooleanConstructor;
-                activator: vue.PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
-                closeDelay: {
-                    type: vue.PropType<string | number>;
-                    default: string | number;
-                };
-                openDelay: {
-                    type: vue.PropType<string | number>;
-                    default: string | number;
-                };
-                activatorProps: {
-                    type: vue.PropType<Record<string, any>>;
-                    default: () => {};
-                };
-                openOnClick: {
-                    type: BooleanConstructor;
-                    default: undefined;
-                };
-                openOnHover: BooleanConstructor;
-                openOnFocus: {
-                    type: BooleanConstructor;
-                    default: undefined;
-                };
-                closeOnContentClick: {
-                    type: vue.PropType<boolean>;
-                    default: boolean;
-                };
-                locationStrategy: Omit<{
-                    type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                        updateLocation: (e: Event) => void;
-                    } | undefined)>;
-                    default: string;
-                    validator: (val: any) => boolean;
-                }, "type" | "default"> & {
-                    type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                        updateLocation: (e: Event) => void;
-                    } | undefined)>;
-                    default: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                        updateLocation: (e: Event) => void;
-                    } | undefined);
-                };
-                scrollStrategy: Omit<{
-                    type: vue.PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                    default: string;
-                    validator: (val: any) => boolean;
-                }, "type" | "default"> & {
-                    type: vue.PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                    default: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
-                };
-                closeOnBack: {
-                    type: BooleanConstructor;
-                    default: boolean;
-                };
-                contained: BooleanConstructor;
-                contentProps: null;
-                noClickAnimation: BooleanConstructor;
-                persistent: BooleanConstructor;
-                scrim: Omit<{
-                    type: (StringConstructor | BooleanConstructor)[];
-                    default: boolean;
-                }, "type" | "default"> & {
-                    type: vue.PropType<string | boolean>;
-                    default: string | boolean;
+                scrim: NonNullable<string | boolean>;
+            }> & Omit<{
+                location: Anchor;
+                origin: "auto" | Anchor | "overlap";
+                transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+                })> | {
+                    component: vue.DefineComponent<{} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
+                        target?: HTMLElement | undefined;
+                    } & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, {}>;
                 };
-                attach: vue.PropType<string | boolean | Element>;
-                id: StringConstructor;
-            }, "$children" | "v-slots" | "v-slot:default" | "v-slot:activator">>> & {
-                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim"> & {
+                zIndex: string | number;
+                eager: boolean;
+                disabled: boolean;
+                modelValue: boolean;
+                closeDelay: NonNullable<string | number>;
+                openDelay: NonNullable<string | number>;
+                activatorProps: Record<string, any>;
+                openOnHover: boolean;
+                closeOnContentClick: boolean;
+                locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined)>;
+                scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+                closeOnBack: boolean;
+                contained: boolean;
+                noClickAnimation: boolean;
+                persistent: boolean;
+                scrim: NonNullable<string | boolean>;
+            } & {
+                offset?: string | number | number[] | undefined;
+                id?: string | undefined;
+                height?: string | number | undefined;
+                width?: string | number | undefined;
+                maxHeight?: string | number | undefined;
+                maxWidth?: string | number | undefined;
+                minHeight?: string | number | undefined;
+                minWidth?: string | number | undefined;
+                theme?: string | undefined;
+                contentClass?: any;
+                activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+                openOnClick?: boolean | undefined;
+                openOnFocus?: boolean | undefined;
+                contentProps?: any;
+                attach?: string | boolean | Element | undefined;
+            } & {
                 $children?: {} | vue.VNodeChild | {
                     default?: ((args_0: {
                         isActive: vue.Ref<boolean>;
@@ -1258,7 +1152,9 @@ declare const VAutocomplete: {
                     isActive: boolean;
                     props: Record<string, any>;
                 }) => vue.VNodeChild) | undefined;
-            }>;
+            } & {
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">>;
         };
         multiple: BooleanConstructor;
         noDataText: {
@@ -1273,8 +1169,8 @@ declare const VAutocomplete: {
         customFilter: vue.PropType<FilterFunction>;
         customKeyFilter: vue.PropType<FilterKeyFunctions>;
         filterKeys: {
-            type: vue.PropType<(string & {}) | FilterKeys>;
-            default: (string & {}) | FilterKeys;
+            type: vue.PropType<NonNullable<FilterKeys>>;
+            default: NonNullable<FilterKeys>;
         };
         filterMode: {
             type: vue.PropType<FilterMode>;
@@ -1282,21 +1178,19 @@ declare const VAutocomplete: {
         };
         noFilter: BooleanConstructor;
         search: StringConstructor;
-    }, "multiple" | "$children" | "items" | "v-slots" | "v-slot:prepend" | "v-slot:append" | "modelValue" | "onUpdate:modelValue" | "v-slot:details" | "v-slot:clear" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:label" | "v-slot:loader" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">>> & {
+    }, "multiple" | "$children" | "items" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "onUpdate:modelValue" | "v-slot:loader" | "v-slot:details" | "v-slot:clear" | "v-slot:label" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">>> & {
         "onUpdate:menu"?: ((val: boolean) => any) | undefined;
         "onUpdate:search"?: ((val: any) => any) | undefined;
     } & vue.ShallowUnwrapRef<{
         isFocused: vue.Ref<boolean>;
         isPristine: vue.Ref<boolean>;
-        menu: vue.Ref<boolean> & {
-            readonly externalValue: boolean;
-        };
+        menu: vue.WritableComputedRef<boolean>;
         search: vue.Ref<string | undefined> & {
             readonly externalValue: string | undefined;
         };
         filteredItems: vue.Ref<InternalItem<any>[]>;
         select: (item: InternalItem) => void;
-    } & Omit<any, string | number | symbol>> & {} & vue.ComponentCustomProperties;
+    } & Omit<any, string | number | symbol>> & {} & vue.ComponentCustomProperties & {};
     __isFragment?: undefined;
     __isTeleport?: undefined;
     __isSuspense?: undefined;
@@ -1308,12 +1202,12 @@ declare const VAutocomplete: {
         default: string;
         validator: (val: unknown) => boolean;
     }, "type" | "default"> & {
-        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+        type: vue.PropType<NonNullable<string | boolean | (vue.TransitionProps & {
             component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-        })>;
-        default: string | boolean | (vue.TransitionProps & {
+        })>>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
             component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-        });
+        })>;
     };
     reverse: BooleanConstructor;
     type: {
@@ -1338,11 +1232,11 @@ declare const VAutocomplete: {
     readonly: BooleanConstructor;
     placeholder: StringConstructor;
     theme: StringConstructor;
+    counter: vue.PropType<string | number | true>;
     messages: {
         type: vue.PropType<string | string[]>;
         default: () => never[];
     };
-    counter: vue.PropType<string | number | true>;
     density: {
         type: vue.PropType<Density>;
         default: string;
@@ -1410,8 +1304,8 @@ declare const VAutocomplete: {
         type: vue.PropType<SelectItemKey>;
         default: string;
     }, "type" | "default"> & {
-        type: vue.PropType<SelectItemKey>;
-        default: SelectItemKey;
+        type: vue.PropType<NonNullable<SelectItemKey>>;
+        default: NonNullable<SelectItemKey>;
     };
     itemProps: {
         type: vue.PropType<SelectItemKey>;
@@ -1432,154 +1326,118 @@ declare const VAutocomplete: {
         type: vue.PropType<Partial<{
             location: Anchor;
             origin: "auto" | Anchor | "overlap";
-            transition: string | boolean | (vue.TransitionProps & {
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-            }) | {
-                component: vue.DefineComponent<{
-                    target: vue.PropType<HTMLElement>;
-                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                    target: vue.PropType<HTMLElement>;
-                }>>, {}>;
+            })> | {
+                component: vue.DefineComponent<{} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, {}>;
             };
             zIndex: string | number;
             eager: boolean;
             disabled: boolean;
             modelValue: boolean;
-            closeDelay: string | number;
-            openDelay: string | number;
+            closeDelay: NonNullable<string | number>;
+            openDelay: NonNullable<string | number>;
             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>>) => {
+            locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
                 updateLocation: (e: Event) => void;
-            } | undefined);
-            scrollStrategy: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
+            } | undefined)>;
+            scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
             closeOnBack: boolean;
             contained: boolean;
             noClickAnimation: boolean;
             persistent: boolean;
-            scrim: string | boolean;
-        }> & Omit<Readonly<vue.ExtractPropTypes<Omit<{
-            offset: vue.PropType<string | number | number[] | undefined>;
-            location: {
-                type: vue.PropType<Anchor>;
-                default: string;
-            };
-            origin: {
-                type: vue.PropType<"auto" | Anchor | "overlap">;
-                default: string;
-            };
-            height: (StringConstructor | NumberConstructor)[];
-            width: (StringConstructor | NumberConstructor)[];
-            maxHeight: (StringConstructor | NumberConstructor)[];
-            maxWidth: (StringConstructor | NumberConstructor)[];
-            minHeight: (StringConstructor | NumberConstructor)[];
-            minWidth: (StringConstructor | NumberConstructor)[];
-            transition: Omit<{
-                type: vue.PropType<string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                })>;
-                default: string;
-                validator: (val: unknown) => boolean;
-            }, "type" | "default"> & {
-                type: vue.PropType<string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                }) | {
-                    component: vue.DefineComponent<{
-                        target: vue.PropType<HTMLElement>;
-                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, 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;
-                }) | {
-                    component: vue.DefineComponent<{
-                        target: vue.PropType<HTMLElement>;
-                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: vue.PropType<HTMLElement>;
-                    }>>, {}>;
-                };
-            };
-            zIndex: {
-                type: (StringConstructor | NumberConstructor)[];
-                default: number;
-            };
-            eager: BooleanConstructor;
-            disabled: BooleanConstructor;
-            theme: StringConstructor;
-            contentClass: null;
-            modelValue: BooleanConstructor;
-            activator: vue.PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
-            closeDelay: {
-                type: vue.PropType<string | number>;
-                default: string | number;
-            };
-            openDelay: {
-                type: vue.PropType<string | number>;
-                default: string | number;
-            };
-            activatorProps: {
-                type: vue.PropType<Record<string, any>>;
-                default: () => {};
-            };
-            openOnClick: {
-                type: BooleanConstructor;
-                default: undefined;
-            };
-            openOnHover: BooleanConstructor;
-            openOnFocus: {
-                type: BooleanConstructor;
-                default: undefined;
-            };
-            closeOnContentClick: {
-                type: vue.PropType<boolean>;
-                default: boolean;
-            };
-            locationStrategy: Omit<{
-                type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                    updateLocation: (e: Event) => void;
-                } | undefined)>;
-                default: string;
-                validator: (val: any) => boolean;
-            }, "type" | "default"> & {
-                type: vue.PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                    updateLocation: (e: Event) => void;
-                } | undefined)>;
-                default: "connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                    updateLocation: (e: Event) => void;
-                } | undefined);
-            };
-            scrollStrategy: Omit<{
-                type: vue.PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                default: string;
-                validator: (val: any) => boolean;
-            }, "type" | "default"> & {
-                type: vue.PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                default: "none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition";
-            };
-            closeOnBack: {
-                type: BooleanConstructor;
-                default: boolean;
-            };
-            contained: BooleanConstructor;
-            contentProps: null;
-            noClickAnimation: BooleanConstructor;
-            persistent: BooleanConstructor;
-            scrim: Omit<{
-                type: (StringConstructor | BooleanConstructor)[];
-                default: boolean;
-            }, "type" | "default"> & {
-                type: vue.PropType<string | boolean>;
-                default: string | boolean;
+            scrim: NonNullable<string | boolean>;
+        }> & Omit<{
+            location: Anchor;
+            origin: "auto" | Anchor | "overlap";
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            })> | {
+                component: vue.DefineComponent<{} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {} & {
+                    target?: HTMLElement | undefined;
+                } & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, {}>;
             };
-            attach: vue.PropType<string | boolean | Element>;
-            id: StringConstructor;
-        }, "$children" | "v-slots" | "v-slot:default" | "v-slot:activator">>> & {
-            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim"> & {
+            zIndex: string | number;
+            eager: boolean;
+            disabled: boolean;
+            modelValue: boolean;
+            closeDelay: NonNullable<string | number>;
+            openDelay: NonNullable<string | number>;
+            activatorProps: Record<string, any>;
+            openOnHover: boolean;
+            closeOnContentClick: boolean;
+            locationStrategy: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                updateLocation: (e: Event) => void;
+            } | undefined)>;
+            scrollStrategy: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
+            closeOnBack: boolean;
+            contained: boolean;
+            noClickAnimation: boolean;
+            persistent: boolean;
+            scrim: NonNullable<string | boolean>;
+        } & {
+            offset?: string | number | number[] | undefined;
+            id?: string | undefined;
+            height?: string | number | undefined;
+            width?: string | number | undefined;
+            maxHeight?: string | number | undefined;
+            maxWidth?: string | number | undefined;
+            minHeight?: string | number | undefined;
+            minWidth?: string | number | undefined;
+            theme?: string | undefined;
+            contentClass?: any;
+            activator?: string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | undefined;
+            openOnClick?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } & {
             $children?: {} | vue.VNodeChild | {
                 default?: ((args_0: {
                     isActive: vue.Ref<boolean>;
@@ -1606,7 +1464,9 @@ declare const VAutocomplete: {
                 isActive: boolean;
                 props: Record<string, any>;
             }) => vue.VNodeChild) | undefined;
-        }>;
+        } & {
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "location" | "origin" | "transition" | "zIndex" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">>;
     };
     multiple: BooleanConstructor;
     noDataText: {
@@ -1621,8 +1481,8 @@ declare const VAutocomplete: {
     customFilter: vue.PropType<FilterFunction>;
     customKeyFilter: vue.PropType<FilterKeyFunctions>;
     filterKeys: {
-        type: vue.PropType<(string & {}) | FilterKeys>;
-        default: (string & {}) | FilterKeys;
+        type: vue.PropType<NonNullable<FilterKeys>>;
+        default: NonNullable<FilterKeys>;
     };
     filterMode: {
         type: vue.PropType<FilterMode>;
@@ -1630,40 +1490,38 @@ declare const VAutocomplete: {
     };
     noFilter: BooleanConstructor;
     search: StringConstructor;
-}, "multiple" | "$children" | "items" | "v-slots" | "v-slot:prepend" | "v-slot:append" | "modelValue" | "onUpdate:modelValue" | "v-slot:details" | "v-slot:clear" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:label" | "v-slot:loader" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">>> & {
+}, "multiple" | "$children" | "items" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "onUpdate:modelValue" | "v-slot:loader" | "v-slot:details" | "v-slot:clear" | "v-slot:label" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">>> & {
     "onUpdate:menu"?: ((val: boolean) => any) | undefined;
     "onUpdate:search"?: ((val: any) => any) | undefined;
 }, {
     isFocused: vue.Ref<boolean>;
     isPristine: vue.Ref<boolean>;
-    menu: vue.Ref<boolean> & {
-        readonly externalValue: boolean;
-    };
+    menu: vue.WritableComputedRef<boolean>;
     search: vue.Ref<string | undefined> & {
         readonly externalValue: string | undefined;
     };
     filteredItems: vue.Ref<InternalItem<any>[]>;
     select: (item: InternalItem) => void;
 } & Omit<any, string | number | symbol>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
-    'update:search': (val: any) => boolean;
+    'update:search': (val: any) => true;
     'update:modelValue': (val: any) => boolean;
-    'update:menu': (val: boolean) => boolean;
-}, "multiple" | "$children" | "items" | "v-slots" | "v-slot:prepend" | "v-slot:append" | "modelValue" | "update:modelValue" | "v-slot:details" | "v-slot:clear" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:label" | "v-slot:loader" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">, string, {
+    'update:menu': (val: boolean) => true;
+}, "multiple" | "$children" | "items" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "update:modelValue" | "v-slot:loader" | "v-slot:details" | "v-slot:clear" | "v-slot:label" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">, string, {
     reverse: boolean;
     type: string;
     error: boolean;
     active: boolean;
     direction: "horizontal" | "vertical";
-    transition: string | boolean | (vue.TransitionProps & {
+    transition: NonNullable<string | boolean | (vue.TransitionProps & {
         component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-    });
+    })>;
     menu: boolean;
     autofocus: boolean;
     eager: boolean;
     disabled: boolean;
     readonly: boolean;
-    messages: string | string[];
     noDataText: string;
+    messages: string | string[];
     density: Density;
     variant: "filled" | "outlined" | "plain" | "underlined" | "solo";
     clearIcon: IconValue;
@@ -1680,7 +1538,7 @@ declare const VAutocomplete: {
     valueComparator: typeof deepEqual;
     itemTitle: SelectItemKey;
     itemValue: SelectItemKey;
-    itemChildren: SelectItemKey;
+    itemChildren: NonNullable<SelectItemKey>;
     itemProps: SelectItemKey;
     chips: boolean;
     closableChips: boolean;
@@ -1690,10 +1548,10 @@ declare const VAutocomplete: {
     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<T, ReturnObject, Multiple> = Value<T, ReturnObject, Multiple>>() => {
+    filterKeys: NonNullable<FilterKeys>;
+}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T_1, ReturnObject extends boolean = false, Multiple extends boolean = false, V extends Value<T_1, ReturnObject, Multiple> = Value<T_1, ReturnObject, Multiple>>() => {
     $props: {
-        items?: readonly T[] | undefined;
+        items?: readonly T_1[] | undefined;
         returnObject?: ReturnObject | undefined;
         multiple?: Multiple | undefined;
         modelValue?: V | undefined;
@@ -1709,17 +1567,17 @@ declare const VAutocomplete: {
             'prepend-inner'?: ((args_0: DefaultInputSlot & VInputSlot) => vue.VNodeChild) | undefined;
             'append-inner'?: ((args_0: DefaultInputSlot & VInputSlot) => vue.VNodeChild) | undefined;
             item?: ((args_0: {
-                item: InternalItem<T>;
+                item: InternalItem<T_1>;
                 index: number;
                 props: Record<string, unknown>;
             }) => vue.VNodeChild) | undefined;
             chip?: ((args_0: {
-                item: InternalItem<T>;
+                item: InternalItem<T_1>;
                 index: number;
                 props: Record<string, unknown>;
             }) => vue.VNodeChild) | undefined;
             selection?: ((args_0: {
-                item: InternalItem<T>;
+                item: InternalItem<T_1>;
                 index: number;
             }) => vue.VNodeChild) | undefined;
             'prepend-item'?: (() => vue.VNodeChild) | undefined;
@@ -1736,17 +1594,17 @@ declare const VAutocomplete: {
             'prepend-inner'?: false | ((args_0: DefaultInputSlot & VInputSlot) => vue.VNodeChild) | undefined;
             'append-inner'?: false | ((args_0: DefaultInputSlot & VInputSlot) => vue.VNodeChild) | undefined;
             item?: false | ((args_0: {
-                item: InternalItem<T>;
+                item: InternalItem<T_1>;
                 index: number;
                 props: Record<string, unknown>;
             }) => vue.VNodeChild) | undefined;
             chip?: false | ((args_0: {
-                item: InternalItem<T>;
+                item: InternalItem<T_1>;
                 index: number;
                 props: Record<string, unknown>;
             }) => vue.VNodeChild) | undefined;
             selection?: false | ((args_0: {
-                item: InternalItem<T>;
+                item: InternalItem<T_1>;
                 index: number;
             }) => vue.VNodeChild) | undefined;
             'prepend-item'?: false | (() => vue.VNodeChild) | undefined;
@@ -1763,17 +1621,17 @@ declare const VAutocomplete: {
         "v-slot:prepend-inner"?: false | ((args_0: DefaultInputSlot & VInputSlot) => vue.VNodeChild) | undefined;
         "v-slot:append-inner"?: false | ((args_0: DefaultInputSlot & VInputSlot) => vue.VNodeChild) | undefined;
         "v-slot:item"?: false | ((args_0: {
-            item: InternalItem<T>;
+            item: InternalItem<T_1>;
             index: number;
             props: Record<string, unknown>;
         }) => vue.VNodeChild) | undefined;
         "v-slot:chip"?: false | ((args_0: {
-            item: InternalItem<T>;
+            item: InternalItem<T_1>;
             index: number;
             props: Record<string, unknown>;
         }) => vue.VNodeChild) | undefined;
         "v-slot:selection"?: false | ((args_0: {
-            item: InternalItem<T>;
+            item: InternalItem<T_1>;
             index: number;
         }) => vue.VNodeChild) | undefined;
         "v-slot:prepend-item"?: false | (() => vue.VNodeChild) | undefined;
@@ -1781,6 +1639,6 @@ declare const VAutocomplete: {
         "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
     };
 });
-declare type VAutocomplete = InstanceType<typeof VAutocomplete>;
+type VAutocomplete = InstanceType<typeof VAutocomplete>;
 
 export { VAutocomplete };