vuetify 3.1.3 → 3.1.5

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

@@ -3,9 +3,9 @@ import { PropType, JSXComponent, ComputedRef, Ref, EffectScope } from 'vue';
 
 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: {
@@ -132,9 +132,9 @@ interface InternalItem<T = any> {
     raw: T;
 }
 
-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 VSelect: {
     new (...args: any[]): {
         $: vue.ComponentInternalInstance;
@@ -145,22 +145,40 @@ declare const VSelect: {
             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;
-            }) | {
-                component: vue.DefineComponent<{
-                    target: PropType<HTMLElement>;
-                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                    target: 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;
+                }, {}>;
             };
             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;
@@ -177,7 +195,7 @@ declare const VSelect: {
             valueComparator: typeof deepEqual;
             itemTitle: SelectItemKey;
             itemValue: SelectItemKey;
-            itemChildren: SelectItemKey;
+            itemChildren: NonNullable<SelectItemKey>;
             itemProps: SelectItemKey;
             chips: boolean;
             closableChips: boolean;
@@ -193,23 +211,59 @@ declare const VSelect: {
                 default: string;
                 validator: (val: unknown) => boolean;
             }, "type" | "default"> & {
-                type: PropType<string | boolean | (vue.TransitionProps & {
+                type: PropType<NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                }) | {
-                    component: vue.DefineComponent<{
-                        target: PropType<HTMLElement>;
-                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: 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;
+                    }, {}>;
                 }>;
-                default: string | boolean | (vue.TransitionProps & {
+                default: NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                }) | {
-                    component: vue.DefineComponent<{
-                        target: PropType<HTMLElement>;
-                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: 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;
+                    }, {}>;
                 };
             };
             reverse: BooleanConstructor;
@@ -235,11 +289,11 @@ declare const VSelect: {
             readonly: BooleanConstructor;
             placeholder: StringConstructor;
             theme: StringConstructor;
+            counter: PropType<string | number | true>;
             messages: {
                 type: PropType<string | string[]>;
                 default: () => never[];
             };
-            counter: PropType<string | number | true>;
             density: {
                 type: PropType<Density>;
                 default: string;
@@ -307,8 +361,8 @@ declare const VSelect: {
                 type: PropType<SelectItemKey>;
                 default: string;
             }, "type" | "default"> & {
-                type: PropType<SelectItemKey>;
-                default: SelectItemKey;
+                type: PropType<NonNullable<SelectItemKey>>;
+                default: NonNullable<SelectItemKey>;
             };
             itemProps: {
                 type: PropType<SelectItemKey>;
@@ -329,154 +383,118 @@ declare const VSelect: {
                 type: 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: PropType<HTMLElement>;
-                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                            target: 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: PropType<string | number | number[] | undefined>;
-                    location: {
-                        type: PropType<Anchor>;
-                        default: string;
-                    };
-                    origin: {
-                        type: 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: PropType<string | boolean | (vue.TransitionProps & {
-                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                        })>;
-                        default: string;
-                        validator: (val: unknown) => boolean;
-                    }, "type" | "default"> & {
-                        type: PropType<string | boolean | (vue.TransitionProps & {
-                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                        }) | {
-                            component: vue.DefineComponent<{
-                                target: PropType<HTMLElement>;
-                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                                target: PropType<HTMLElement>;
-                            }>>, {}>;
-                        }>;
-                        default: string | boolean | (vue.TransitionProps & {
-                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                        }) | {
-                            component: vue.DefineComponent<{
-                                target: PropType<HTMLElement>;
-                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                                target: PropType<HTMLElement>;
-                            }>>, {}>;
-                        };
-                    };
-                    zIndex: {
-                        type: (StringConstructor | NumberConstructor)[];
-                        default: number;
-                    };
-                    eager: BooleanConstructor;
-                    disabled: BooleanConstructor;
-                    theme: StringConstructor;
-                    contentClass: null;
-                    modelValue: BooleanConstructor;
-                    activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
-                    closeDelay: {
-                        type: PropType<string | number>;
-                        default: string | number;
-                    };
-                    openDelay: {
-                        type: PropType<string | number>;
-                        default: string | number;
-                    };
-                    activatorProps: {
-                        type: PropType<Record<string, any>>;
-                        default: () => {};
-                    };
-                    openOnClick: {
-                        type: BooleanConstructor;
-                        default: undefined;
-                    };
-                    openOnHover: BooleanConstructor;
-                    openOnFocus: {
-                        type: BooleanConstructor;
-                        default: undefined;
-                    };
-                    closeOnContentClick: {
-                        type: PropType<boolean>;
-                        default: boolean;
-                    };
-                    locationStrategy: Omit<{
-                        type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                            updateLocation: (e: Event) => void;
-                        } | undefined)>;
-                        default: string;
-                        validator: (val: any) => boolean;
-                    }, "type" | "default"> & {
-                        type: 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: PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                        default: string;
-                        validator: (val: any) => boolean;
-                    }, "type" | "default"> & {
-                        type: 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: 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: 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>;
@@ -503,7 +521,9 @@ declare const VSelect: {
                         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,9 +535,9 @@ declare const VSelect: {
                 type: PropType<typeof deepEqual>;
                 default: typeof deepEqual;
             };
-        }, "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;
-        } & 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">;
+        } & 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">;
         $attrs: {
             [x: string]: unknown;
         };
@@ -527,8 +547,8 @@ declare const VSelect: {
         $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;
         $el: any;
         $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
@@ -539,23 +559,59 @@ declare const VSelect: {
                 default: string;
                 validator: (val: unknown) => boolean;
             }, "type" | "default"> & {
-                type: PropType<string | boolean | (vue.TransitionProps & {
+                type: PropType<NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                }) | {
-                    component: vue.DefineComponent<{
-                        target: PropType<HTMLElement>;
-                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: 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;
+                    }, {}>;
                 }>;
-                default: string | boolean | (vue.TransitionProps & {
+                default: NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                }) | {
-                    component: vue.DefineComponent<{
-                        target: PropType<HTMLElement>;
-                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: 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;
+                    }, {}>;
                 };
             };
             reverse: BooleanConstructor;
@@ -581,11 +637,11 @@ declare const VSelect: {
             readonly: BooleanConstructor;
             placeholder: StringConstructor;
             theme: StringConstructor;
+            counter: PropType<string | number | true>;
             messages: {
                 type: PropType<string | string[]>;
                 default: () => never[];
             };
-            counter: PropType<string | number | true>;
             density: {
                 type: PropType<Density>;
                 default: string;
@@ -653,8 +709,8 @@ declare const VSelect: {
                 type: PropType<SelectItemKey>;
                 default: string;
             }, "type" | "default"> & {
-                type: PropType<SelectItemKey>;
-                default: SelectItemKey;
+                type: PropType<NonNullable<SelectItemKey>>;
+                default: NonNullable<SelectItemKey>;
             };
             itemProps: {
                 type: PropType<SelectItemKey>;
@@ -675,154 +731,118 @@ declare const VSelect: {
                 type: 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: PropType<HTMLElement>;
-                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                            target: 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: PropType<string | number | number[] | undefined>;
-                    location: {
-                        type: PropType<Anchor>;
-                        default: string;
-                    };
-                    origin: {
-                        type: 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: PropType<string | boolean | (vue.TransitionProps & {
-                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                        })>;
-                        default: string;
-                        validator: (val: unknown) => boolean;
-                    }, "type" | "default"> & {
-                        type: PropType<string | boolean | (vue.TransitionProps & {
-                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                        }) | {
-                            component: vue.DefineComponent<{
-                                target: PropType<HTMLElement>;
-                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                                target: PropType<HTMLElement>;
-                            }>>, {}>;
-                        }>;
-                        default: string | boolean | (vue.TransitionProps & {
-                            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                        }) | {
-                            component: vue.DefineComponent<{
-                                target: PropType<HTMLElement>;
-                            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                                target: PropType<HTMLElement>;
-                            }>>, {}>;
-                        };
-                    };
-                    zIndex: {
-                        type: (StringConstructor | NumberConstructor)[];
-                        default: number;
-                    };
-                    eager: BooleanConstructor;
-                    disabled: BooleanConstructor;
-                    theme: StringConstructor;
-                    contentClass: null;
-                    modelValue: BooleanConstructor;
-                    activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
-                    closeDelay: {
-                        type: PropType<string | number>;
-                        default: string | number;
-                    };
-                    openDelay: {
-                        type: PropType<string | number>;
-                        default: string | number;
-                    };
-                    activatorProps: {
-                        type: PropType<Record<string, any>>;
-                        default: () => {};
-                    };
-                    openOnClick: {
-                        type: BooleanConstructor;
-                        default: undefined;
-                    };
-                    openOnHover: BooleanConstructor;
-                    openOnFocus: {
-                        type: BooleanConstructor;
-                        default: undefined;
-                    };
-                    closeOnContentClick: {
-                        type: PropType<boolean>;
-                        default: boolean;
-                    };
-                    locationStrategy: Omit<{
-                        type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                            updateLocation: (e: Event) => void;
-                        } | undefined)>;
-                        default: string;
-                        validator: (val: any) => boolean;
-                    }, "type" | "default"> & {
-                        type: 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: PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                        default: string;
-                        validator: (val: any) => boolean;
-                    }, "type" | "default"> & {
-                        type: 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: 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: 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>;
@@ -849,7 +869,9 @@ declare const VSelect: {
                         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: {
@@ -861,38 +883,54 @@ declare const VSelect: {
                 type: PropType<typeof deepEqual>;
                 default: typeof deepEqual;
             };
-        }, "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;
         }, {
-            menu: vue.Ref<boolean> & {
-                readonly externalValue: boolean;
-            };
+            menu: vue.WritableComputedRef<boolean>;
             select: (item: InternalItem) => void;
         } & Omit<any, string | number | symbol>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
             '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;
-            }) | {
-                component: vue.DefineComponent<{
-                    target: PropType<HTMLElement>;
-                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                    target: 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;
+                }, {}>;
             };
             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;
@@ -909,7 +947,7 @@ declare const VSelect: {
             valueComparator: typeof deepEqual;
             itemTitle: SelectItemKey;
             itemValue: SelectItemKey;
-            itemChildren: SelectItemKey;
+            itemChildren: NonNullable<SelectItemKey>;
             itemProps: SelectItemKey;
             chips: boolean;
             closableChips: boolean;
@@ -917,7 +955,7 @@ declare const VSelect: {
             hideSelected: boolean;
             menuIcon: IconValue;
             openOnClear: boolean;
-        }> & {
+        }, {}, string> & {
             beforeCreate?: ((() => void) | (() => void)[]) | undefined;
             created?: ((() => void) | (() => void)[]) | undefined;
             beforeMount?: ((() => void) | (() => void)[]) | undefined;
@@ -932,11 +970,11 @@ declare const VSelect: {
             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 vue.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: PropType<string | boolean | (vue.TransitionProps & {
@@ -945,23 +983,59 @@ declare const VSelect: {
             default: string;
             validator: (val: unknown) => boolean;
         }, "type" | "default"> & {
-            type: PropType<string | boolean | (vue.TransitionProps & {
+            type: PropType<NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-            }) | {
-                component: vue.DefineComponent<{
-                    target: PropType<HTMLElement>;
-                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                    target: 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;
+                }, {}>;
             }>;
-            default: string | boolean | (vue.TransitionProps & {
+            default: NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-            }) | {
-                component: vue.DefineComponent<{
-                    target: PropType<HTMLElement>;
-                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                    target: 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;
+                }, {}>;
             };
         };
         reverse: BooleanConstructor;
@@ -987,11 +1061,11 @@ declare const VSelect: {
         readonly: BooleanConstructor;
         placeholder: StringConstructor;
         theme: StringConstructor;
+        counter: PropType<string | number | true>;
         messages: {
             type: PropType<string | string[]>;
             default: () => never[];
         };
-        counter: PropType<string | number | true>;
         density: {
             type: PropType<Density>;
             default: string;
@@ -1059,8 +1133,8 @@ declare const VSelect: {
             type: PropType<SelectItemKey>;
             default: string;
         }, "type" | "default"> & {
-            type: PropType<SelectItemKey>;
-            default: SelectItemKey;
+            type: PropType<NonNullable<SelectItemKey>>;
+            default: NonNullable<SelectItemKey>;
         };
         itemProps: {
             type: PropType<SelectItemKey>;
@@ -1081,154 +1155,118 @@ declare const VSelect: {
             type: 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: PropType<HTMLElement>;
-                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: 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: PropType<string | number | number[] | undefined>;
-                location: {
-                    type: PropType<Anchor>;
-                    default: string;
-                };
-                origin: {
-                    type: 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: PropType<string | boolean | (vue.TransitionProps & {
-                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                    })>;
-                    default: string;
-                    validator: (val: unknown) => boolean;
-                }, "type" | "default"> & {
-                    type: PropType<string | boolean | (vue.TransitionProps & {
-                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                    }) | {
-                        component: vue.DefineComponent<{
-                            target: PropType<HTMLElement>;
-                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                            target: PropType<HTMLElement>;
-                        }>>, {}>;
-                    }>;
-                    default: string | boolean | (vue.TransitionProps & {
-                        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                    }) | {
-                        component: vue.DefineComponent<{
-                            target: PropType<HTMLElement>;
-                        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                            target: PropType<HTMLElement>;
-                        }>>, {}>;
-                    };
-                };
-                zIndex: {
-                    type: (StringConstructor | NumberConstructor)[];
-                    default: number;
-                };
-                eager: BooleanConstructor;
-                disabled: BooleanConstructor;
-                theme: StringConstructor;
-                contentClass: null;
-                modelValue: BooleanConstructor;
-                activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
-                closeDelay: {
-                    type: PropType<string | number>;
-                    default: string | number;
-                };
-                openDelay: {
-                    type: PropType<string | number>;
-                    default: string | number;
-                };
-                activatorProps: {
-                    type: PropType<Record<string, any>>;
-                    default: () => {};
-                };
-                openOnClick: {
-                    type: BooleanConstructor;
-                    default: undefined;
-                };
-                openOnHover: BooleanConstructor;
-                openOnFocus: {
-                    type: BooleanConstructor;
-                    default: undefined;
-                };
-                closeOnContentClick: {
-                    type: PropType<boolean>;
-                    default: boolean;
-                };
-                locationStrategy: Omit<{
-                    type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                        updateLocation: (e: Event) => void;
-                    } | undefined)>;
-                    default: string;
-                    validator: (val: any) => boolean;
-                }, "type" | "default"> & {
-                    type: 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: PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                    default: string;
-                    validator: (val: any) => boolean;
-                }, "type" | "default"> & {
-                    type: 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: 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: 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>;
@@ -1255,7 +1293,9 @@ declare const VSelect: {
                     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: {
@@ -1267,14 +1307,12 @@ declare const VSelect: {
             type: PropType<typeof deepEqual>;
             default: typeof deepEqual;
         };
-    }, "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;
     } & vue.ShallowUnwrapRef<{
-        menu: vue.Ref<boolean> & {
-            readonly externalValue: boolean;
-        };
+        menu: vue.WritableComputedRef<boolean>;
         select: (item: InternalItem) => void;
-    } & Omit<any, string | number | symbol>> & {} & vue.ComponentCustomProperties;
+    } & Omit<any, string | number | symbol>> & {} & vue.ComponentCustomProperties & {};
     __isFragment?: undefined;
     __isTeleport?: undefined;
     __isSuspense?: undefined;
@@ -1286,23 +1324,59 @@ declare const VSelect: {
         default: string;
         validator: (val: unknown) => boolean;
     }, "type" | "default"> & {
-        type: PropType<string | boolean | (vue.TransitionProps & {
+        type: PropType<NonNullable<string | boolean | (vue.TransitionProps & {
             component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-        }) | {
-            component: vue.DefineComponent<{
-                target: PropType<HTMLElement>;
-            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                target: 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;
+            }, {}>;
         }>;
-        default: string | boolean | (vue.TransitionProps & {
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
             component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-        }) | {
-            component: vue.DefineComponent<{
-                target: PropType<HTMLElement>;
-            }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                target: 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;
+            }, {}>;
         };
     };
     reverse: BooleanConstructor;
@@ -1328,11 +1402,11 @@ declare const VSelect: {
     readonly: BooleanConstructor;
     placeholder: StringConstructor;
     theme: StringConstructor;
+    counter: PropType<string | number | true>;
     messages: {
         type: PropType<string | string[]>;
         default: () => never[];
     };
-    counter: PropType<string | number | true>;
     density: {
         type: PropType<Density>;
         default: string;
@@ -1400,8 +1474,8 @@ declare const VSelect: {
         type: PropType<SelectItemKey>;
         default: string;
     }, "type" | "default"> & {
-        type: PropType<SelectItemKey>;
-        default: SelectItemKey;
+        type: PropType<NonNullable<SelectItemKey>>;
+        default: NonNullable<SelectItemKey>;
     };
     itemProps: {
         type: PropType<SelectItemKey>;
@@ -1422,154 +1496,118 @@ declare const VSelect: {
         type: 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: PropType<HTMLElement>;
-                }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                    target: 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: PropType<string | number | number[] | undefined>;
-            location: {
-                type: PropType<Anchor>;
-                default: string;
-            };
-            origin: {
-                type: 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: PropType<string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                })>;
-                default: string;
-                validator: (val: unknown) => boolean;
-            }, "type" | "default"> & {
-                type: PropType<string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                }) | {
-                    component: vue.DefineComponent<{
-                        target: PropType<HTMLElement>;
-                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: PropType<HTMLElement>;
-                    }>>, {}>;
-                }>;
-                default: string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-                }) | {
-                    component: vue.DefineComponent<{
-                        target: PropType<HTMLElement>;
-                    }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-                        target: PropType<HTMLElement>;
-                    }>>, {}>;
-                };
-            };
-            zIndex: {
-                type: (StringConstructor | NumberConstructor)[];
-                default: number;
-            };
-            eager: BooleanConstructor;
-            disabled: BooleanConstructor;
-            theme: StringConstructor;
-            contentClass: null;
-            modelValue: BooleanConstructor;
-            activator: PropType<string | Element | vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | undefined>;
-            closeDelay: {
-                type: PropType<string | number>;
-                default: string | number;
-            };
-            openDelay: {
-                type: PropType<string | number>;
-                default: string | number;
-            };
-            activatorProps: {
-                type: PropType<Record<string, any>>;
-                default: () => {};
-            };
-            openOnClick: {
-                type: BooleanConstructor;
-                default: undefined;
-            };
-            openOnHover: BooleanConstructor;
-            openOnFocus: {
-                type: BooleanConstructor;
-                default: undefined;
-            };
-            closeOnContentClick: {
-                type: PropType<boolean>;
-                default: boolean;
-            };
-            locationStrategy: Omit<{
-                type: PropType<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
-                    updateLocation: (e: Event) => void;
-                } | undefined)>;
-                default: string;
-                validator: (val: any) => boolean;
-            }, "type" | "default"> & {
-                type: 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: PropType<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition">;
-                default: string;
-                validator: (val: any) => boolean;
-            }, "type" | "default"> & {
-                type: 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: 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: 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>;
@@ -1596,7 +1634,9 @@ declare const VSelect: {
                 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: {
@@ -1608,38 +1648,54 @@ declare const VSelect: {
         type: PropType<typeof deepEqual>;
         default: typeof deepEqual;
     };
-}, "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;
 }, {
-    menu: vue.Ref<boolean> & {
-        readonly externalValue: boolean;
-    };
+    menu: vue.WritableComputedRef<boolean>;
     select: (item: InternalItem) => void;
 } & Omit<any, string | number | symbol>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
     '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;
-    }) | {
-        component: vue.DefineComponent<{
-            target: PropType<HTMLElement>;
-        }, () => JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-            target: 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;
+        }, {}>;
     };
     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;
@@ -1656,7 +1712,7 @@ declare const VSelect: {
     valueComparator: typeof deepEqual;
     itemTitle: SelectItemKey;
     itemValue: SelectItemKey;
-    itemChildren: SelectItemKey;
+    itemChildren: NonNullable<SelectItemKey>;
     itemProps: SelectItemKey;
     chips: boolean;
     closableChips: boolean;
@@ -1664,9 +1720,9 @@ declare const VSelect: {
     hideSelected: boolean;
     menuIcon: IconValue;
     openOnClear: boolean;
-}> & 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>>() => {
+}, {}, 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;
@@ -1682,17 +1738,17 @@ declare const VSelect: {
             '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;
@@ -1709,17 +1765,17 @@ declare const VSelect: {
             '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;
@@ -1736,17 +1792,17 @@ declare const VSelect: {
         "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;
@@ -1754,6 +1810,6 @@ declare const VSelect: {
         "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
     };
 });
-declare type VSelect = InstanceType<typeof VSelect>;
+type VSelect = InstanceType<typeof VSelect>;
 
 export { VSelect };