@vuetify/nightly 4.0.0-dev-20230511.0 → 4.0.0-dev-20230512.0

package/lib/components/VCombobox/index.d.mts

@@ -1,27 +1,11 @@
 import * as vue from 'vue';
-import { Ref, EffectScope, ComponentPropsOptions, ExtractPropTypes, VNodeChild, PropType, JSXComponent, ComputedRef, nextTick } from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, VNodeChild, PropType, JSXComponent, Ref, ComputedRef, EffectScope, nextTick } from 'vue';
 
-interface ScrollStrategyData {
-    root: Ref<HTMLElement | undefined>;
-    contentEl: Ref<HTMLElement | undefined>;
-    activatorEl: Ref<HTMLElement | undefined>;
-    isActive: Ref<boolean>;
-    updateLocation: Ref<((e: Event) => void) | undefined>;
-}
-type ScrollStrategyFn = (data: ScrollStrategyData, props: StrategyProps$1, scope: EffectScope) => void;
-declare const scrollStrategies: {
-    none: null;
-    close: typeof closeScrollStrategy;
-    block: typeof blockScrollStrategy;
-    reposition: typeof repositionScrollStrategy;
-};
-interface StrategyProps$1 {
-    scrollStrategy: keyof typeof scrollStrategies | ScrollStrategyFn;
-    contained: boolean | undefined;
-}
-declare function closeScrollStrategy(data: ScrollStrategyData): void;
-declare function blockScrollStrategy(data: ScrollStrategyData, props: StrategyProps$1): void;
-declare function repositionScrollStrategy(data: ScrollStrategyData, props: StrategyProps$1, scope: EffectScope): void;
+declare const block: readonly ["top", "bottom"];
+declare const inline: readonly ["start", "end", "left", "right"];
+type Tblock = typeof block[number];
+type Tinline = typeof inline[number];
+type Anchor = Tblock | Tinline | 'center' | 'center center' | `${Tblock} ${Tinline | 'center'}` | `${Tinline} ${Tblock | 'center'}`;
 
 declare class Box {
     x: number;
@@ -40,13 +24,7 @@ declare class Box {
     get right(): number;
 }
 
-declare const block: readonly ["top", "bottom"];
-declare const inline: readonly ["start", "end", "left", "right"];
-type Tblock = typeof block[number];
-type Tinline = typeof inline[number];
-type Anchor = Tblock | Tinline | 'center' | 'center center' | `${Tblock} ${Tinline | 'center'}` | `${Tinline} ${Tblock | 'center'}`;
-
-type SlotsToProps<U extends Record<string, any[]> | Record<string, Slot>, T = U extends Record<string, any[]> ? MakeSlots<U> : U> = {
+type SlotsToProps<U extends RawSlots, T = U extends Record<string, any[]> ? MakeSlots<U> : U> = {
     $children?: (VNodeChild | (T extends {
         default: infer V;
     } ? V : {}) | {
@@ -58,8 +36,9 @@ type SlotsToProps<U extends Record<string, any[]> | Record<string, Slot>, T = U
 } & {
     [K in keyof T as `v-slot:${K & string}`]?: T[K] | false;
 };
+type RawSlots = Record<string, any[]> | Record<string, Slot>;
 type Slot<T extends any[] = any[]> = (...args: T) => VNodeChild;
-type MakeSlots<T extends Record<string, any[]> | Record<string, Slot>> = {
+type MakeSlots<T extends RawSlots> = {
     [K in keyof T]: T[K] extends any[] ? Slot<T[K]> : T[K];
 };
 type GenericProps<Props, Slots extends Record<string, any[]>> = {
@@ -75,38 +54,64 @@ type SelectItemKey = boolean | string | (string | number)[] | ((item: Record<str
 type EventProp<T extends any[] = any[], F = (...args: T) => any> = F | F[];
 declare const EventProp: <T extends any[] = any[]>() => PropType<EventProp<T, (...args: T) => any>>;
 
-interface LocationStrategyData {
-    contentEl: Ref<HTMLElement | undefined>;
-    activatorEl: Ref<HTMLElement | undefined>;
+interface LoaderSlotProps {
+    color: string | undefined;
+    isActive: boolean;
+}
+
+type IconValue = string | (string | [path: string, opacity: number])[] | JSXComponent;
+declare const IconValue: PropType<IconValue>;
+
+interface DefaultInputSlot {
     isActive: Ref<boolean>;
-    isRtl: Ref<boolean>;
+    isFocused: Ref<boolean>;
+    controlRef: Ref<HTMLElement | undefined>;
+    focus: () => void;
+    blur: () => void;
 }
-type LocationStrategyFn = (data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>) => undefined | {
-    updateLocation: (e: Event) => void;
+interface VFieldSlot extends DefaultInputSlot {
+    props: Record<string, unknown>;
+}
+type VFieldSlots = {
+    clear: [];
+    'prepend-inner': [DefaultInputSlot];
+    'append-inner': [DefaultInputSlot];
+    label: [DefaultInputSlot & {
+        label: string | undefined;
+        props: Record<string, any>;
+    }];
+    loader: [LoaderSlotProps];
+    default: [VFieldSlot];
 };
-declare const locationStrategies: {
-    static: typeof staticLocationStrategy;
-    connected: typeof connectedLocationStrategy;
+
+type Density = null | 'default' | 'comfortable' | 'compact';
+
+type ValidationResult = string | boolean;
+type ValidationRule = ValidationResult | PromiseLike<ValidationResult> | ((value: any) => ValidationResult) | ((value: any) => PromiseLike<ValidationResult>);
+
+type VMessageSlot = {
+    message: string;
 };
-interface StrategyProps {
-    locationStrategy: keyof typeof locationStrategies | LocationStrategyFn;
-    location: Anchor;
-    origin: Anchor | 'auto' | 'overlap';
-    offset?: number | string | number[];
-    maxHeight?: number | string;
-    maxWidth?: number | string;
-    minHeight?: number | string;
-    minWidth?: number | string;
+
+interface VInputSlot {
+    id: ComputedRef<string>;
+    messagesId: ComputedRef<string>;
+    isDirty: ComputedRef<boolean>;
+    isDisabled: ComputedRef<boolean>;
+    isReadonly: ComputedRef<boolean>;
+    isPristine: Ref<boolean>;
+    isValid: ComputedRef<boolean | null>;
+    isValidating: Ref<boolean>;
+    reset: () => void;
+    resetValidation: () => void;
+    validate: () => void;
 }
-declare function staticLocationStrategy(): void;
-declare function connectedLocationStrategy(data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>): {
-    updateLocation: () => {
-        available: {
-            x: number;
-            y: number;
-        };
-        contentBox: Box;
-    } | undefined;
+type VInputSlots = {
+    default: [VInputSlot];
+    prepend: [VInputSlot];
+    append: [VInputSlot];
+    details: [VInputSlot];
+    message: [VMessageSlot];
 };
 
 interface InternalItem<T = any> {
@@ -133,1059 +138,377 @@ type FilterKeyFunctions = Record<string, FilterFunction>;
 type FilterKeys = string | string[];
 type FilterMode = 'some' | 'every' | 'union' | 'intersection';
 
-type ValidationResult = string | boolean;
-type ValidationRule = ValidationResult | PromiseLike<ValidationResult> | ((value: any) => ValidationResult) | ((value: any) => PromiseLike<ValidationResult>);
-
-type IconValue = string | (string | [path: string, opacity: number])[] | JSXComponent;
-declare const IconValue: PropType<IconValue>;
-
-type Density = null | 'default' | 'comfortable' | 'compact';
-
-interface LoaderSlotProps {
-    color: string | undefined;
-    isActive: boolean;
-}
-
-interface VInputSlot {
-    id: ComputedRef<string>;
-    messagesId: ComputedRef<string>;
-    isDirty: ComputedRef<boolean>;
-    isDisabled: ComputedRef<boolean>;
-    isReadonly: ComputedRef<boolean>;
-    isPristine: Ref<boolean>;
-    isValid: ComputedRef<boolean | null>;
-    isValidating: Ref<boolean>;
-    reset: () => void;
-    resetValidation: () => void;
-    validate: () => void;
+interface ScrollStrategyData {
+    root: Ref<HTMLElement | undefined>;
+    contentEl: Ref<HTMLElement | undefined>;
+    activatorEl: Ref<HTMLElement | undefined>;
+    isActive: Ref<boolean>;
+    updateLocation: Ref<((e: Event) => void) | undefined>;
 }
-type VInputSlots = {
-    default: [VInputSlot];
-    prepend: [VInputSlot];
-    append: [VInputSlot];
-    details: [VInputSlot];
+type ScrollStrategyFn = (data: ScrollStrategyData, props: StrategyProps$1, scope: EffectScope) => void;
+declare const scrollStrategies: {
+    none: null;
+    close: typeof closeScrollStrategy;
+    block: typeof blockScrollStrategy;
+    reposition: typeof repositionScrollStrategy;
 };
+interface StrategyProps$1 {
+    scrollStrategy: keyof typeof scrollStrategies | ScrollStrategyFn;
+    contained: boolean | undefined;
+}
+declare function closeScrollStrategy(data: ScrollStrategyData): void;
+declare function blockScrollStrategy(data: ScrollStrategyData, props: StrategyProps$1): void;
+declare function repositionScrollStrategy(data: ScrollStrategyData, props: StrategyProps$1, scope: EffectScope): void;
 
-interface DefaultInputSlot {
+interface LocationStrategyData {
+    contentEl: Ref<HTMLElement | undefined>;
+    activatorEl: Ref<HTMLElement | undefined>;
     isActive: Ref<boolean>;
-    isFocused: Ref<boolean>;
-    controlRef: Ref<HTMLElement | undefined>;
-    focus: () => void;
-    blur: () => void;
+    isRtl: Ref<boolean>;
 }
-interface VFieldSlot extends DefaultInputSlot {
-    props: Record<string, unknown>;
+type LocationStrategyFn = (data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>) => undefined | {
+    updateLocation: (e: Event) => void;
+};
+declare const locationStrategies: {
+    static: typeof staticLocationStrategy;
+    connected: typeof connectedLocationStrategy;
+};
+interface StrategyProps {
+    locationStrategy: keyof typeof locationStrategies | LocationStrategyFn;
+    location: Anchor;
+    origin: Anchor | 'auto' | 'overlap';
+    offset?: number | string | number[];
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    minWidth?: number | string;
 }
-type VFieldSlots = {
-    clear: [];
-    'prepend-inner': [DefaultInputSlot & VInputSlot];
-    'append-inner': [DefaultInputSlot & VInputSlot];
-    label: [DefaultInputSlot & VInputSlot];
-    loader: [LoaderSlotProps];
-    default: [VFieldSlot];
+declare function staticLocationStrategy(): void;
+declare function connectedLocationStrategy(data: LocationStrategyData, props: StrategyProps, contentStyles: Ref<Record<string, string>>): {
+    updateLocation: () => {
+        available: {
+            x: number;
+            y: number;
+        };
+        contentBox: Box;
+    } | undefined;
 };
 
 type Primitive = string | number | boolean | symbol;
 type Val<T, ReturnObject extends boolean> = string | (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>;
+type Value<T, ReturnObject extends boolean, Multiple extends boolean> = Multiple extends true ? readonly Val<T, ReturnObject>[] : Val<T, ReturnObject> | null;
 declare const VCombobox: {
     new (...args: any[]): {
         $: vue.ComponentInternalInstance;
         $data: {};
-        $props: Partial<{
-            flat: boolean;
-            reverse: boolean;
-            type: string;
-            error: boolean;
-            active: boolean;
-            direction: "horizontal" | "vertical";
-            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+        $props: {
+            flat?: boolean | undefined;
+            reverse?: boolean | undefined;
+            type?: string | undefined;
+            error?: boolean | undefined;
+            active?: boolean | undefined;
+            direction?: "horizontal" | "vertical" | undefined;
+            transition?: NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component | undefined;
-            })>;
-            menu: boolean;
-            style: vue.StyleValue;
-            autofocus: boolean;
-            eager: boolean;
-            disabled: boolean;
-            readonly: boolean;
-            noDataText: string;
-            messages: string | string[];
-            rounded: string | number | boolean;
-            density: Density;
-            variant: "filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled";
-            clearIcon: IconValue;
-            focused: boolean;
-            errorMessages: string | string[];
-            maxErrors: string | number;
-            rules: ValidationRule[];
-            persistentHint: boolean;
-            clearable: boolean;
-            persistentClear: boolean;
-            singleLine: boolean;
-            persistentPlaceholder: boolean;
-            persistentCounter: boolean;
-            valueComparator: typeof deepEqual;
-            itemTitle: SelectItemKey;
-            itemValue: SelectItemKey;
-            itemChildren: NonNullable<SelectItemKey>;
-            itemProps: SelectItemKey;
-            chips: boolean;
-            closableChips: boolean;
-            hideNoData: boolean;
-            hideSelected: boolean;
-            menuIcon: IconValue;
-            openOnClear: boolean;
-            filterMode: FilterMode;
-            noFilter: boolean;
-            filterKeys: NonNullable<FilterKeys>;
-        }> & Omit<Readonly<vue.ExtractPropTypes<Omit<{
-            transition: Omit<{
-                type: PropType<string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component | undefined;
-                })>;
-                default: string;
-                validator: (val: unknown) => boolean;
-            }, "type" | "default"> & {
-                type: PropType<NonNullable<string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component | undefined;
-                })>>;
-                default: NonNullable<string | boolean | (vue.TransitionProps & {
+            })> | undefined;
+            menu?: boolean | undefined;
+            style?: vue.StyleValue | undefined;
+            autofocus?: boolean | undefined;
+            eager?: boolean | undefined;
+            disabled?: boolean | undefined;
+            readonly?: boolean | undefined;
+            noDataText?: string | undefined;
+            messages?: string | string[] | undefined;
+            rounded?: string | number | boolean | undefined;
+            density?: Density | undefined;
+            variant?: "filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled" | undefined;
+            clearIcon?: IconValue | undefined;
+            focused?: boolean | undefined;
+            clearable?: boolean | undefined;
+            persistentClear?: boolean | undefined;
+            singleLine?: boolean | undefined;
+            errorMessages?: string | string[] | undefined;
+            maxErrors?: string | number | undefined;
+            rules?: ValidationRule[] | undefined;
+            persistentHint?: boolean | undefined;
+            persistentPlaceholder?: boolean | undefined;
+            persistentCounter?: boolean | undefined;
+            valueComparator?: typeof deepEqual | undefined;
+            itemTitle?: SelectItemKey | undefined;
+            itemValue?: SelectItemKey | undefined;
+            itemChildren?: NonNullable<SelectItemKey> | undefined;
+            itemProps?: SelectItemKey | undefined;
+            chips?: boolean | undefined;
+            closableChips?: boolean | undefined;
+            hideNoData?: boolean | undefined;
+            hideSelected?: boolean | undefined;
+            menuIcon?: IconValue | undefined;
+            openOnClear?: boolean | undefined;
+            filterMode?: FilterMode | undefined;
+            noFilter?: boolean | undefined;
+            filterKeys?: NonNullable<FilterKeys> | undefined;
+            key?: string | number | symbol | undefined;
+            id?: string | undefined;
+            name?: string | undefined;
+            color?: string | undefined;
+            loading?: string | boolean | undefined;
+            label?: string | undefined;
+            prefix?: string | undefined;
+            class?: any;
+            delimiters?: string[] | undefined;
+            placeholder?: string | undefined;
+            ref?: vue.VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            theme?: string | undefined;
+            counter?: string | number | true | undefined;
+            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            "onUpdate:modelValue"?: ((val: any) => any) | undefined;
+            bgColor?: string | undefined;
+            prependIcon?: IconValue | undefined;
+            appendIcon?: IconValue | undefined;
+            prependInnerIcon?: IconValue | undefined;
+            'onClick:clear'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+            'onClick:append'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+            'onClick:prepend'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+            'onClick:appendInner'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+            'onClick:prependInner'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+            'onUpdate:focused'?: (EventProp<[boolean], (args_0: boolean) => any> & ((focused: boolean) => any)) | undefined;
+            baseColor?: string | undefined;
+            validateOn?: "input" | "blur" | "submit" | undefined;
+            hint?: string | undefined;
+            hideDetails?: boolean | "auto" | undefined;
+            suffix?: string | undefined;
+            counterValue?: ((value: any) => number) | undefined;
+            modelModifiers?: Record<string, boolean> | undefined;
+            menuProps?: {
+                location?: Anchor | undefined;
+                origin?: "auto" | Anchor | "overlap" | undefined;
+                transition?: NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component | undefined;
-                })>;
-            };
-            flat: BooleanConstructor;
-            reverse: BooleanConstructor;
-            type: {
-                type: StringConstructor;
-                default: string;
-            };
-            error: BooleanConstructor;
-            id: StringConstructor;
-            active: BooleanConstructor;
-            name: StringConstructor;
-            color: StringConstructor;
-            direction: {
-                type: PropType<"horizontal" | "vertical">;
-                default: string;
-                validator: (v: any) => boolean;
-            };
-            loading: (StringConstructor | BooleanConstructor)[];
-            label: StringConstructor;
-            style: {
-                type: PropType<vue.StyleValue>;
-                default: null;
-            };
-            prefix: StringConstructor;
-            autofocus: BooleanConstructor;
-            disabled: BooleanConstructor;
-            readonly: BooleanConstructor;
-            class: PropType<any>;
-            placeholder: StringConstructor;
-            theme: StringConstructor;
-            counter: PropType<string | number | true>;
-            messages: {
-                type: PropType<string | string[]>;
-                default: () => never[];
-            };
-            rounded: {
-                type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
-                default: undefined;
-            };
-            density: {
-                type: PropType<Density>;
-                default: string;
-                validator: (v: any) => boolean;
-            };
-            variant: {
-                type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled">;
-                default: string;
-                validator: (v: any) => boolean;
-            };
-            modelValue: {
-                type: PropType<any>;
-                default: any;
-            };
-            bgColor: StringConstructor;
-            prependIcon: PropType<IconValue>;
-            appendIcon: PropType<IconValue>;
-            clearIcon: {
-                type: PropType<IconValue>;
-                default: string;
-            };
-            prependInnerIcon: PropType<IconValue>;
-            'onClick:clear': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-            'onClick:append': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-            'onClick:prepend': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-            'onClick:appendInner': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-            'onClick:prependInner': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-            focused: BooleanConstructor;
-            'onUpdate:focused': PropType<EventProp<[boolean], (args_0: boolean) => any>>;
-            validateOn: PropType<"input" | "blur" | "submit" | undefined>;
-            errorMessages: {
-                type: PropType<string | string[]>;
-                default: () => never[];
-            };
-            maxErrors: {
-                type: (StringConstructor | NumberConstructor)[];
-                default: number;
-            };
-            rules: {
-                type: PropType<ValidationRule[]>;
-                default: () => never[];
-            };
-            hint: StringConstructor;
-            persistentHint: BooleanConstructor;
-            hideDetails: PropType<boolean | "auto">;
-            clearable: BooleanConstructor;
-            baseColor: StringConstructor;
-            persistentClear: BooleanConstructor;
-            singleLine: BooleanConstructor;
-            persistentPlaceholder: BooleanConstructor;
-            persistentCounter: BooleanConstructor;
-            suffix: StringConstructor;
-            counterValue: PropType<(value: any) => number>;
-            modelModifiers: PropType<Record<string, boolean>>;
-            items: {
-                type: PropType<any[]>;
-                default: () => never[];
-            };
-            itemTitle: {
-                type: PropType<SelectItemKey>;
-                default: string;
-            };
-            itemValue: {
-                type: PropType<SelectItemKey>;
-                default: string;
-            };
-            itemChildren: Omit<{
-                type: PropType<SelectItemKey>;
-                default: string;
-            }, "type" | "default"> & {
-                type: PropType<NonNullable<SelectItemKey>>;
-                default: NonNullable<SelectItemKey>;
-            };
-            itemProps: {
-                type: PropType<SelectItemKey>;
-                default: string;
-            };
-            returnObject: {
-                type: PropType<boolean>;
-                default: boolean;
-            };
-            chips: BooleanConstructor;
-            closableChips: BooleanConstructor;
-            eager: BooleanConstructor;
-            hideNoData: {
-                type: PropType<boolean>;
-                default: boolean;
-            };
-            hideSelected: BooleanConstructor;
-            menu: BooleanConstructor;
-            menuIcon: {
-                type: PropType<IconValue>;
-                default: string;
-            };
-            menuProps: {
-                type: PropType<Partial<{
-                    location: Anchor;
-                    origin: "auto" | Anchor | "overlap";
-                    transition: NonNullable<string | boolean | (vue.TransitionProps & {
-                        component?: vue.Component | undefined;
-                    })> | {
-                        component: {
-                            new (...args: any[]): {
-                                $: vue.ComponentInternalInstance;
-                                $data: {};
-                                $props: Partial<{}> & Omit<{} & {
-                                    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;
-                                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                                $attrs: {
-                                    [x: string]: unknown;
-                                };
-                                $refs: {
-                                    [x: string]: unknown;
-                                };
-                                $slots: Readonly<{
-                                    [name: string]: vue.Slot | undefined;
-                                }>;
-                                $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                                $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                                $emit: (event: string, ...args: any[]) => void;
-                                $el: any;
-                                $options: vue.ComponentOptionsBase<{} & {
-                                    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, {}, {}, string> & {
-                                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                                    created?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                                    mounted?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                                    updated?: ((() => void) | (() => void)[]) | undefined;
-                                    activated?: ((() => void) | (() => void)[]) | undefined;
-                                    deactivated?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                                    destroyed?: ((() => void) | (() => void)[]) | undefined;
-                                    unmounted?: ((() => void) | (() => void)[]) | undefined;
-                                    renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                    renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                    errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                                };
-                                $forceUpdate: () => void;
-                                $nextTick: typeof nextTick;
-                                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                            } & {} & {
-                                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;
-                            } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } & vue.ComponentOptionsBase<{} & {
-                            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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                            target: PropType<HTMLElement>;
-                        }, vue.ExtractPropTypes<{
-                            target: PropType<HTMLElement>;
-                        }>>;
-                    };
-                    zIndex: string | number;
-                    style: vue.StyleValue;
-                    eager: boolean;
-                    disabled: boolean;
-                    modelValue: boolean;
-                    closeDelay: NonNullable<string | number>;
-                    openDelay: NonNullable<string | number>;
-                    activatorProps: Record<string, any>;
-                    openOnClick: boolean;
-                    openOnHover: boolean;
-                    openOnFocus: 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>;
-                }> & Omit<{
-                    location: Anchor;
-                    origin: "auto" | Anchor | "overlap";
-                    transition: NonNullable<string | boolean | (vue.TransitionProps & {
-                        component?: vue.Component | undefined;
-                    })> | {
-                        component: {
-                            new (...args: any[]): {
-                                $: vue.ComponentInternalInstance;
-                                $data: {};
-                                $props: Partial<{}> & Omit<{} & {
-                                    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;
-                                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                                $attrs: {
-                                    [x: string]: unknown;
-                                };
-                                $refs: {
-                                    [x: string]: unknown;
-                                };
-                                $slots: Readonly<{
-                                    [name: string]: vue.Slot | undefined;
-                                }>;
-                                $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                                $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                                $emit: (event: string, ...args: any[]) => void;
-                                $el: any;
-                                $options: vue.ComponentOptionsBase<{} & {
-                                    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, {}, {}, string> & {
-                                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                                    created?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                                    mounted?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                                    updated?: ((() => void) | (() => void)[]) | undefined;
-                                    activated?: ((() => void) | (() => void)[]) | undefined;
-                                    deactivated?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                                    destroyed?: ((() => void) | (() => void)[]) | undefined;
-                                    unmounted?: ((() => void) | (() => void)[]) | undefined;
-                                    renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                    renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                    errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                                };
-                                $forceUpdate: () => void;
-                                $nextTick: typeof nextTick;
-                                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                            } & {} & {
-                                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;
-                            } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } & vue.ComponentOptionsBase<{} & {
-                            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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                            target: PropType<HTMLElement>;
-                        }, vue.ExtractPropTypes<{
-                            target: PropType<HTMLElement>;
-                        }>>;
-                    };
-                    zIndex: string | number;
-                    style: vue.StyleValue;
-                    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;
-                    class?: any;
-                    theme?: string | undefined;
-                    contentClass?: any;
-                    activator?: string | Element | vue.ComponentPublicInstance | undefined;
-                    openOnClick?: boolean | undefined;
-                    openOnFocus?: boolean | undefined;
-                    contentProps?: any;
-                    attach?: string | boolean | Element | undefined;
-                } & {
-                    $children?: vue.VNodeChild | {
-                        default?: ((args_0: {
-                            isActive: vue.Ref<boolean>;
-                        }) => vue.VNodeChild) | undefined;
-                        activator?: ((args_0: {
-                            isActive: boolean;
-                            props: Record<string, any>;
-                        }) => vue.VNodeChild) | undefined;
-                    } | ((args_0: {
-                        isActive: vue.Ref<boolean>;
-                    }) => vue.VNodeChild);
-                    'v-slots'?: {
-                        default?: false | ((args_0: {
-                            isActive: vue.Ref<boolean>;
-                        }) => vue.VNodeChild) | undefined;
-                        activator?: false | ((args_0: {
-                            isActive: boolean;
-                            props: Record<string, any>;
-                        }) => vue.VNodeChild) | undefined;
-                    } | undefined;
-                } & {
-                    "v-slot:default"?: false | ((args_0: {
-                        isActive: vue.Ref<boolean>;
-                    }) => vue.VNodeChild) | undefined;
-                    "v-slot:activator"?: false | ((args_0: {
-                        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" | "style" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">>;
-            };
-            multiple: BooleanConstructor;
-            noDataText: {
-                type: StringConstructor;
-                default: string;
-            };
-            openOnClear: BooleanConstructor;
-            valueComparator: {
-                type: PropType<typeof deepEqual>;
-                default: typeof deepEqual;
-            };
-            customFilter: PropType<FilterFunction>;
-            customKeyFilter: PropType<FilterKeyFunctions>;
-            filterKeys: {
-                type: PropType<NonNullable<FilterKeys>>;
-                default: NonNullable<FilterKeys>;
-            };
-            filterMode: {
-                type: PropType<FilterMode>;
-                default: string;
-            };
-            noFilter: BooleanConstructor;
-            delimiters: PropType<string[]>;
-        }, "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:focused"?: ((focused: boolean) => any) | undefined;
-            "onUpdate:menu"?: ((val: boolean) => any) | undefined;
-            "onUpdate:search"?: ((val: string) => any) | undefined;
-        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "flat" | "reverse" | "type" | "error" | "active" | "direction" | "transition" | "menu" | "style" | "autofocus" | "eager" | "disabled" | "readonly" | "noDataText" | "messages" | "rounded" | "density" | "variant" | "clearIcon" | "focused" | "errorMessages" | "maxErrors" | "rules" | "persistentHint" | "clearable" | "persistentClear" | "singleLine" | "persistentPlaceholder" | "persistentCounter" | "valueComparator" | "itemTitle" | "itemValue" | "itemChildren" | "itemProps" | "chips" | "closableChips" | "hideNoData" | "hideSelected" | "menuIcon" | "openOnClear" | "filterMode" | "noFilter" | "filterKeys">;
-        $attrs: {
-            [x: string]: unknown;
-        };
-        $refs: {
-            [x: string]: unknown;
-        };
-        $slots: Readonly<{
-            [name: string]: vue.Slot | undefined;
-        }>;
-        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-        $emit: ((event: "update:focused", focused: boolean) => void) & ((event: "update:menu", val: boolean) => void) & ((event: "update:search", val: string) => void);
-        $el: any;
-        $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
-            transition: Omit<{
-                type: PropType<string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component | undefined;
-                })>;
-                default: string;
-                validator: (val: unknown) => boolean;
-            }, "type" | "default"> & {
-                type: PropType<NonNullable<string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component | undefined;
-                })>>;
-                default: NonNullable<string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component | undefined;
-                })>;
-            };
-            flat: BooleanConstructor;
-            reverse: BooleanConstructor;
-            type: {
-                type: StringConstructor;
-                default: string;
-            };
-            error: BooleanConstructor;
-            id: StringConstructor;
-            active: BooleanConstructor;
-            name: StringConstructor;
-            color: StringConstructor;
-            direction: {
-                type: PropType<"horizontal" | "vertical">;
-                default: string;
-                validator: (v: any) => boolean;
-            };
-            loading: (StringConstructor | BooleanConstructor)[];
-            label: StringConstructor;
-            style: {
-                type: PropType<vue.StyleValue>;
-                default: null;
-            };
-            prefix: StringConstructor;
-            autofocus: BooleanConstructor;
-            disabled: BooleanConstructor;
-            readonly: BooleanConstructor;
-            class: PropType<any>;
-            placeholder: StringConstructor;
-            theme: StringConstructor;
-            counter: PropType<string | number | true>;
-            messages: {
-                type: PropType<string | string[]>;
-                default: () => never[];
-            };
-            rounded: {
-                type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
-                default: undefined;
-            };
-            density: {
-                type: PropType<Density>;
-                default: string;
-                validator: (v: any) => boolean;
-            };
-            variant: {
-                type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled">;
-                default: string;
-                validator: (v: any) => boolean;
-            };
-            modelValue: {
-                type: PropType<any>;
-                default: any;
-            };
-            bgColor: StringConstructor;
-            prependIcon: PropType<IconValue>;
-            appendIcon: PropType<IconValue>;
-            clearIcon: {
-                type: PropType<IconValue>;
-                default: string;
-            };
-            prependInnerIcon: PropType<IconValue>;
-            'onClick:clear': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-            'onClick:append': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-            'onClick:prepend': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-            'onClick:appendInner': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-            'onClick:prependInner': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-            focused: BooleanConstructor;
-            'onUpdate:focused': PropType<EventProp<[boolean], (args_0: boolean) => any>>;
-            validateOn: PropType<"input" | "blur" | "submit" | undefined>;
-            errorMessages: {
-                type: PropType<string | string[]>;
-                default: () => never[];
-            };
-            maxErrors: {
-                type: (StringConstructor | NumberConstructor)[];
-                default: number;
-            };
-            rules: {
-                type: PropType<ValidationRule[]>;
-                default: () => never[];
-            };
-            hint: StringConstructor;
-            persistentHint: BooleanConstructor;
-            hideDetails: PropType<boolean | "auto">;
-            clearable: BooleanConstructor;
-            baseColor: StringConstructor;
-            persistentClear: BooleanConstructor;
-            singleLine: BooleanConstructor;
-            persistentPlaceholder: BooleanConstructor;
-            persistentCounter: BooleanConstructor;
-            suffix: StringConstructor;
-            counterValue: PropType<(value: any) => number>;
-            modelModifiers: PropType<Record<string, boolean>>;
-            items: {
-                type: PropType<any[]>;
-                default: () => never[];
-            };
-            itemTitle: {
-                type: PropType<SelectItemKey>;
-                default: string;
-            };
-            itemValue: {
-                type: PropType<SelectItemKey>;
-                default: string;
-            };
-            itemChildren: Omit<{
-                type: PropType<SelectItemKey>;
-                default: string;
-            }, "type" | "default"> & {
-                type: PropType<NonNullable<SelectItemKey>>;
-                default: NonNullable<SelectItemKey>;
-            };
-            itemProps: {
-                type: PropType<SelectItemKey>;
-                default: string;
-            };
-            returnObject: {
-                type: PropType<boolean>;
-                default: boolean;
-            };
-            chips: BooleanConstructor;
-            closableChips: BooleanConstructor;
-            eager: BooleanConstructor;
-            hideNoData: {
-                type: PropType<boolean>;
-                default: boolean;
-            };
-            hideSelected: BooleanConstructor;
-            menu: BooleanConstructor;
-            menuIcon: {
-                type: PropType<IconValue>;
-                default: string;
-            };
-            menuProps: {
-                type: PropType<Partial<{
-                    location: Anchor;
-                    origin: "auto" | Anchor | "overlap";
-                    transition: NonNullable<string | boolean | (vue.TransitionProps & {
-                        component?: vue.Component | undefined;
-                    })> | {
-                        component: {
-                            new (...args: any[]): {
-                                $: vue.ComponentInternalInstance;
-                                $data: {};
-                                $props: Partial<{}> & Omit<{} & {
-                                    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;
-                                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                                $attrs: {
-                                    [x: string]: unknown;
-                                };
-                                $refs: {
-                                    [x: string]: unknown;
-                                };
-                                $slots: Readonly<{
-                                    [name: string]: vue.Slot | undefined;
-                                }>;
-                                $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                                $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                                $emit: (event: string, ...args: any[]) => void;
-                                $el: any;
-                                $options: vue.ComponentOptionsBase<{} & {
-                                    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, {}, {}, string> & {
-                                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                                    created?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                                    mounted?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                                    updated?: ((() => void) | (() => void)[]) | undefined;
-                                    activated?: ((() => void) | (() => void)[]) | undefined;
-                                    deactivated?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                                    destroyed?: ((() => void) | (() => void)[]) | undefined;
-                                    unmounted?: ((() => void) | (() => void)[]) | undefined;
-                                    renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                    renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                    errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                                };
-                                $forceUpdate: () => void;
-                                $nextTick: typeof nextTick;
-                                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                            } & {} & {
-                                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;
-                            } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } & vue.ComponentOptionsBase<{} & {
-                            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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                            target: PropType<HTMLElement>;
-                        }, vue.ExtractPropTypes<{
-                            target: PropType<HTMLElement>;
-                        }>>;
-                    };
-                    zIndex: string | number;
-                    style: vue.StyleValue;
-                    eager: boolean;
-                    disabled: boolean;
-                    modelValue: boolean;
-                    closeDelay: NonNullable<string | number>;
-                    openDelay: NonNullable<string | number>;
-                    activatorProps: Record<string, any>;
-                    openOnClick: boolean;
-                    openOnHover: boolean;
-                    openOnFocus: 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>;
-                }> & Omit<{
-                    location: Anchor;
-                    origin: "auto" | Anchor | "overlap";
-                    transition: NonNullable<string | boolean | (vue.TransitionProps & {
-                        component?: vue.Component | undefined;
-                    })> | {
-                        component: {
-                            new (...args: any[]): {
-                                $: vue.ComponentInternalInstance;
-                                $data: {};
-                                $props: Partial<{}> & Omit<{} & {
-                                    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;
-                                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                                $attrs: {
-                                    [x: string]: unknown;
-                                };
-                                $refs: {
-                                    [x: string]: unknown;
-                                };
-                                $slots: Readonly<{
-                                    [name: string]: vue.Slot | undefined;
-                                }>;
-                                $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                                $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                                $emit: (event: string, ...args: any[]) => void;
-                                $el: any;
-                                $options: vue.ComponentOptionsBase<{} & {
-                                    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, {}, {}, string> & {
-                                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                                    created?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                                    mounted?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                                    updated?: ((() => void) | (() => void)[]) | undefined;
-                                    activated?: ((() => void) | (() => void)[]) | undefined;
-                                    deactivated?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                                    destroyed?: ((() => void) | (() => void)[]) | undefined;
-                                    unmounted?: ((() => void) | (() => void)[]) | undefined;
-                                    renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                    renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                    errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                                };
-                                $forceUpdate: () => void;
-                                $nextTick: typeof nextTick;
-                                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                            } & {} & {
-                                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;
-                            } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } & vue.ComponentOptionsBase<{} & {
-                            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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                            target: PropType<HTMLElement>;
-                        }, vue.ExtractPropTypes<{
-                            target: PropType<HTMLElement>;
-                        }>>;
-                    };
-                    zIndex: string | number;
-                    style: vue.StyleValue;
-                    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;
-                    class?: any;
-                    theme?: string | undefined;
-                    contentClass?: any;
-                    activator?: string | Element | vue.ComponentPublicInstance | undefined;
-                    openOnClick?: boolean | undefined;
-                    openOnFocus?: boolean | undefined;
-                    contentProps?: any;
-                    attach?: string | boolean | Element | undefined;
-                } & {
-                    $children?: vue.VNodeChild | {
-                        default?: ((args_0: {
-                            isActive: vue.Ref<boolean>;
-                        }) => vue.VNodeChild) | undefined;
-                        activator?: ((args_0: {
-                            isActive: boolean;
-                            props: Record<string, any>;
-                        }) => vue.VNodeChild) | undefined;
-                    } | ((args_0: {
+                })> | {
+                    component: vue.Component;
+                } | undefined;
+                zIndex?: string | number | undefined;
+                style?: vue.StyleValue | undefined;
+                eager?: boolean | undefined;
+                disabled?: boolean | undefined;
+                modelValue?: boolean | undefined;
+                closeDelay?: NonNullable<string | number> | undefined;
+                openDelay?: NonNullable<string | number> | undefined;
+                activatorProps?: Record<string, any> | undefined;
+                openOnClick?: boolean | undefined;
+                openOnHover?: boolean | undefined;
+                openOnFocus?: boolean | undefined;
+                closeOnContentClick?: boolean | undefined;
+                locationStrategy?: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+                    updateLocation: (e: Event) => void;
+                } | undefined)> | undefined;
+                scrollStrategy?: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition"> | undefined;
+                closeOnBack?: boolean | undefined;
+                contained?: boolean | undefined;
+                noClickAnimation?: boolean | undefined;
+                persistent?: boolean | undefined;
+                scrim?: NonNullable<string | boolean> | undefined;
+                offset?: string | number | number[] | undefined;
+                key?: string | number | symbol | 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;
+                class?: any;
+                $children?: vue.VNodeChild | {
+                    default?: ((args_0: {
                         isActive: vue.Ref<boolean>;
-                    }) => vue.VNodeChild);
-                    'v-slots'?: {
-                        default?: false | ((args_0: {
-                            isActive: vue.Ref<boolean>;
-                        }) => vue.VNodeChild) | undefined;
-                        activator?: false | ((args_0: {
-                            isActive: boolean;
-                            props: Record<string, any>;
-                        }) => vue.VNodeChild) | undefined;
-                    } | undefined;
-                } & {
-                    "v-slot:default"?: false | ((args_0: {
+                    }) => vue.VNodeChild) | undefined;
+                    activator?: ((args_0: {
+                        isActive: boolean;
+                        props: Record<string, any>;
+                    }) => vue.VNodeChild) | undefined;
+                } | ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild);
+                ref?: vue.VNodeRef | undefined;
+                ref_for?: boolean | undefined;
+                ref_key?: string | undefined;
+                theme?: string | undefined;
+                "v-slot:default"?: false | ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
+                'v-slots'?: {
+                    default?: false | ((args_0: {
                         isActive: vue.Ref<boolean>;
                     }) => vue.VNodeChild) | undefined;
-                    "v-slot:activator"?: false | ((args_0: {
+                    activator?: false | ((args_0: {
                         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" | "style" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">>;
-            };
-            multiple: BooleanConstructor;
-            noDataText: {
-                type: StringConstructor;
-                default: string;
-            };
-            openOnClear: BooleanConstructor;
-            valueComparator: {
-                type: PropType<typeof deepEqual>;
-                default: typeof deepEqual;
-            };
-            customFilter: PropType<FilterFunction>;
-            customKeyFilter: PropType<FilterKeyFunctions>;
-            filterKeys: {
-                type: PropType<NonNullable<FilterKeys>>;
-                default: NonNullable<FilterKeys>;
-            };
-            filterMode: {
-                type: PropType<FilterMode>;
-                default: string;
-            };
-            noFilter: BooleanConstructor;
-            delimiters: PropType<string[]>;
-        }, "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:focused"?: ((focused: boolean) => any) | undefined;
+                } | undefined;
+                contentClass?: any;
+                onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                activator?: string | Element | vue.ComponentPublicInstance | undefined;
+                "v-slot:activator"?: false | ((args_0: {
+                    isActive: boolean;
+                    props: Record<string, any>;
+                }) => vue.VNodeChild) | undefined;
+                contentProps?: any;
+                attach?: string | boolean | Element | undefined;
+            } | undefined;
             "onUpdate:menu"?: ((val: boolean) => any) | undefined;
+            customFilter?: FilterFunction | undefined;
+            customKeyFilter?: FilterKeyFunctions | undefined;
             "onUpdate:search"?: ((val: string) => any) | undefined;
-        }, {
-            isFocused: vue.Ref<boolean>;
-            isPristine: vue.Ref<boolean>;
-            menu: vue.WritableComputedRef<boolean>;
-            search: vue.WritableComputedRef<string>;
-            selectionIndex: vue.Ref<number>;
-            filteredItems: vue.Ref<InternalItem<any>[]>;
-            select: (item: InternalItem) => void;
-        } & Omit<any, string | number | symbol>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
-            'update:focused': (focused: boolean) => true;
-            'update:modelValue': (val: any) => true;
-            'update:search': (val: string) => true;
-            '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, {
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            message?: ((args_0: VMessageSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            clear?: (() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            details?: ((args_0: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            label?: ((args_0: DefaultInputSlot & {
+                label: string | undefined;
+                props: Record<string, any>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            append?: ((args_0: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            prepend?: ((args_0: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            loader?: ((args_0: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            'prepend-inner'?: ((args_0: DefaultInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            'append-inner'?: ((args_0: DefaultInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            item?: ((args_0: {
+                item: InternalItem<unknown>;
+                index: number;
+                props: Record<string, unknown>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            chip?: ((args_0: {
+                item: InternalItem<unknown>;
+                index: number;
+                props: Record<string, unknown>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            selection?: ((args_0: {
+                item: InternalItem<unknown>;
+                index: number;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            'prepend-item'?: (() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            'append-item'?: (() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+            'no-data'?: (() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[]) | undefined;
+        }>;
+        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $emit: ((event: "update:focused", focused: boolean) => void) & ((event: "update:menu", val: boolean) => void) & ((event: "update:search", val: string) => void);
+        $el: any;
+        $options: vue.ComponentOptionsBase<{
             flat: boolean;
             reverse: boolean;
             type: string;
@@ -1203,18 +526,17 @@ declare const VCombobox: {
             readonly: boolean;
             noDataText: string;
             messages: string | string[];
-            rounded: string | number | boolean;
             density: Density;
             variant: "filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled";
             clearIcon: IconValue;
             focused: boolean;
+            clearable: boolean;
+            persistentClear: boolean;
+            singleLine: boolean;
             errorMessages: string | string[];
             maxErrors: string | number;
             rules: ValidationRule[];
             persistentHint: boolean;
-            clearable: boolean;
-            persistentClear: boolean;
-            singleLine: boolean;
             persistentPlaceholder: boolean;
             persistentCounter: boolean;
             valueComparator: typeof deepEqual;
@@ -1231,412 +553,67 @@ declare const VCombobox: {
             filterMode: FilterMode;
             noFilter: boolean;
             filterKeys: NonNullable<FilterKeys>;
-        }, {}, string> & {
-            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-            created?: ((() => void) | (() => void)[]) | undefined;
-            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-            mounted?: ((() => void) | (() => void)[]) | undefined;
-            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-            updated?: ((() => void) | (() => void)[]) | undefined;
-            activated?: ((() => void) | (() => void)[]) | undefined;
-            deactivated?: ((() => void) | (() => void)[]) | undefined;
-            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-            destroyed?: ((() => void) | (() => void)[]) | undefined;
-            unmounted?: ((() => void) | (() => void)[]) | undefined;
-            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-        };
-        $forceUpdate: () => void;
-        $nextTick: typeof nextTick;
-        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-    } & Readonly<vue.ExtractPropTypes<Omit<{
-        transition: Omit<{
-            type: PropType<string | boolean | (vue.TransitionProps & {
-                component?: vue.Component | undefined;
-            })>;
-            default: string;
-            validator: (val: unknown) => boolean;
-        }, "type" | "default"> & {
-            type: PropType<NonNullable<string | boolean | (vue.TransitionProps & {
-                component?: vue.Component | undefined;
-            })>>;
-            default: NonNullable<string | boolean | (vue.TransitionProps & {
-                component?: vue.Component | undefined;
-            })>;
-        };
-        flat: BooleanConstructor;
-        reverse: BooleanConstructor;
-        type: {
-            type: StringConstructor;
-            default: string;
-        };
-        error: BooleanConstructor;
-        id: StringConstructor;
-        active: BooleanConstructor;
-        name: StringConstructor;
-        color: StringConstructor;
-        direction: {
-            type: PropType<"horizontal" | "vertical">;
-            default: string;
-            validator: (v: any) => boolean;
-        };
-        loading: (StringConstructor | BooleanConstructor)[];
-        label: StringConstructor;
-        style: {
-            type: PropType<vue.StyleValue>;
-            default: null;
-        };
-        prefix: StringConstructor;
-        autofocus: BooleanConstructor;
-        disabled: BooleanConstructor;
-        readonly: BooleanConstructor;
-        class: PropType<any>;
-        placeholder: StringConstructor;
-        theme: StringConstructor;
-        counter: PropType<string | number | true>;
-        messages: {
-            type: PropType<string | string[]>;
-            default: () => never[];
-        };
-        rounded: {
-            type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
-            default: undefined;
-        };
-        density: {
-            type: PropType<Density>;
-            default: string;
-            validator: (v: any) => boolean;
-        };
-        variant: {
-            type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled">;
-            default: string;
-            validator: (v: any) => boolean;
-        };
-        modelValue: {
-            type: PropType<any>;
-            default: any;
-        };
-        bgColor: StringConstructor;
-        prependIcon: PropType<IconValue>;
-        appendIcon: PropType<IconValue>;
-        clearIcon: {
-            type: PropType<IconValue>;
-            default: string;
-        };
-        prependInnerIcon: PropType<IconValue>;
-        'onClick:clear': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-        'onClick:append': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-        'onClick:prepend': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-        'onClick:appendInner': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-        'onClick:prependInner': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-        focused: BooleanConstructor;
-        'onUpdate:focused': PropType<EventProp<[boolean], (args_0: boolean) => any>>;
-        validateOn: PropType<"input" | "blur" | "submit" | undefined>;
-        errorMessages: {
-            type: PropType<string | string[]>;
-            default: () => never[];
-        };
-        maxErrors: {
-            type: (StringConstructor | NumberConstructor)[];
-            default: number;
-        };
-        rules: {
-            type: PropType<ValidationRule[]>;
-            default: () => never[];
-        };
-        hint: StringConstructor;
-        persistentHint: BooleanConstructor;
-        hideDetails: PropType<boolean | "auto">;
-        clearable: BooleanConstructor;
-        baseColor: StringConstructor;
-        persistentClear: BooleanConstructor;
-        singleLine: BooleanConstructor;
-        persistentPlaceholder: BooleanConstructor;
-        persistentCounter: BooleanConstructor;
-        suffix: StringConstructor;
-        counterValue: PropType<(value: any) => number>;
-        modelModifiers: PropType<Record<string, boolean>>;
-        items: {
-            type: PropType<any[]>;
-            default: () => never[];
-        };
-        itemTitle: {
-            type: PropType<SelectItemKey>;
-            default: string;
-        };
-        itemValue: {
-            type: PropType<SelectItemKey>;
-            default: string;
-        };
-        itemChildren: Omit<{
-            type: PropType<SelectItemKey>;
-            default: string;
-        }, "type" | "default"> & {
-            type: PropType<NonNullable<SelectItemKey>>;
-            default: NonNullable<SelectItemKey>;
-        };
-        itemProps: {
-            type: PropType<SelectItemKey>;
-            default: string;
-        };
-        returnObject: {
-            type: PropType<boolean>;
-            default: boolean;
-        };
-        chips: BooleanConstructor;
-        closableChips: BooleanConstructor;
-        eager: BooleanConstructor;
-        hideNoData: {
-            type: PropType<boolean>;
-            default: boolean;
-        };
-        hideSelected: BooleanConstructor;
-        menu: BooleanConstructor;
-        menuIcon: {
-            type: PropType<IconValue>;
-            default: string;
-        };
-        menuProps: {
-            type: PropType<Partial<{
-                location: Anchor;
-                origin: "auto" | Anchor | "overlap";
-                transition: NonNullable<string | boolean | (vue.TransitionProps & {
-                    component?: vue.Component | undefined;
-                })> | {
-                    component: {
-                        new (...args: any[]): {
-                            $: vue.ComponentInternalInstance;
-                            $data: {};
-                            $props: Partial<{}> & Omit<{} & {
-                                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;
-                            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                            $attrs: {
-                                [x: string]: unknown;
-                            };
-                            $refs: {
-                                [x: string]: unknown;
-                            };
-                            $slots: Readonly<{
-                                [name: string]: vue.Slot | undefined;
-                            }>;
-                            $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                            $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                            $emit: (event: string, ...args: any[]) => void;
-                            $el: any;
-                            $options: vue.ComponentOptionsBase<{} & {
-                                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, {}, {}, string> & {
-                                beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                                created?: ((() => void) | (() => void)[]) | undefined;
-                                beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                                mounted?: ((() => void) | (() => void)[]) | undefined;
-                                beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                                updated?: ((() => void) | (() => void)[]) | undefined;
-                                activated?: ((() => void) | (() => void)[]) | undefined;
-                                deactivated?: ((() => void) | (() => void)[]) | undefined;
-                                beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                                beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                                destroyed?: ((() => void) | (() => void)[]) | undefined;
-                                unmounted?: ((() => void) | (() => void)[]) | undefined;
-                                renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                            };
-                            $forceUpdate: () => void;
-                            $nextTick: typeof nextTick;
-                            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                        } & {} & {
-                            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;
-                        } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                        __isFragment?: undefined;
-                        __isTeleport?: undefined;
-                        __isSuspense?: undefined;
-                    } & vue.ComponentOptionsBase<{} & {
-                        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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                        target: PropType<HTMLElement>;
-                    }, vue.ExtractPropTypes<{
-                        target: PropType<HTMLElement>;
-                    }>>;
-                };
-                zIndex: string | number;
-                style: vue.StyleValue;
-                eager: boolean;
-                disabled: boolean;
-                modelValue: boolean;
-                closeDelay: NonNullable<string | number>;
-                openDelay: NonNullable<string | number>;
-                activatorProps: Record<string, any>;
-                openOnClick: boolean;
-                openOnHover: boolean;
-                openOnFocus: 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>;
-            }> & Omit<{
-                location: Anchor;
-                origin: "auto" | Anchor | "overlap";
-                transition: NonNullable<string | boolean | (vue.TransitionProps & {
+        } & {
+            id?: string | undefined;
+            name?: string | undefined;
+            color?: string | undefined;
+            loading?: string | boolean | undefined;
+            label?: string | undefined;
+            prefix?: string | undefined;
+            class?: any;
+            delimiters?: string[] | undefined;
+            placeholder?: string | undefined;
+            theme?: string | undefined;
+            counter?: string | number | true | undefined;
+            rounded?: string | number | boolean | undefined;
+            bgColor?: string | undefined;
+            prependIcon?: IconValue | undefined;
+            appendIcon?: IconValue | undefined;
+            prependInnerIcon?: IconValue | undefined;
+            'onClick:clear'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+            'onClick:append'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+            'onClick:prepend'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+            'onClick:appendInner'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+            'onClick:prependInner'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+            'onUpdate:focused'?: EventProp<[boolean], (args_0: boolean) => any> | undefined;
+            baseColor?: string | undefined;
+            validateOn?: "input" | "blur" | "submit" | undefined;
+            hint?: string | undefined;
+            hideDetails?: boolean | "auto" | undefined;
+            suffix?: string | undefined;
+            counterValue?: ((value: any) => number) | undefined;
+            modelModifiers?: Record<string, boolean> | undefined;
+            menuProps?: {
+                location?: Anchor | undefined;
+                origin?: "auto" | Anchor | "overlap" | undefined;
+                transition?: NonNullable<string | boolean | (vue.TransitionProps & {
                     component?: vue.Component | undefined;
                 })> | {
-                    component: {
-                        new (...args: any[]): {
-                            $: vue.ComponentInternalInstance;
-                            $data: {};
-                            $props: Partial<{}> & Omit<{} & {
-                                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;
-                            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                            $attrs: {
-                                [x: string]: unknown;
-                            };
-                            $refs: {
-                                [x: string]: unknown;
-                            };
-                            $slots: Readonly<{
-                                [name: string]: vue.Slot | undefined;
-                            }>;
-                            $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                            $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                            $emit: (event: string, ...args: any[]) => void;
-                            $el: any;
-                            $options: vue.ComponentOptionsBase<{} & {
-                                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, {}, {}, string> & {
-                                beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                                created?: ((() => void) | (() => void)[]) | undefined;
-                                beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                                mounted?: ((() => void) | (() => void)[]) | undefined;
-                                beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                                updated?: ((() => void) | (() => void)[]) | undefined;
-                                activated?: ((() => void) | (() => void)[]) | undefined;
-                                deactivated?: ((() => void) | (() => void)[]) | undefined;
-                                beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                                beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                                destroyed?: ((() => void) | (() => void)[]) | undefined;
-                                unmounted?: ((() => void) | (() => void)[]) | undefined;
-                                renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                                errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                            };
-                            $forceUpdate: () => void;
-                            $nextTick: typeof nextTick;
-                            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                        } & {} & {
-                            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;
-                        } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                        __isFragment?: undefined;
-                        __isTeleport?: undefined;
-                        __isSuspense?: undefined;
-                    } & vue.ComponentOptionsBase<{} & {
-                        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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                        target: PropType<HTMLElement>;
-                    }, vue.ExtractPropTypes<{
-                        target: PropType<HTMLElement>;
-                    }>>;
-                };
-                zIndex: string | number;
-                style: vue.StyleValue;
-                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>>) => {
+                    component: vue.Component;
+                } | undefined;
+                zIndex?: string | number | undefined;
+                style?: vue.StyleValue | undefined;
+                eager?: boolean | undefined;
+                disabled?: boolean | undefined;
+                modelValue?: boolean | undefined;
+                closeDelay?: NonNullable<string | number> | undefined;
+                openDelay?: NonNullable<string | number> | undefined;
+                activatorProps?: Record<string, any> | undefined;
+                openOnClick?: boolean | undefined;
+                openOnHover?: boolean | undefined;
+                openOnFocus?: boolean | undefined;
+                closeOnContentClick?: boolean | undefined;
+                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>;
-            } & {
+                } | undefined)> | undefined;
+                scrollStrategy?: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition"> | undefined;
+                closeOnBack?: boolean | undefined;
+                contained?: boolean | undefined;
+                noClickAnimation?: boolean | undefined;
+                persistent?: boolean | undefined;
+                scrim?: NonNullable<string | boolean> | undefined;
                 offset?: string | number | number[] | undefined;
+                key?: string | number | symbol | undefined;
                 id?: string | undefined;
                 height?: string | number | undefined;
                 width?: string | number | undefined;
@@ -1645,14 +622,6 @@ declare const VCombobox: {
                 minHeight?: string | number | undefined;
                 minWidth?: string | number | undefined;
                 class?: any;
-                theme?: string | undefined;
-                contentClass?: any;
-                activator?: string | Element | vue.ComponentPublicInstance | undefined;
-                openOnClick?: boolean | undefined;
-                openOnFocus?: boolean | undefined;
-                contentProps?: any;
-                attach?: string | boolean | Element | undefined;
-            } & {
                 $children?: vue.VNodeChild | {
                     default?: ((args_0: {
                         isActive: vue.Ref<boolean>;
@@ -1664,6 +633,13 @@ declare const VCombobox: {
                 } | ((args_0: {
                     isActive: vue.Ref<boolean>;
                 }) => vue.VNodeChild);
+                ref?: vue.VNodeRef | undefined;
+                ref_for?: boolean | undefined;
+                ref_key?: string | undefined;
+                theme?: string | undefined;
+                "v-slot:default"?: false | ((args_0: {
+                    isActive: vue.Ref<boolean>;
+                }) => vue.VNodeChild) | undefined;
                 'v-slots'?: {
                     default?: false | ((args_0: {
                         isActive: vue.Ref<boolean>;
@@ -1673,442 +649,298 @@ declare const VCombobox: {
                         props: Record<string, any>;
                     }) => vue.VNodeChild) | undefined;
                 } | undefined;
-            } & {
-                "v-slot:default"?: false | ((args_0: {
-                    isActive: vue.Ref<boolean>;
-                }) => vue.VNodeChild) | undefined;
+                contentClass?: any;
+                onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>) => void)[] | undefined;
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                activator?: string | Element | vue.ComponentPublicInstance | undefined;
                 "v-slot:activator"?: false | ((args_0: {
                     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" | "style" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">>;
-        };
-        multiple: BooleanConstructor;
-        noDataText: {
-            type: StringConstructor;
-            default: string;
-        };
-        openOnClear: BooleanConstructor;
-        valueComparator: {
-            type: PropType<typeof deepEqual>;
-            default: typeof deepEqual;
-        };
-        customFilter: PropType<FilterFunction>;
-        customKeyFilter: PropType<FilterKeyFunctions>;
-        filterKeys: {
-            type: PropType<NonNullable<FilterKeys>>;
-            default: NonNullable<FilterKeys>;
-        };
-        filterMode: {
-            type: PropType<FilterMode>;
-            default: string;
-        };
-        noFilter: BooleanConstructor;
-        delimiters: PropType<string[]>;
-    }, "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:focused"?: ((focused: boolean) => any) | undefined;
-        "onUpdate:menu"?: ((val: boolean) => any) | undefined;
-        "onUpdate:search"?: ((val: string) => any) | undefined;
-    } & vue.ShallowUnwrapRef<{
-        isFocused: vue.Ref<boolean>;
-        isPristine: vue.Ref<boolean>;
-        menu: vue.WritableComputedRef<boolean>;
-        search: vue.WritableComputedRef<string>;
-        selectionIndex: vue.Ref<number>;
-        filteredItems: vue.Ref<InternalItem<any>[]>;
-        select: (item: InternalItem) => void;
-    } & Omit<any, string | number | symbol>> & {} & vue.ComponentCustomProperties & {};
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<Omit<{
-    transition: Omit<{
-        type: PropType<string | boolean | (vue.TransitionProps & {
-            component?: vue.Component | undefined;
-        })>;
-        default: string;
-        validator: (val: unknown) => boolean;
-    }, "type" | "default"> & {
-        type: PropType<NonNullable<string | boolean | (vue.TransitionProps & {
-            component?: vue.Component | undefined;
-        })>>;
-        default: NonNullable<string | boolean | (vue.TransitionProps & {
-            component?: vue.Component | undefined;
-        })>;
-    };
-    flat: BooleanConstructor;
-    reverse: BooleanConstructor;
-    type: {
-        type: StringConstructor;
-        default: string;
-    };
-    error: BooleanConstructor;
-    id: StringConstructor;
-    active: BooleanConstructor;
-    name: StringConstructor;
-    color: StringConstructor;
-    direction: {
-        type: PropType<"horizontal" | "vertical">;
-        default: string;
-        validator: (v: any) => boolean;
-    };
-    loading: (StringConstructor | BooleanConstructor)[];
-    label: StringConstructor;
-    style: {
-        type: PropType<vue.StyleValue>;
-        default: null;
-    };
-    prefix: StringConstructor;
-    autofocus: BooleanConstructor;
-    disabled: BooleanConstructor;
-    readonly: BooleanConstructor;
-    class: PropType<any>;
-    placeholder: StringConstructor;
-    theme: StringConstructor;
-    counter: PropType<string | number | true>;
-    messages: {
-        type: PropType<string | string[]>;
-        default: () => never[];
-    };
-    rounded: {
-        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
-        default: undefined;
-    };
-    density: {
-        type: PropType<Density>;
-        default: string;
-        validator: (v: any) => boolean;
-    };
-    variant: {
-        type: PropType<"filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled">;
-        default: string;
-        validator: (v: any) => boolean;
-    };
-    modelValue: {
-        type: PropType<any>;
-        default: any;
-    };
-    bgColor: StringConstructor;
-    prependIcon: PropType<IconValue>;
-    appendIcon: PropType<IconValue>;
-    clearIcon: {
-        type: PropType<IconValue>;
-        default: string;
-    };
-    prependInnerIcon: PropType<IconValue>;
-    'onClick:clear': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-    'onClick:append': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-    'onClick:prepend': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-    'onClick:appendInner': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-    'onClick:prependInner': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
-    focused: BooleanConstructor;
-    'onUpdate:focused': PropType<EventProp<[boolean], (args_0: boolean) => any>>;
-    validateOn: PropType<"input" | "blur" | "submit" | undefined>;
-    errorMessages: {
-        type: PropType<string | string[]>;
-        default: () => never[];
-    };
-    maxErrors: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: number;
-    };
-    rules: {
-        type: PropType<ValidationRule[]>;
-        default: () => never[];
-    };
-    hint: StringConstructor;
-    persistentHint: BooleanConstructor;
-    hideDetails: PropType<boolean | "auto">;
-    clearable: BooleanConstructor;
-    baseColor: StringConstructor;
-    persistentClear: BooleanConstructor;
-    singleLine: BooleanConstructor;
-    persistentPlaceholder: BooleanConstructor;
-    persistentCounter: BooleanConstructor;
-    suffix: StringConstructor;
-    counterValue: PropType<(value: any) => number>;
-    modelModifiers: PropType<Record<string, boolean>>;
-    items: {
-        type: PropType<any[]>;
-        default: () => never[];
-    };
-    itemTitle: {
-        type: PropType<SelectItemKey>;
-        default: string;
-    };
-    itemValue: {
-        type: PropType<SelectItemKey>;
-        default: string;
-    };
-    itemChildren: Omit<{
-        type: PropType<SelectItemKey>;
-        default: string;
-    }, "type" | "default"> & {
-        type: PropType<NonNullable<SelectItemKey>>;
-        default: NonNullable<SelectItemKey>;
-    };
-    itemProps: {
-        type: PropType<SelectItemKey>;
-        default: string;
-    };
-    returnObject: {
-        type: PropType<boolean>;
-        default: boolean;
-    };
-    chips: BooleanConstructor;
-    closableChips: BooleanConstructor;
-    eager: BooleanConstructor;
-    hideNoData: {
-        type: PropType<boolean>;
-        default: boolean;
-    };
-    hideSelected: BooleanConstructor;
-    menu: BooleanConstructor;
-    menuIcon: {
-        type: PropType<IconValue>;
-        default: string;
-    };
-    menuProps: {
-        type: PropType<Partial<{
-            location: Anchor;
-            origin: "auto" | Anchor | "overlap";
+                contentProps?: any;
+                attach?: string | boolean | Element | undefined;
+            } | undefined;
+            customFilter?: FilterFunction | undefined;
+            customKeyFilter?: FilterKeyFunctions | undefined;
+        } & {
+            "onUpdate:modelValue"?: ((val: any) => any) | undefined;
+            "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
+            "onUpdate:menu"?: ((val: boolean) => any) | undefined;
+            "onUpdate:search"?: ((val: string) => any) | undefined;
+        }, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+            'update:focused': (focused: boolean) => true;
+            'update:modelValue': (val: any) => true;
+            'update:search': (val: string) => true;
+            'update:menu': (val: boolean) => true;
+        }, "multiple" | "$children" | "items" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "update:modelValue" | "v-slot:loader" | "v-slot:clear" | "v-slot:label" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:message" | "v-slot:details" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">, string, {
+            flat: boolean;
+            reverse: boolean;
+            type: string;
+            error: boolean;
+            active: boolean;
+            direction: "horizontal" | "vertical";
             transition: NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component | undefined;
-            })> | {
-                component: {
-                    new (...args: any[]): {
-                        $: vue.ComponentInternalInstance;
-                        $data: {};
-                        $props: Partial<{}> & Omit<{} & {
-                            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;
-                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                        $attrs: {
-                            [x: string]: unknown;
-                        };
-                        $refs: {
-                            [x: string]: unknown;
-                        };
-                        $slots: Readonly<{
-                            [name: string]: vue.Slot | undefined;
-                        }>;
-                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $emit: (event: string, ...args: any[]) => void;
-                        $el: any;
-                        $options: vue.ComponentOptionsBase<{} & {
-                            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, {}, {}, string> & {
-                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                            created?: ((() => void) | (() => void)[]) | undefined;
-                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                            mounted?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                            updated?: ((() => void) | (() => void)[]) | undefined;
-                            activated?: ((() => void) | (() => void)[]) | undefined;
-                            deactivated?: ((() => void) | (() => void)[]) | undefined;
-                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                            destroyed?: ((() => void) | (() => void)[]) | undefined;
-                            unmounted?: ((() => void) | (() => void)[]) | undefined;
-                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                        };
-                        $forceUpdate: () => void;
-                        $nextTick: typeof nextTick;
-                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                    } & {} & {
-                        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;
-                    } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } & vue.ComponentOptionsBase<{} & {
-                    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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                    target: PropType<HTMLElement>;
-                }, vue.ExtractPropTypes<{
-                    target: PropType<HTMLElement>;
-                }>>;
-            };
-            zIndex: string | number;
+            })>;
+            menu: boolean;
             style: vue.StyleValue;
+            autofocus: boolean;
             eager: boolean;
             disabled: boolean;
-            modelValue: boolean;
-            closeDelay: NonNullable<string | number>;
-            openDelay: NonNullable<string | number>;
-            activatorProps: Record<string, any>;
-            openOnClick: boolean;
-            openOnHover: boolean;
-            openOnFocus: 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>;
-        }> & Omit<{
-            location: Anchor;
-            origin: "auto" | Anchor | "overlap";
-            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            readonly: boolean;
+            noDataText: string;
+            messages: string | string[];
+            rounded: string | number | boolean;
+            density: Density;
+            variant: "filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled";
+            clearIcon: IconValue;
+            focused: boolean;
+            clearable: boolean;
+            persistentClear: boolean;
+            singleLine: boolean;
+            errorMessages: string | string[];
+            maxErrors: string | number;
+            rules: ValidationRule[];
+            persistentHint: boolean;
+            persistentPlaceholder: boolean;
+            persistentCounter: boolean;
+            valueComparator: typeof deepEqual;
+            itemTitle: SelectItemKey;
+            itemValue: SelectItemKey;
+            itemChildren: NonNullable<SelectItemKey>;
+            itemProps: SelectItemKey;
+            chips: boolean;
+            closableChips: boolean;
+            hideNoData: boolean;
+            hideSelected: boolean;
+            menuIcon: IconValue;
+            openOnClear: boolean;
+            filterMode: FilterMode;
+            noFilter: boolean;
+            filterKeys: NonNullable<FilterKeys>;
+        }, {}, string, vue.SlotsType<Partial<{
+            message: (args_0: VMessageSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            clear: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            details: (args_0: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            label: (args_0: DefaultInputSlot & {
+                label: string | undefined;
+                props: Record<string, any>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            append: (args_0: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            prepend: (args_0: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            loader: (args_0: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            'prepend-inner': (args_0: DefaultInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            'append-inner': (args_0: DefaultInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            item: (args_0: {
+                item: InternalItem<unknown>;
+                index: number;
+                props: Record<string, unknown>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            chip: (args_0: {
+                item: InternalItem<unknown>;
+                index: number;
+                props: Record<string, unknown>;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            selection: (args_0: {
+                item: InternalItem<unknown>;
+                index: number;
+            }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            'prepend-item': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            'append-item': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+            'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }>>> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+    } & {
+        flat: boolean;
+        reverse: boolean;
+        type: string;
+        error: boolean;
+        active: boolean;
+        direction: "horizontal" | "vertical";
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        menu: boolean;
+        style: vue.StyleValue;
+        autofocus: boolean;
+        eager: boolean;
+        disabled: boolean;
+        readonly: boolean;
+        noDataText: string;
+        messages: string | string[];
+        density: Density;
+        variant: "filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled";
+        clearIcon: IconValue;
+        focused: boolean;
+        clearable: boolean;
+        persistentClear: boolean;
+        singleLine: boolean;
+        errorMessages: string | string[];
+        maxErrors: string | number;
+        rules: ValidationRule[];
+        persistentHint: boolean;
+        persistentPlaceholder: boolean;
+        persistentCounter: boolean;
+        valueComparator: typeof deepEqual;
+        itemTitle: SelectItemKey;
+        itemValue: SelectItemKey;
+        itemChildren: NonNullable<SelectItemKey>;
+        itemProps: SelectItemKey;
+        chips: boolean;
+        closableChips: boolean;
+        hideNoData: boolean;
+        hideSelected: boolean;
+        menuIcon: IconValue;
+        openOnClear: boolean;
+        filterMode: FilterMode;
+        noFilter: boolean;
+        filterKeys: NonNullable<FilterKeys>;
+    } & {
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        loading?: string | boolean | undefined;
+        label?: string | undefined;
+        prefix?: string | undefined;
+        class?: any;
+        delimiters?: string[] | undefined;
+        placeholder?: string | undefined;
+        theme?: string | undefined;
+        counter?: string | number | true | undefined;
+        rounded?: string | number | boolean | undefined;
+        bgColor?: string | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        prependInnerIcon?: IconValue | undefined;
+        'onClick:clear'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+        'onClick:append'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+        'onClick:prepend'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+        'onClick:appendInner'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+        'onClick:prependInner'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+        'onUpdate:focused'?: EventProp<[boolean], (args_0: boolean) => any> | undefined;
+        baseColor?: string | undefined;
+        validateOn?: "input" | "blur" | "submit" | undefined;
+        hint?: string | undefined;
+        hideDetails?: boolean | "auto" | undefined;
+        suffix?: string | undefined;
+        counterValue?: ((value: any) => number) | undefined;
+        modelModifiers?: Record<string, boolean> | undefined;
+        menuProps?: {
+            location?: Anchor | undefined;
+            origin?: "auto" | Anchor | "overlap" | undefined;
+            transition?: NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component | undefined;
             })> | {
-                component: {
-                    new (...args: any[]): {
-                        $: vue.ComponentInternalInstance;
-                        $data: {};
-                        $props: Partial<{}> & Omit<{} & {
-                            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;
-                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                        $attrs: {
-                            [x: string]: unknown;
-                        };
-                        $refs: {
-                            [x: string]: unknown;
-                        };
-                        $slots: Readonly<{
-                            [name: string]: vue.Slot | undefined;
-                        }>;
-                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $emit: (event: string, ...args: any[]) => void;
-                        $el: any;
-                        $options: vue.ComponentOptionsBase<{} & {
-                            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, {}, {}, string> & {
-                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                            created?: ((() => void) | (() => void)[]) | undefined;
-                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                            mounted?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                            updated?: ((() => void) | (() => void)[]) | undefined;
-                            activated?: ((() => void) | (() => void)[]) | undefined;
-                            deactivated?: ((() => void) | (() => void)[]) | undefined;
-                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                            destroyed?: ((() => void) | (() => void)[]) | undefined;
-                            unmounted?: ((() => void) | (() => void)[]) | undefined;
-                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                        };
-                        $forceUpdate: () => void;
-                        $nextTick: typeof nextTick;
-                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                    } & {} & {
-                        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;
-                    } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } & vue.ComponentOptionsBase<{} & {
-                    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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                    target: PropType<HTMLElement>;
-                }, vue.ExtractPropTypes<{
-                    target: PropType<HTMLElement>;
-                }>>;
-            };
-            zIndex: string | number;
-            style: vue.StyleValue;
-            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>>) => {
+                component: vue.Component;
+            } | undefined;
+            zIndex?: string | number | undefined;
+            style?: vue.StyleValue | undefined;
+            eager?: boolean | undefined;
+            disabled?: boolean | undefined;
+            modelValue?: boolean | undefined;
+            closeDelay?: NonNullable<string | number> | undefined;
+            openDelay?: NonNullable<string | number> | undefined;
+            activatorProps?: Record<string, any> | undefined;
+            openOnClick?: boolean | undefined;
+            openOnHover?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            closeOnContentClick?: boolean | undefined;
+            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>;
-        } & {
+            } | undefined)> | undefined;
+            scrollStrategy?: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition"> | undefined;
+            closeOnBack?: boolean | undefined;
+            contained?: boolean | undefined;
+            noClickAnimation?: boolean | undefined;
+            persistent?: boolean | undefined;
+            scrim?: NonNullable<string | boolean> | undefined;
             offset?: string | number | number[] | undefined;
+            key?: string | number | symbol | undefined;
             id?: string | undefined;
             height?: string | number | undefined;
             width?: string | number | undefined;
@@ -2117,14 +949,6 @@ declare const VCombobox: {
             minHeight?: string | number | undefined;
             minWidth?: string | number | undefined;
             class?: any;
-            theme?: string | undefined;
-            contentClass?: any;
-            activator?: string | Element | vue.ComponentPublicInstance | undefined;
-            openOnClick?: boolean | undefined;
-            openOnFocus?: boolean | undefined;
-            contentProps?: any;
-            attach?: string | boolean | Element | undefined;
-        } & {
             $children?: vue.VNodeChild | {
                 default?: ((args_0: {
                     isActive: vue.Ref<boolean>;
@@ -2136,6 +960,13 @@ declare const VCombobox: {
             } | ((args_0: {
                 isActive: vue.Ref<boolean>;
             }) => vue.VNodeChild);
+            ref?: vue.VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            theme?: string | undefined;
+            "v-slot:default"?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
             'v-slots'?: {
                 default?: false | ((args_0: {
                     isActive: vue.Ref<boolean>;
@@ -2145,58 +976,267 @@ declare const VCombobox: {
                     props: Record<string, any>;
                 }) => vue.VNodeChild) | undefined;
             } | undefined;
-        } & {
-            "v-slot:default"?: false | ((args_0: {
+            contentClass?: any;
+            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            activator?: string | Element | vue.ComponentPublicInstance | undefined;
+            "v-slot:activator"?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        } | undefined;
+        customFilter?: FilterFunction | undefined;
+        customKeyFilter?: FilterKeyFunctions | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((val: any) => any) | undefined;
+        "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
+        "onUpdate:menu"?: ((val: boolean) => any) | undefined;
+        "onUpdate:search"?: ((val: string) => any) | undefined;
+    } & vue.ShallowUnwrapRef<any> & {} & vue.ComponentCustomProperties & {};
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    flat: boolean;
+    reverse: boolean;
+    type: string;
+    error: boolean;
+    active: boolean;
+    direction: "horizontal" | "vertical";
+    transition: NonNullable<string | boolean | (vue.TransitionProps & {
+        component?: vue.Component | undefined;
+    })>;
+    menu: boolean;
+    style: vue.StyleValue;
+    autofocus: boolean;
+    eager: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    noDataText: string;
+    messages: string | string[];
+    density: Density;
+    variant: "filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled";
+    clearIcon: IconValue;
+    focused: boolean;
+    clearable: boolean;
+    persistentClear: boolean;
+    singleLine: boolean;
+    errorMessages: string | string[];
+    maxErrors: string | number;
+    rules: ValidationRule[];
+    persistentHint: boolean;
+    persistentPlaceholder: boolean;
+    persistentCounter: boolean;
+    valueComparator: typeof deepEqual;
+    itemTitle: SelectItemKey;
+    itemValue: SelectItemKey;
+    itemChildren: NonNullable<SelectItemKey>;
+    itemProps: SelectItemKey;
+    chips: boolean;
+    closableChips: boolean;
+    hideNoData: boolean;
+    hideSelected: boolean;
+    menuIcon: IconValue;
+    openOnClear: boolean;
+    filterMode: FilterMode;
+    noFilter: boolean;
+    filterKeys: NonNullable<FilterKeys>;
+} & {
+    id?: string | undefined;
+    name?: string | undefined;
+    color?: string | undefined;
+    loading?: string | boolean | undefined;
+    label?: string | undefined;
+    prefix?: string | undefined;
+    class?: any;
+    delimiters?: string[] | undefined;
+    placeholder?: string | undefined;
+    theme?: string | undefined;
+    counter?: string | number | true | undefined;
+    rounded?: string | number | boolean | undefined;
+    bgColor?: string | undefined;
+    prependIcon?: IconValue | undefined;
+    appendIcon?: IconValue | undefined;
+    prependInnerIcon?: IconValue | undefined;
+    'onClick:clear'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+    'onClick:append'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+    'onClick:prepend'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+    'onClick:appendInner'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+    'onClick:prependInner'?: EventProp<[MouseEvent], (args_0: MouseEvent) => any> | undefined;
+    'onUpdate:focused'?: EventProp<[boolean], (args_0: boolean) => any> | undefined;
+    baseColor?: string | undefined;
+    validateOn?: "input" | "blur" | "submit" | undefined;
+    hint?: string | undefined;
+    hideDetails?: boolean | "auto" | undefined;
+    suffix?: string | undefined;
+    counterValue?: ((value: any) => number) | undefined;
+    modelModifiers?: Record<string, boolean> | undefined;
+    menuProps?: {
+        location?: Anchor | undefined;
+        origin?: "auto" | Anchor | "overlap" | undefined;
+        transition?: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })> | {
+            component: vue.Component;
+        } | undefined;
+        zIndex?: string | number | undefined;
+        style?: vue.StyleValue | undefined;
+        eager?: boolean | undefined;
+        disabled?: boolean | undefined;
+        modelValue?: boolean | undefined;
+        closeDelay?: NonNullable<string | number> | undefined;
+        openDelay?: NonNullable<string | number> | undefined;
+        activatorProps?: Record<string, any> | undefined;
+        openOnClick?: boolean | undefined;
+        openOnHover?: boolean | undefined;
+        openOnFocus?: boolean | undefined;
+        closeOnContentClick?: boolean | undefined;
+        locationStrategy?: NonNullable<"connected" | "static" | ((data: LocationStrategyData, props: StrategyProps, contentStyles: vue.Ref<Record<string, string>>) => {
+            updateLocation: (e: Event) => void;
+        } | undefined)> | undefined;
+        scrollStrategy?: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition"> | undefined;
+        closeOnBack?: boolean | undefined;
+        contained?: boolean | undefined;
+        noClickAnimation?: boolean | undefined;
+        persistent?: boolean | undefined;
+        scrim?: NonNullable<string | boolean> | undefined;
+        offset?: string | number | number[] | undefined;
+        key?: string | number | symbol | 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;
+        class?: any;
+        $children?: vue.VNodeChild | {
+            default?: ((args_0: {
                 isActive: vue.Ref<boolean>;
             }) => vue.VNodeChild) | undefined;
-            "v-slot:activator"?: false | ((args_0: {
+            activator?: ((args_0: {
                 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" | "style" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">>;
-    };
-    multiple: BooleanConstructor;
-    noDataText: {
-        type: StringConstructor;
-        default: string;
-    };
-    openOnClear: BooleanConstructor;
-    valueComparator: {
-        type: PropType<typeof deepEqual>;
-        default: typeof deepEqual;
-    };
-    customFilter: PropType<FilterFunction>;
-    customKeyFilter: PropType<FilterKeyFunctions>;
-    filterKeys: {
-        type: PropType<NonNullable<FilterKeys>>;
-        default: NonNullable<FilterKeys>;
-    };
-    filterMode: {
-        type: PropType<FilterMode>;
-        default: string;
-    };
-    noFilter: BooleanConstructor;
-    delimiters: PropType<string[]>;
-}, "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">>> & {
+        } | ((args_0: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild);
+        ref?: vue.VNodeRef | undefined;
+        ref_for?: boolean | undefined;
+        ref_key?: string | undefined;
+        theme?: string | undefined;
+        "v-slot:default"?: false | ((args_0: {
+            isActive: vue.Ref<boolean>;
+        }) => vue.VNodeChild) | undefined;
+        'v-slots'?: {
+            default?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
+            activator?: false | ((args_0: {
+                isActive: boolean;
+                props: Record<string, any>;
+            }) => vue.VNodeChild) | undefined;
+        } | undefined;
+        contentClass?: any;
+        onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        activator?: string | Element | vue.ComponentPublicInstance | undefined;
+        "v-slot:activator"?: false | ((args_0: {
+            isActive: boolean;
+            props: Record<string, any>;
+        }) => vue.VNodeChild) | undefined;
+        contentProps?: any;
+        attach?: string | boolean | Element | undefined;
+    } | undefined;
+    customFilter?: FilterFunction | undefined;
+    customKeyFilter?: FilterKeyFunctions | undefined;
+} & {
+    "onUpdate:modelValue"?: ((val: any) => any) | undefined;
     "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
     "onUpdate:menu"?: ((val: boolean) => any) | undefined;
     "onUpdate:search"?: ((val: string) => any) | undefined;
-}, {
-    isFocused: vue.Ref<boolean>;
-    isPristine: vue.Ref<boolean>;
-    menu: vue.WritableComputedRef<boolean>;
-    search: vue.WritableComputedRef<string>;
-    selectionIndex: vue.Ref<number>;
-    filteredItems: vue.Ref<InternalItem<any>[]>;
-    select: (item: InternalItem) => void;
-} & Omit<any, string | number | symbol>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+}, any, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
     'update:focused': (focused: boolean) => true;
     'update:modelValue': (val: any) => true;
     'update:search': (val: string) => true;
     '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, {
+}, "multiple" | "$children" | "items" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "update:modelValue" | "v-slot:loader" | "v-slot:clear" | "v-slot:label" | "v-slot:prepend-inner" | "v-slot:append-inner" | "v-slot:message" | "v-slot:details" | "v-slot:item" | "returnObject" | "v-slot:chip" | "v-slot:selection" | "v-slot:prepend-item" | "v-slot:append-item" | "v-slot:no-data">, string, {
     flat: boolean;
     reverse: boolean;
     type: string;
@@ -2219,13 +1259,13 @@ declare const VCombobox: {
     variant: "filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled";
     clearIcon: IconValue;
     focused: boolean;
+    clearable: boolean;
+    persistentClear: boolean;
+    singleLine: boolean;
     errorMessages: string | string[];
     maxErrors: string | number;
     rules: ValidationRule[];
     persistentHint: boolean;
-    clearable: boolean;
-    persistentClear: boolean;
-    singleLine: boolean;
     persistentPlaceholder: boolean;
     persistentCounter: boolean;
     valueComparator: typeof deepEqual;
@@ -2242,31 +1282,109 @@ declare const VCombobox: {
     filterMode: FilterMode;
     noFilter: boolean;
     filterKeys: NonNullable<FilterKeys>;
-}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T_1, ReturnObject extends boolean = true, Multiple extends boolean = false, V extends Value<T_1, ReturnObject, Multiple> = Value<T_1, ReturnObject, Multiple>>(props: {
-    items?: readonly T_1[] | undefined;
+}, {}, string, vue.SlotsType<Partial<{
+    message: (args_0: VMessageSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    clear: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    details: (args_0: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    label: (args_0: DefaultInputSlot & {
+        label: string | undefined;
+        props: Record<string, any>;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    append: (args_0: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    prepend: (args_0: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    loader: (args_0: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    'prepend-inner': (args_0: DefaultInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    'append-inner': (args_0: DefaultInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    item: (args_0: {
+        item: InternalItem<unknown>;
+        index: number;
+        props: Record<string, unknown>;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    chip: (args_0: {
+        item: InternalItem<unknown>;
+        index: number;
+        props: Record<string, unknown>;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    selection: (args_0: {
+        item: InternalItem<unknown>;
+        index: number;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    'prepend-item': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    'append-item': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T_1 extends readonly any[], Item = T_1 extends readonly (infer U)[] ? U : never, ReturnObject extends boolean = true, Multiple extends boolean = false, V extends Value<Item, ReturnObject, Multiple> = Value<Item, ReturnObject, Multiple>>(props: {
+    items?: T_1 | undefined;
     returnObject?: ReturnObject | undefined;
     multiple?: Multiple | undefined;
-    modelValue?: V | undefined;
+    modelValue?: V | null | undefined;
     'onUpdate:modelValue'?: ((val: V) => void) | undefined;
+}, slots: Omit<VInputSlots & VFieldSlots, "default"> & {
+    item: [{
+        item: InternalItem<Item>;
+        index: number;
+        props: Record<string, unknown>;
+    }];
+    chip: [{
+        item: InternalItem<Item>;
+        index: number;
+        props: Record<string, unknown>;
+    }];
+    selection: [{
+        item: InternalItem<Item>;
+        index: number;
+    }];
+    'prepend-item': [];
+    'append-item': [];
+    'no-data': [];
 }) => GenericProps<{
-    items?: readonly T_1[] | undefined;
+    items?: T_1 | undefined;
     returnObject?: ReturnObject | undefined;
     multiple?: Multiple | undefined;
-    modelValue?: V | undefined;
+    modelValue?: V | null | undefined;
     'onUpdate:modelValue'?: ((val: V) => void) | undefined;
 }, Omit<VInputSlots & VFieldSlots, "default"> & {
     item: [{
-        item: InternalItem<T_1>;
+        item: InternalItem<Item>;
         index: number;
         props: Record<string, unknown>;
     }];
     chip: [{
-        item: InternalItem<T_1>;
+        item: InternalItem<Item>;
         index: number;
         props: Record<string, unknown>;
     }];
     selection: [{
-        item: InternalItem<T_1>;
+        item: InternalItem<Item>;
         index: number;
     }];
     'prepend-item': [];
@@ -2354,6 +1472,10 @@ declare const VCombobox: {
     'onClick:prependInner': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
     focused: BooleanConstructor;
     'onUpdate:focused': PropType<EventProp<[boolean], (args_0: boolean) => any>>;
+    clearable: BooleanConstructor;
+    baseColor: StringConstructor;
+    persistentClear: BooleanConstructor;
+    singleLine: BooleanConstructor;
     validateOn: PropType<"input" | "blur" | "submit" | undefined>;
     errorMessages: {
         type: PropType<string | string[]>;
@@ -2370,10 +1492,6 @@ declare const VCombobox: {
     hint: StringConstructor;
     persistentHint: BooleanConstructor;
     hideDetails: PropType<boolean | "auto">;
-    clearable: BooleanConstructor;
-    baseColor: StringConstructor;
-    persistentClear: BooleanConstructor;
-    singleLine: BooleanConstructor;
     persistentPlaceholder: BooleanConstructor;
     persistentCounter: BooleanConstructor;
     suffix: StringConstructor;
@@ -2420,244 +1538,37 @@ declare const VCombobox: {
         default: string;
     };
     menuProps: {
-        type: PropType<Partial<{
-            location: Anchor;
-            origin: "auto" | Anchor | "overlap";
-            transition: NonNullable<string | boolean | (vue.TransitionProps & {
-                component?: vue.Component | undefined;
-            })> | {
-                component: {
-                    new (...args: any[]): {
-                        $: vue.ComponentInternalInstance;
-                        $data: {};
-                        $props: Partial<{}> & Omit<{} & {
-                            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;
-                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                        $attrs: {
-                            [x: string]: unknown;
-                        };
-                        $refs: {
-                            [x: string]: unknown;
-                        };
-                        $slots: Readonly<{
-                            [name: string]: vue.Slot | undefined;
-                        }>;
-                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $emit: (event: string, ...args: any[]) => void;
-                        $el: any;
-                        $options: vue.ComponentOptionsBase<{} & {
-                            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, {}, {}, string> & {
-                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                            created?: ((() => void) | (() => void)[]) | undefined;
-                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                            mounted?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                            updated?: ((() => void) | (() => void)[]) | undefined;
-                            activated?: ((() => void) | (() => void)[]) | undefined;
-                            deactivated?: ((() => void) | (() => void)[]) | undefined;
-                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                            destroyed?: ((() => void) | (() => void)[]) | undefined;
-                            unmounted?: ((() => void) | (() => void)[]) | undefined;
-                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                        };
-                        $forceUpdate: () => void;
-                        $nextTick: typeof nextTick;
-                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                    } & {} & {
-                        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;
-                    } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } & vue.ComponentOptionsBase<{} & {
-                    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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                    target: PropType<HTMLElement>;
-                }, vue.ExtractPropTypes<{
-                    target: PropType<HTMLElement>;
-                }>>;
-            };
-            zIndex: string | number;
-            style: vue.StyleValue;
-            eager: boolean;
-            disabled: boolean;
-            modelValue: boolean;
-            closeDelay: NonNullable<string | number>;
-            openDelay: NonNullable<string | number>;
-            activatorProps: Record<string, any>;
-            openOnClick: boolean;
-            openOnHover: boolean;
-            openOnFocus: 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>;
-        }> & Omit<{
-            location: Anchor;
-            origin: "auto" | Anchor | "overlap";
-            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+        type: PropType<{
+            location?: Anchor | undefined;
+            origin?: "auto" | Anchor | "overlap" | undefined;
+            transition?: NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component | undefined;
             })> | {
-                component: {
-                    new (...args: any[]): {
-                        $: vue.ComponentInternalInstance;
-                        $data: {};
-                        $props: Partial<{}> & Omit<{} & {
-                            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;
-                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                        $attrs: {
-                            [x: string]: unknown;
-                        };
-                        $refs: {
-                            [x: string]: unknown;
-                        };
-                        $slots: Readonly<{
-                            [name: string]: vue.Slot | undefined;
-                        }>;
-                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $emit: (event: string, ...args: any[]) => void;
-                        $el: any;
-                        $options: vue.ComponentOptionsBase<{} & {
-                            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, {}, {}, string> & {
-                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                            created?: ((() => void) | (() => void)[]) | undefined;
-                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                            mounted?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                            updated?: ((() => void) | (() => void)[]) | undefined;
-                            activated?: ((() => void) | (() => void)[]) | undefined;
-                            deactivated?: ((() => void) | (() => void)[]) | undefined;
-                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                            destroyed?: ((() => void) | (() => void)[]) | undefined;
-                            unmounted?: ((() => void) | (() => void)[]) | undefined;
-                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                        };
-                        $forceUpdate: () => void;
-                        $nextTick: typeof nextTick;
-                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                    } & {} & {
-                        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;
-                    } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } & vue.ComponentOptionsBase<{} & {
-                    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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                    target: PropType<HTMLElement>;
-                }, vue.ExtractPropTypes<{
-                    target: PropType<HTMLElement>;
-                }>>;
-            };
-            zIndex: string | number;
-            style: vue.StyleValue;
-            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>>) => {
+                component: vue.Component;
+            } | undefined;
+            zIndex?: string | number | undefined;
+            style?: vue.StyleValue | undefined;
+            eager?: boolean | undefined;
+            disabled?: boolean | undefined;
+            modelValue?: boolean | undefined;
+            closeDelay?: NonNullable<string | number> | undefined;
+            openDelay?: NonNullable<string | number> | undefined;
+            activatorProps?: Record<string, any> | undefined;
+            openOnClick?: boolean | undefined;
+            openOnHover?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            closeOnContentClick?: boolean | undefined;
+            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>;
-        } & {
+            } | undefined)> | undefined;
+            scrollStrategy?: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition"> | undefined;
+            closeOnBack?: boolean | undefined;
+            contained?: boolean | undefined;
+            noClickAnimation?: boolean | undefined;
+            persistent?: boolean | undefined;
+            scrim?: NonNullable<string | boolean> | undefined;
             offset?: string | number | number[] | undefined;
+            key?: string | number | symbol | undefined;
             id?: string | undefined;
             height?: string | number | undefined;
             width?: string | number | undefined;
@@ -2666,14 +1577,6 @@ declare const VCombobox: {
             minHeight?: string | number | undefined;
             minWidth?: string | number | undefined;
             class?: any;
-            theme?: string | undefined;
-            contentClass?: any;
-            activator?: string | Element | vue.ComponentPublicInstance | undefined;
-            openOnClick?: boolean | undefined;
-            openOnFocus?: boolean | undefined;
-            contentProps?: any;
-            attach?: string | boolean | Element | undefined;
-        } & {
             $children?: vue.VNodeChild | {
                 default?: ((args_0: {
                     isActive: vue.Ref<boolean>;
@@ -2685,6 +1588,13 @@ declare const VCombobox: {
             } | ((args_0: {
                 isActive: vue.Ref<boolean>;
             }) => vue.VNodeChild);
+            ref?: vue.VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            theme?: string | undefined;
+            "v-slot:default"?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
             'v-slots'?: {
                 default?: false | ((args_0: {
                     isActive: vue.Ref<boolean>;
@@ -2694,17 +1604,54 @@ declare const VCombobox: {
                     props: Record<string, any>;
                 }) => vue.VNodeChild) | undefined;
             } | undefined;
-        } & {
-            "v-slot:default"?: false | ((args_0: {
-                isActive: vue.Ref<boolean>;
-            }) => vue.VNodeChild) | undefined;
+            contentClass?: any;
+            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            activator?: string | Element | vue.ComponentPublicInstance | undefined;
             "v-slot:activator"?: false | ((args_0: {
                 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" | "style" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">>;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        }>;
     };
     multiple: BooleanConstructor;
     noDataText: {
@@ -2810,6 +1757,10 @@ declare const VCombobox: {
     'onClick:prependInner': PropType<EventProp<[MouseEvent], (args_0: MouseEvent) => any>>;
     focused: BooleanConstructor;
     'onUpdate:focused': PropType<EventProp<[boolean], (args_0: boolean) => any>>;
+    clearable: BooleanConstructor;
+    baseColor: StringConstructor;
+    persistentClear: BooleanConstructor;
+    singleLine: BooleanConstructor;
     validateOn: PropType<"input" | "blur" | "submit" | undefined>;
     errorMessages: {
         type: PropType<string | string[]>;
@@ -2826,10 +1777,6 @@ declare const VCombobox: {
     hint: StringConstructor;
     persistentHint: BooleanConstructor;
     hideDetails: PropType<boolean | "auto">;
-    clearable: BooleanConstructor;
-    baseColor: StringConstructor;
-    persistentClear: BooleanConstructor;
-    singleLine: BooleanConstructor;
     persistentPlaceholder: BooleanConstructor;
     persistentCounter: BooleanConstructor;
     suffix: StringConstructor;
@@ -2876,244 +1823,37 @@ declare const VCombobox: {
         default: string;
     };
     menuProps: {
-        type: PropType<Partial<{
-            location: Anchor;
-            origin: "auto" | Anchor | "overlap";
-            transition: NonNullable<string | boolean | (vue.TransitionProps & {
-                component?: vue.Component | undefined;
-            })> | {
-                component: {
-                    new (...args: any[]): {
-                        $: vue.ComponentInternalInstance;
-                        $data: {};
-                        $props: Partial<{}> & Omit<{} & {
-                            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;
-                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                        $attrs: {
-                            [x: string]: unknown;
-                        };
-                        $refs: {
-                            [x: string]: unknown;
-                        };
-                        $slots: Readonly<{
-                            [name: string]: vue.Slot | undefined;
-                        }>;
-                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $emit: (event: string, ...args: any[]) => void;
-                        $el: any;
-                        $options: vue.ComponentOptionsBase<{} & {
-                            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, {}, {}, string> & {
-                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                            created?: ((() => void) | (() => void)[]) | undefined;
-                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                            mounted?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                            updated?: ((() => void) | (() => void)[]) | undefined;
-                            activated?: ((() => void) | (() => void)[]) | undefined;
-                            deactivated?: ((() => void) | (() => void)[]) | undefined;
-                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                            destroyed?: ((() => void) | (() => void)[]) | undefined;
-                            unmounted?: ((() => void) | (() => void)[]) | undefined;
-                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                        };
-                        $forceUpdate: () => void;
-                        $nextTick: typeof nextTick;
-                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                    } & {} & {
-                        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;
-                    } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } & vue.ComponentOptionsBase<{} & {
-                    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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                    target: PropType<HTMLElement>;
-                }, vue.ExtractPropTypes<{
-                    target: PropType<HTMLElement>;
-                }>>;
-            };
-            zIndex: string | number;
-            style: vue.StyleValue;
-            eager: boolean;
-            disabled: boolean;
-            modelValue: boolean;
-            closeDelay: NonNullable<string | number>;
-            openDelay: NonNullable<string | number>;
-            activatorProps: Record<string, any>;
-            openOnClick: boolean;
-            openOnHover: boolean;
-            openOnFocus: 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>;
-        }> & Omit<{
-            location: Anchor;
-            origin: "auto" | Anchor | "overlap";
-            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+        type: PropType<{
+            location?: Anchor | undefined;
+            origin?: "auto" | Anchor | "overlap" | undefined;
+            transition?: NonNullable<string | boolean | (vue.TransitionProps & {
                 component?: vue.Component | undefined;
             })> | {
-                component: {
-                    new (...args: any[]): {
-                        $: vue.ComponentInternalInstance;
-                        $data: {};
-                        $props: Partial<{}> & Omit<{} & {
-                            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;
-                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
-                        $attrs: {
-                            [x: string]: unknown;
-                        };
-                        $refs: {
-                            [x: string]: unknown;
-                        };
-                        $slots: Readonly<{
-                            [name: string]: vue.Slot | undefined;
-                        }>;
-                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-                        $emit: (event: string, ...args: any[]) => void;
-                        $el: any;
-                        $options: vue.ComponentOptionsBase<{} & {
-                            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, {}, {}, string> & {
-                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                            created?: ((() => void) | (() => void)[]) | undefined;
-                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                            mounted?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                            updated?: ((() => void) | (() => void)[]) | undefined;
-                            activated?: ((() => void) | (() => void)[]) | undefined;
-                            deactivated?: ((() => void) | (() => void)[]) | undefined;
-                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                            destroyed?: ((() => void) | (() => void)[]) | undefined;
-                            unmounted?: ((() => void) | (() => void)[]) | undefined;
-                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
-                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-                        };
-                        $forceUpdate: () => void;
-                        $nextTick: typeof nextTick;
-                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
-                    } & {} & {
-                        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;
-                    } & vue.ShallowUnwrapRef<() => JSX.Element> & {} & vue.ComponentCustomProperties & {};
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } & vue.ComponentOptionsBase<{} & {
-                    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, {}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
-                    target: PropType<HTMLElement>;
-                }, vue.ExtractPropTypes<{
-                    target: PropType<HTMLElement>;
-                }>>;
-            };
-            zIndex: string | number;
-            style: vue.StyleValue;
-            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>>) => {
+                component: vue.Component;
+            } | undefined;
+            zIndex?: string | number | undefined;
+            style?: vue.StyleValue | undefined;
+            eager?: boolean | undefined;
+            disabled?: boolean | undefined;
+            modelValue?: boolean | undefined;
+            closeDelay?: NonNullable<string | number> | undefined;
+            openDelay?: NonNullable<string | number> | undefined;
+            activatorProps?: Record<string, any> | undefined;
+            openOnClick?: boolean | undefined;
+            openOnHover?: boolean | undefined;
+            openOnFocus?: boolean | undefined;
+            closeOnContentClick?: boolean | undefined;
+            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>;
-        } & {
+            } | undefined)> | undefined;
+            scrollStrategy?: NonNullable<"none" | "block" | "close" | ((data: ScrollStrategyData, props: StrategyProps$1, scope: vue.EffectScope) => void) | "reposition"> | undefined;
+            closeOnBack?: boolean | undefined;
+            contained?: boolean | undefined;
+            noClickAnimation?: boolean | undefined;
+            persistent?: boolean | undefined;
+            scrim?: NonNullable<string | boolean> | undefined;
             offset?: string | number | number[] | undefined;
+            key?: string | number | symbol | undefined;
             id?: string | undefined;
             height?: string | number | undefined;
             width?: string | number | undefined;
@@ -3122,14 +1862,6 @@ declare const VCombobox: {
             minHeight?: string | number | undefined;
             minWidth?: string | number | undefined;
             class?: any;
-            theme?: string | undefined;
-            contentClass?: any;
-            activator?: string | Element | vue.ComponentPublicInstance | undefined;
-            openOnClick?: boolean | undefined;
-            openOnFocus?: boolean | undefined;
-            contentProps?: any;
-            attach?: string | boolean | Element | undefined;
-        } & {
             $children?: vue.VNodeChild | {
                 default?: ((args_0: {
                     isActive: vue.Ref<boolean>;
@@ -3141,6 +1873,13 @@ declare const VCombobox: {
             } | ((args_0: {
                 isActive: vue.Ref<boolean>;
             }) => vue.VNodeChild);
+            ref?: vue.VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            theme?: string | undefined;
+            "v-slot:default"?: false | ((args_0: {
+                isActive: vue.Ref<boolean>;
+            }) => vue.VNodeChild) | undefined;
             'v-slots'?: {
                 default?: false | ((args_0: {
                     isActive: vue.Ref<boolean>;
@@ -3150,17 +1889,54 @@ declare const VCombobox: {
                     props: Record<string, any>;
                 }) => vue.VNodeChild) | undefined;
             } | undefined;
-        } & {
-            "v-slot:default"?: false | ((args_0: {
-                isActive: vue.Ref<boolean>;
-            }) => vue.VNodeChild) | undefined;
+            contentClass?: any;
+            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            activator?: string | Element | vue.ComponentPublicInstance | undefined;
             "v-slot:activator"?: false | ((args_0: {
                 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" | "style" | "eager" | "disabled" | "modelValue" | "closeDelay" | "openDelay" | "activatorProps" | "openOnClick" | "openOnHover" | "openOnFocus" | "closeOnContentClick" | "locationStrategy" | "scrollStrategy" | "closeOnBack" | "contained" | "noClickAnimation" | "persistent" | "scrim">>;
+            contentProps?: any;
+            attach?: string | boolean | Element | undefined;
+        }>;
     };
     multiple: BooleanConstructor;
     noDataText: {