@vuetify/nightly 3.7.10-next.2025-02-04 → 3.7.10-next.2025-02-05

package/dist/vuetify-labs.d.ts

@@ -8014,17 +8014,20 @@ declare const VAutocomplete: {
         'prepend-inner': (arg: DefaultInputSlot) => vue.VNode[];
         'append-inner': (arg: DefaultInputSlot) => vue.VNode[];
         item: (arg: {
-            item: ListItem<unknown>;
+            item: unknown;
+            internalItem: ListItem<unknown>;
             index: number;
             props: Record<string, unknown>;
         }) => vue.VNode[];
         chip: (arg: {
-            item: ListItem<unknown>;
+            item: unknown;
+            internalItem: ListItem<unknown>;
             index: number;
             props: Record<string, unknown>;
         }) => vue.VNode[];
         selection: (arg: {
-            item: ListItem<unknown>;
+            item: unknown;
+            internalItem: ListItem<unknown>;
             index: number;
         }) => vue.VNode[];
         'prepend-item': () => vue.VNode[];
@@ -8888,17 +8891,20 @@ declare const VAutocomplete: {
     'prepend-inner': (arg: DefaultInputSlot) => vue.VNode[];
     'append-inner': (arg: DefaultInputSlot) => vue.VNode[];
     item: (arg: {
-        item: ListItem<unknown>;
+        item: unknown;
+        internalItem: ListItem<unknown>;
         index: number;
         props: Record<string, unknown>;
     }) => vue.VNode[];
     chip: (arg: {
-        item: ListItem<unknown>;
+        item: unknown;
+        internalItem: ListItem<unknown>;
         index: number;
         props: Record<string, unknown>;
     }) => vue.VNode[];
     selection: (arg: {
-        item: ListItem<unknown>;
+        item: unknown;
+        internalItem: ListItem<unknown>;
         index: number;
     }) => vue.VNode[];
     'prepend-item': () => vue.VNode[];
@@ -8915,17 +8921,20 @@ declare const VAutocomplete: {
     "onUpdate:modelValue"?: (value: V) => void;
 }, slots: Omit<VInputSlots & VFieldSlots, "default"> & {
     item: {
-        item: ListItem<Item>;
+        item: Item;
+        internalItem: ListItem<Item>;
         index: number;
         props: Record<string, unknown>;
     };
     chip: {
-        item: ListItem<Item>;
+        item: Item;
+        internalItem: ListItem<Item>;
         index: number;
         props: Record<string, unknown>;
     };
     selection: {
-        item: ListItem<Item>;
+        item: Item;
+        internalItem: ListItem<Item>;
         index: number;
     };
     "prepend-item": never;
@@ -18074,17 +18083,20 @@ declare const VCombobox: {
         'prepend-inner': (arg: DefaultInputSlot) => vue.VNode[];
         'append-inner': (arg: DefaultInputSlot) => vue.VNode[];
         item: (arg: {
-            item: ListItem<unknown>;
+            item: unknown;
+            internalItem: ListItem<unknown>;
             index: number;
             props: Record<string, unknown>;
         }) => vue.VNode[];
         chip: (arg: {
-            item: ListItem<unknown>;
+            item: unknown;
+            internalItem: ListItem<unknown>;
             index: number;
             props: Record<string, unknown>;
         }) => vue.VNode[];
         selection: (arg: {
-            item: ListItem<unknown>;
+            item: unknown;
+            internalItem: ListItem<unknown>;
             index: number;
         }) => vue.VNode[];
         'prepend-item': () => vue.VNode[];
@@ -18948,17 +18960,20 @@ declare const VCombobox: {
     'prepend-inner': (arg: DefaultInputSlot) => vue.VNode[];
     'append-inner': (arg: DefaultInputSlot) => vue.VNode[];
     item: (arg: {
-        item: ListItem<unknown>;
+        item: unknown;
+        internalItem: ListItem<unknown>;
         index: number;
         props: Record<string, unknown>;
     }) => vue.VNode[];
     chip: (arg: {
-        item: ListItem<unknown>;
+        item: unknown;
+        internalItem: ListItem<unknown>;
         index: number;
         props: Record<string, unknown>;
     }) => vue.VNode[];
     selection: (arg: {
-        item: ListItem<unknown>;
+        item: unknown;
+        internalItem: ListItem<unknown>;
         index: number;
     }) => vue.VNode[];
     'prepend-item': () => vue.VNode[];
@@ -18975,17 +18990,20 @@ declare const VCombobox: {
     "onUpdate:modelValue"?: (value: V) => void;
 }, slots: Omit<VInputSlots & VFieldSlots, "default"> & {
     item: {
-        item: ListItem<Item>;
+        item: Item;
+        internalItem: ListItem<Item>;
         index: number;
         props: Record<string, unknown>;
     };
     chip: {
-        item: ListItem<Item>;
+        item: Item;
+        internalItem: ListItem<Item>;
         index: number;
         props: Record<string, unknown>;
     };
     selection: {
-        item: ListItem<Item>;
+        item: Item;
+        internalItem: ListItem<Item>;
         index: number;
     };
     "prepend-item": never;
@@ -31076,169 +31094,49 @@ declare const VForm: {
     } & {
         $children?: vue.VNodeChild | {
             default?: ((arg: {
-                errors: vue.Ref<{
-                    id: number | string;
-                    errorMessages: string[];
-                }[], FieldValidationResult[] | {
-                    id: number | string;
-                    errorMessages: string[];
-                }[]>;
-                isDisabled: vue.ComputedRef<boolean>;
-                isReadonly: vue.ComputedRef<boolean>;
-                isValidating: vue.ShallowRef<boolean, boolean>;
-                isValid: vue.Ref<boolean | null, boolean | null> & {
-                    readonly externalValue: boolean | null;
-                };
-                items: vue.Ref<{
-                    id: number | string;
-                    validate: () => Promise<string[]>;
-                    reset: () => Promise<void>;
-                    resetValidation: () => Promise<void>;
-                    vm: vue.Raw<vue.ComponentInternalInstance>;
-                    isValid: boolean | null;
-                    errorMessages: string[];
-                }[], FormField[] | {
-                    id: number | string;
-                    validate: () => Promise<string[]>;
-                    reset: () => Promise<void>;
-                    resetValidation: () => Promise<void>;
-                    vm: vue.Raw<vue.ComponentInternalInstance>;
-                    isValid: boolean | null;
-                    errorMessages: string[];
-                }[]>;
-                validate: () => Promise<{
-                    valid: boolean;
-                    errors: {
-                        id: number | string;
-                        errorMessages: string[];
-                    }[];
-                }>;
+                errors: FieldValidationResult[];
+                isDisabled: boolean;
+                isReadonly: boolean;
+                isValidating: boolean;
+                isValid: boolean | null;
+                items: FormField[];
+                validate: () => Promise<FormValidationResult>;
                 reset: () => void;
                 resetValidation: () => void;
             }) => vue.VNodeChild) | undefined;
         } | ((arg: {
-            errors: vue.Ref<{
-                id: number | string;
-                errorMessages: string[];
-            }[], FieldValidationResult[] | {
-                id: number | string;
-                errorMessages: string[];
-            }[]>;
-            isDisabled: vue.ComputedRef<boolean>;
-            isReadonly: vue.ComputedRef<boolean>;
-            isValidating: vue.ShallowRef<boolean, boolean>;
-            isValid: vue.Ref<boolean | null, boolean | null> & {
-                readonly externalValue: boolean | null;
-            };
-            items: vue.Ref<{
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[], FormField[] | {
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[]>;
-            validate: () => Promise<{
-                valid: boolean;
-                errors: {
-                    id: number | string;
-                    errorMessages: string[];
-                }[];
-            }>;
+            errors: FieldValidationResult[];
+            isDisabled: boolean;
+            isReadonly: boolean;
+            isValidating: boolean;
+            isValid: boolean | null;
+            items: FormField[];
+            validate: () => Promise<FormValidationResult>;
             reset: () => void;
             resetValidation: () => void;
         }) => vue.VNodeChild);
         'v-slots'?: {
             default?: false | ((arg: {
-                errors: vue.Ref<{
-                    id: number | string;
-                    errorMessages: string[];
-                }[], FieldValidationResult[] | {
-                    id: number | string;
-                    errorMessages: string[];
-                }[]>;
-                isDisabled: vue.ComputedRef<boolean>;
-                isReadonly: vue.ComputedRef<boolean>;
-                isValidating: vue.ShallowRef<boolean, boolean>;
-                isValid: vue.Ref<boolean | null, boolean | null> & {
-                    readonly externalValue: boolean | null;
-                };
-                items: vue.Ref<{
-                    id: number | string;
-                    validate: () => Promise<string[]>;
-                    reset: () => Promise<void>;
-                    resetValidation: () => Promise<void>;
-                    vm: vue.Raw<vue.ComponentInternalInstance>;
-                    isValid: boolean | null;
-                    errorMessages: string[];
-                }[], FormField[] | {
-                    id: number | string;
-                    validate: () => Promise<string[]>;
-                    reset: () => Promise<void>;
-                    resetValidation: () => Promise<void>;
-                    vm: vue.Raw<vue.ComponentInternalInstance>;
-                    isValid: boolean | null;
-                    errorMessages: string[];
-                }[]>;
-                validate: () => Promise<{
-                    valid: boolean;
-                    errors: {
-                        id: number | string;
-                        errorMessages: string[];
-                    }[];
-                }>;
+                errors: FieldValidationResult[];
+                isDisabled: boolean;
+                isReadonly: boolean;
+                isValidating: boolean;
+                isValid: boolean | null;
+                items: FormField[];
+                validate: () => Promise<FormValidationResult>;
                 reset: () => void;
                 resetValidation: () => void;
             }) => vue.VNodeChild) | undefined;
         } | undefined;
     } & {
         "v-slot:default"?: false | ((arg: {
-            errors: vue.Ref<{
-                id: number | string;
-                errorMessages: string[];
-            }[], FieldValidationResult[] | {
-                id: number | string;
-                errorMessages: string[];
-            }[]>;
-            isDisabled: vue.ComputedRef<boolean>;
-            isReadonly: vue.ComputedRef<boolean>;
-            isValidating: vue.ShallowRef<boolean, boolean>;
-            isValid: vue.Ref<boolean | null, boolean | null> & {
-                readonly externalValue: boolean | null;
-            };
-            items: vue.Ref<{
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[], FormField[] | {
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[]>;
-            validate: () => Promise<{
-                valid: boolean;
-                errors: {
-                    id: number | string;
-                    errorMessages: string[];
-                }[];
-            }>;
+            errors: FieldValidationResult[];
+            isDisabled: boolean;
+            isReadonly: boolean;
+            isValidating: boolean;
+            isValid: boolean | null;
+            items: FormField[];
+            validate: () => Promise<FormValidationResult>;
             reset: () => void;
             resetValidation: () => void;
         }) => vue.VNodeChild) | undefined;
@@ -31339,43 +31237,13 @@ declare const VForm: {
         fastFail: boolean;
     }, true, {}, vue.SlotsType<Partial<{
         default: (arg: {
-            errors: vue.Ref<{
-                id: number | string;
-                errorMessages: string[];
-            }[], FieldValidationResult[] | {
-                id: number | string;
-                errorMessages: string[];
-            }[]>;
-            isDisabled: vue.ComputedRef<boolean>;
-            isReadonly: vue.ComputedRef<boolean>;
-            isValidating: vue.ShallowRef<boolean, boolean>;
-            isValid: vue.Ref<boolean | null, boolean | null> & {
-                readonly externalValue: boolean | null;
-            };
-            items: vue.Ref<{
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[], FormField[] | {
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[]>;
-            validate: () => Promise<{
-                valid: boolean;
-                errors: {
-                    id: number | string;
-                    errorMessages: string[];
-                }[];
-            }>;
+            errors: FieldValidationResult[];
+            isDisabled: boolean;
+            isReadonly: boolean;
+            isValidating: boolean;
+            isValid: boolean | null;
+            items: FormField[];
+            validate: () => Promise<FormValidationResult>;
             reset: () => void;
             resetValidation: () => void;
         }) => vue.VNode[];
@@ -31398,217 +31266,97 @@ declare const VForm: {
     } & {
         $children?: vue.VNodeChild | {
             default?: ((arg: {
-                errors: vue.Ref<{
-                    id: number | string;
-                    errorMessages: string[];
-                }[], FieldValidationResult[] | {
-                    id: number | string;
-                    errorMessages: string[];
-                }[]>;
-                isDisabled: vue.ComputedRef<boolean>;
-                isReadonly: vue.ComputedRef<boolean>;
-                isValidating: vue.ShallowRef<boolean, boolean>;
-                isValid: vue.Ref<boolean | null, boolean | null> & {
-                    readonly externalValue: boolean | null;
-                };
-                items: vue.Ref<{
-                    id: number | string;
-                    validate: () => Promise<string[]>;
-                    reset: () => Promise<void>;
-                    resetValidation: () => Promise<void>;
-                    vm: vue.Raw<vue.ComponentInternalInstance>;
-                    isValid: boolean | null;
-                    errorMessages: string[];
-                }[], FormField[] | {
-                    id: number | string;
-                    validate: () => Promise<string[]>;
-                    reset: () => Promise<void>;
-                    resetValidation: () => Promise<void>;
-                    vm: vue.Raw<vue.ComponentInternalInstance>;
-                    isValid: boolean | null;
-                    errorMessages: string[];
-                }[]>;
-                validate: () => Promise<{
-                    valid: boolean;
-                    errors: {
-                        id: number | string;
-                        errorMessages: string[];
-                    }[];
-                }>;
+                errors: FieldValidationResult[];
+                isDisabled: boolean;
+                isReadonly: boolean;
+                isValidating: boolean;
+                isValid: boolean | null;
+                items: FormField[];
+                validate: () => Promise<FormValidationResult>;
                 reset: () => void;
                 resetValidation: () => void;
             }) => vue.VNodeChild) | undefined;
         } | ((arg: {
-            errors: vue.Ref<{
-                id: number | string;
-                errorMessages: string[];
-            }[], FieldValidationResult[] | {
-                id: number | string;
-                errorMessages: string[];
-            }[]>;
-            isDisabled: vue.ComputedRef<boolean>;
-            isReadonly: vue.ComputedRef<boolean>;
-            isValidating: vue.ShallowRef<boolean, boolean>;
-            isValid: vue.Ref<boolean | null, boolean | null> & {
-                readonly externalValue: boolean | null;
-            };
-            items: vue.Ref<{
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[], FormField[] | {
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[]>;
-            validate: () => Promise<{
-                valid: boolean;
-                errors: {
-                    id: number | string;
-                    errorMessages: string[];
-                }[];
-            }>;
+            errors: FieldValidationResult[];
+            isDisabled: boolean;
+            isReadonly: boolean;
+            isValidating: boolean;
+            isValid: boolean | null;
+            items: FormField[];
+            validate: () => Promise<FormValidationResult>;
             reset: () => void;
             resetValidation: () => void;
         }) => vue.VNodeChild);
         'v-slots'?: {
             default?: false | ((arg: {
-                errors: vue.Ref<{
-                    id: number | string;
-                    errorMessages: string[];
-                }[], FieldValidationResult[] | {
-                    id: number | string;
-                    errorMessages: string[];
-                }[]>;
-                isDisabled: vue.ComputedRef<boolean>;
-                isReadonly: vue.ComputedRef<boolean>;
-                isValidating: vue.ShallowRef<boolean, boolean>;
-                isValid: vue.Ref<boolean | null, boolean | null> & {
-                    readonly externalValue: boolean | null;
-                };
-                items: vue.Ref<{
-                    id: number | string;
-                    validate: () => Promise<string[]>;
-                    reset: () => Promise<void>;
-                    resetValidation: () => Promise<void>;
-                    vm: vue.Raw<vue.ComponentInternalInstance>;
-                    isValid: boolean | null;
-                    errorMessages: string[];
-                }[], FormField[] | {
-                    id: number | string;
-                    validate: () => Promise<string[]>;
-                    reset: () => Promise<void>;
-                    resetValidation: () => Promise<void>;
-                    vm: vue.Raw<vue.ComponentInternalInstance>;
-                    isValid: boolean | null;
-                    errorMessages: string[];
-                }[]>;
-                validate: () => Promise<{
-                    valid: boolean;
-                    errors: {
-                        id: number | string;
-                        errorMessages: string[];
-                    }[];
-                }>;
+                errors: FieldValidationResult[];
+                isDisabled: boolean;
+                isReadonly: boolean;
+                isValidating: boolean;
+                isValid: boolean | null;
+                items: FormField[];
+                validate: () => Promise<FormValidationResult>;
                 reset: () => void;
                 resetValidation: () => void;
             }) => vue.VNodeChild) | undefined;
         } | undefined;
     } & {
         "v-slot:default"?: false | ((arg: {
-            errors: vue.Ref<{
-                id: number | string;
-                errorMessages: string[];
-            }[], FieldValidationResult[] | {
-                id: number | string;
-                errorMessages: string[];
-            }[]>;
-            isDisabled: vue.ComputedRef<boolean>;
-            isReadonly: vue.ComputedRef<boolean>;
-            isValidating: vue.ShallowRef<boolean, boolean>;
-            isValid: vue.Ref<boolean | null, boolean | null> & {
-                readonly externalValue: boolean | null;
-            };
-            items: vue.Ref<{
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[], FormField[] | {
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[]>;
-            validate: () => Promise<{
-                valid: boolean;
-                errors: {
-                    id: number | string;
-                    errorMessages: string[];
-                }[];
-            }>;
-            reset: () => void;
-            resetValidation: () => void;
-        }) => vue.VNodeChild) | undefined;
-    } & {
-        onSubmit?: ((e: SubmitEventPromise) => any) | undefined;
-        "onUpdate:modelValue"?: ((val: boolean | null) => any) | undefined;
-    }, {
-        errors: vue.Ref<{
-            id: number | string;
-            errorMessages: string[];
-        }[], FieldValidationResult[] | {
-            id: number | string;
-            errorMessages: string[];
-        }[]>;
-        isDisabled: vue.ComputedRef<boolean>;
-        isReadonly: vue.ComputedRef<boolean>;
-        isValidating: vue.ShallowRef<boolean, boolean>;
-        isValid: vue.Ref<boolean | null, boolean | null> & {
-            readonly externalValue: boolean | null;
-        };
-        items: vue.Ref<{
-            id: number | string;
-            validate: () => Promise<string[]>;
-            reset: () => Promise<void>;
-            resetValidation: () => Promise<void>;
-            vm: vue.Raw<vue.ComponentInternalInstance>;
-            isValid: boolean | null;
-            errorMessages: string[];
-        }[], FormField[] | {
-            id: number | string;
-            validate: () => Promise<string[]>;
-            reset: () => Promise<void>;
-            resetValidation: () => Promise<void>;
-            vm: vue.Raw<vue.ComponentInternalInstance>;
-            isValid: boolean | null;
-            errorMessages: string[];
-        }[]>;
-        validate: () => Promise<{
-            valid: boolean;
-            errors: {
-                id: number | string;
-                errorMessages: string[];
-            }[];
-        }>;
-        reset: () => void;
-        resetValidation: () => void;
-    } & HTMLFormElement & {
-        _allExposed: {
+            errors: FieldValidationResult[];
+            isDisabled: boolean;
+            isReadonly: boolean;
+            isValidating: boolean;
+            isValid: boolean | null;
+            items: FormField[];
+            validate: () => Promise<FormValidationResult>;
+            reset: () => void;
+            resetValidation: () => void;
+        }) => vue.VNodeChild) | undefined;
+    } & {
+        onSubmit?: ((e: SubmitEventPromise) => any) | undefined;
+        "onUpdate:modelValue"?: ((val: boolean | null) => any) | undefined;
+    }, {
+        errors: vue.Ref<{
+            id: number | string;
+            errorMessages: string[];
+        }[], FieldValidationResult[] | {
+            id: number | string;
+            errorMessages: string[];
+        }[]>;
+        isDisabled: vue.ComputedRef<boolean>;
+        isReadonly: vue.ComputedRef<boolean>;
+        isValidating: vue.ShallowRef<boolean, boolean>;
+        isValid: vue.Ref<boolean | null, boolean | null> & {
+            readonly externalValue: boolean | null;
+        };
+        items: vue.Ref<{
+            id: number | string;
+            validate: () => Promise<string[]>;
+            reset: () => Promise<void>;
+            resetValidation: () => Promise<void>;
+            vm: vue.Raw<vue.ComponentInternalInstance>;
+            isValid: boolean | null;
+            errorMessages: string[];
+        }[], FormField[] | {
+            id: number | string;
+            validate: () => Promise<string[]>;
+            reset: () => Promise<void>;
+            resetValidation: () => Promise<void>;
+            vm: vue.Raw<vue.ComponentInternalInstance>;
+            isValid: boolean | null;
+            errorMessages: string[];
+        }[]>;
+        validate: () => Promise<{
+            valid: boolean;
+            errors: {
+                id: number | string;
+                errorMessages: string[];
+            }[];
+        }>;
+        reset: () => void;
+        resetValidation: () => void;
+    } & HTMLFormElement & {
+        _allExposed: {
             errors: vue.Ref<{
                 id: number | string;
                 errorMessages: string[];
@@ -31672,169 +31420,49 @@ declare const VForm: {
 } & {
     $children?: vue.VNodeChild | {
         default?: ((arg: {
-            errors: vue.Ref<{
-                id: number | string;
-                errorMessages: string[];
-            }[], FieldValidationResult[] | {
-                id: number | string;
-                errorMessages: string[];
-            }[]>;
-            isDisabled: vue.ComputedRef<boolean>;
-            isReadonly: vue.ComputedRef<boolean>;
-            isValidating: vue.ShallowRef<boolean, boolean>;
-            isValid: vue.Ref<boolean | null, boolean | null> & {
-                readonly externalValue: boolean | null;
-            };
-            items: vue.Ref<{
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[], FormField[] | {
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[]>;
-            validate: () => Promise<{
-                valid: boolean;
-                errors: {
-                    id: number | string;
-                    errorMessages: string[];
-                }[];
-            }>;
+            errors: FieldValidationResult[];
+            isDisabled: boolean;
+            isReadonly: boolean;
+            isValidating: boolean;
+            isValid: boolean | null;
+            items: FormField[];
+            validate: () => Promise<FormValidationResult>;
             reset: () => void;
             resetValidation: () => void;
         }) => vue.VNodeChild) | undefined;
     } | ((arg: {
-        errors: vue.Ref<{
-            id: number | string;
-            errorMessages: string[];
-        }[], FieldValidationResult[] | {
-            id: number | string;
-            errorMessages: string[];
-        }[]>;
-        isDisabled: vue.ComputedRef<boolean>;
-        isReadonly: vue.ComputedRef<boolean>;
-        isValidating: vue.ShallowRef<boolean, boolean>;
-        isValid: vue.Ref<boolean | null, boolean | null> & {
-            readonly externalValue: boolean | null;
-        };
-        items: vue.Ref<{
-            id: number | string;
-            validate: () => Promise<string[]>;
-            reset: () => Promise<void>;
-            resetValidation: () => Promise<void>;
-            vm: vue.Raw<vue.ComponentInternalInstance>;
-            isValid: boolean | null;
-            errorMessages: string[];
-        }[], FormField[] | {
-            id: number | string;
-            validate: () => Promise<string[]>;
-            reset: () => Promise<void>;
-            resetValidation: () => Promise<void>;
-            vm: vue.Raw<vue.ComponentInternalInstance>;
-            isValid: boolean | null;
-            errorMessages: string[];
-        }[]>;
-        validate: () => Promise<{
-            valid: boolean;
-            errors: {
-                id: number | string;
-                errorMessages: string[];
-            }[];
-        }>;
+        errors: FieldValidationResult[];
+        isDisabled: boolean;
+        isReadonly: boolean;
+        isValidating: boolean;
+        isValid: boolean | null;
+        items: FormField[];
+        validate: () => Promise<FormValidationResult>;
         reset: () => void;
         resetValidation: () => void;
     }) => vue.VNodeChild);
     'v-slots'?: {
         default?: false | ((arg: {
-            errors: vue.Ref<{
-                id: number | string;
-                errorMessages: string[];
-            }[], FieldValidationResult[] | {
-                id: number | string;
-                errorMessages: string[];
-            }[]>;
-            isDisabled: vue.ComputedRef<boolean>;
-            isReadonly: vue.ComputedRef<boolean>;
-            isValidating: vue.ShallowRef<boolean, boolean>;
-            isValid: vue.Ref<boolean | null, boolean | null> & {
-                readonly externalValue: boolean | null;
-            };
-            items: vue.Ref<{
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[], FormField[] | {
-                id: number | string;
-                validate: () => Promise<string[]>;
-                reset: () => Promise<void>;
-                resetValidation: () => Promise<void>;
-                vm: vue.Raw<vue.ComponentInternalInstance>;
-                isValid: boolean | null;
-                errorMessages: string[];
-            }[]>;
-            validate: () => Promise<{
-                valid: boolean;
-                errors: {
-                    id: number | string;
-                    errorMessages: string[];
-                }[];
-            }>;
+            errors: FieldValidationResult[];
+            isDisabled: boolean;
+            isReadonly: boolean;
+            isValidating: boolean;
+            isValid: boolean | null;
+            items: FormField[];
+            validate: () => Promise<FormValidationResult>;
             reset: () => void;
             resetValidation: () => void;
         }) => vue.VNodeChild) | undefined;
     } | undefined;
 } & {
     "v-slot:default"?: false | ((arg: {
-        errors: vue.Ref<{
-            id: number | string;
-            errorMessages: string[];
-        }[], FieldValidationResult[] | {
-            id: number | string;
-            errorMessages: string[];
-        }[]>;
-        isDisabled: vue.ComputedRef<boolean>;
-        isReadonly: vue.ComputedRef<boolean>;
-        isValidating: vue.ShallowRef<boolean, boolean>;
-        isValid: vue.Ref<boolean | null, boolean | null> & {
-            readonly externalValue: boolean | null;
-        };
-        items: vue.Ref<{
-            id: number | string;
-            validate: () => Promise<string[]>;
-            reset: () => Promise<void>;
-            resetValidation: () => Promise<void>;
-            vm: vue.Raw<vue.ComponentInternalInstance>;
-            isValid: boolean | null;
-            errorMessages: string[];
-        }[], FormField[] | {
-            id: number | string;
-            validate: () => Promise<string[]>;
-            reset: () => Promise<void>;
-            resetValidation: () => Promise<void>;
-            vm: vue.Raw<vue.ComponentInternalInstance>;
-            isValid: boolean | null;
-            errorMessages: string[];
-        }[]>;
-        validate: () => Promise<{
-            valid: boolean;
-            errors: {
-                id: number | string;
-                errorMessages: string[];
-            }[];
-        }>;
+        errors: FieldValidationResult[];
+        isDisabled: boolean;
+        isReadonly: boolean;
+        isValidating: boolean;
+        isValid: boolean | null;
+        items: FormField[];
+        validate: () => Promise<FormValidationResult>;
         reset: () => void;
         resetValidation: () => void;
     }) => vue.VNodeChild) | undefined;
@@ -31935,43 +31563,13 @@ declare const VForm: {
     fastFail: boolean;
 }, {}, string, vue.SlotsType<Partial<{
     default: (arg: {
-        errors: vue.Ref<{
-            id: number | string;
-            errorMessages: string[];
-        }[], FieldValidationResult[] | {
-            id: number | string;
-            errorMessages: string[];
-        }[]>;
-        isDisabled: vue.ComputedRef<boolean>;
-        isReadonly: vue.ComputedRef<boolean>;
-        isValidating: vue.ShallowRef<boolean, boolean>;
-        isValid: vue.Ref<boolean | null, boolean | null> & {
-            readonly externalValue: boolean | null;
-        };
-        items: vue.Ref<{
-            id: number | string;
-            validate: () => Promise<string[]>;
-            reset: () => Promise<void>;
-            resetValidation: () => Promise<void>;
-            vm: vue.Raw<vue.ComponentInternalInstance>;
-            isValid: boolean | null;
-            errorMessages: string[];
-        }[], FormField[] | {
-            id: number | string;
-            validate: () => Promise<string[]>;
-            reset: () => Promise<void>;
-            resetValidation: () => Promise<void>;
-            vm: vue.Raw<vue.ComponentInternalInstance>;
-            isValid: boolean | null;
-            errorMessages: string[];
-        }[]>;
-        validate: () => Promise<{
-            valid: boolean;
-            errors: {
-                id: number | string;
-                errorMessages: string[];
-            }[];
-        }>;
+        errors: FieldValidationResult[];
+        isDisabled: boolean;
+        isReadonly: boolean;
+        isValidating: boolean;
+        isValid: boolean | null;
+        items: FormField[];
+        validate: () => Promise<FormValidationResult>;
         reset: () => void;
         resetValidation: () => void;
     }) => vue.VNode[];
@@ -39475,17 +39073,20 @@ declare const VSelect: {
         'prepend-inner': (arg: DefaultInputSlot) => vue.VNode[];
         'append-inner': (arg: DefaultInputSlot) => vue.VNode[];
         item: (arg: {
-            item: ListItem<unknown>;
+            item: unknown;
+            internalItem: ListItem<unknown>;
             index: number;
             props: Record<string, unknown>;
         }) => vue.VNode[];
         chip: (arg: {
-            item: ListItem<unknown>;
+            item: unknown;
+            internalItem: ListItem<unknown>;
             index: number;
             props: Record<string, unknown>;
         }) => vue.VNode[];
         selection: (arg: {
-            item: ListItem<unknown>;
+            item: unknown;
+            internalItem: ListItem<unknown>;
             index: number;
         }) => vue.VNode[];
         'prepend-item': () => vue.VNode[];
@@ -40330,17 +39931,20 @@ declare const VSelect: {
     'prepend-inner': (arg: DefaultInputSlot) => vue.VNode[];
     'append-inner': (arg: DefaultInputSlot) => vue.VNode[];
     item: (arg: {
-        item: ListItem<unknown>;
+        item: unknown;
+        internalItem: ListItem<unknown>;
         index: number;
         props: Record<string, unknown>;
     }) => vue.VNode[];
     chip: (arg: {
-        item: ListItem<unknown>;
+        item: unknown;
+        internalItem: ListItem<unknown>;
         index: number;
         props: Record<string, unknown>;
     }) => vue.VNode[];
     selection: (arg: {
-        item: ListItem<unknown>;
+        item: unknown;
+        internalItem: ListItem<unknown>;
         index: number;
     }) => vue.VNode[];
     'prepend-item': () => vue.VNode[];
@@ -40357,17 +39961,20 @@ declare const VSelect: {
     "onUpdate:modelValue"?: (value: V) => void;
 }, slots: Omit<VInputSlots & VFieldSlots, "default"> & {
     item: {
-        item: ListItem<Item>;
+        item: Item;
+        internalItem: ListItem<Item>;
         index: number;
         props: Record<string, unknown>;
     };
     chip: {
-        item: ListItem<Item>;
+        item: Item;
+        internalItem: ListItem<Item>;
         index: number;
         props: Record<string, unknown>;
     };
     selection: {
-        item: ListItem<Item>;
+        item: Item;
+        internalItem: ListItem<Item>;
         index: number;
     };
     "prepend-item": never;
@@ -72156,52 +71763,45 @@ declare module 'vue' {
     $children?: VNodeChild
   }
   export interface GlobalComponents {
+    VAutocomplete: VAutocomplete
     VApp: VApp
     VAlert: VAlert
     VAlertTitle: VAlertTitle
-    VAutocomplete: VAutocomplete
-    VAppBar: VAppBar
-    VAppBarNavIcon: VAppBarNavIcon
-    VAppBarTitle: VAppBarTitle
+    VAvatar: VAvatar
     VBreadcrumbs: VBreadcrumbs
     VBreadcrumbsItem: VBreadcrumbsItem
     VBreadcrumbsDivider: VBreadcrumbsDivider
-    VBanner: VBanner
-    VBannerActions: VBannerActions
-    VBannerText: VBannerText
-    VBottomSheet: VBottomSheet
     VBadge: VBadge
-    VAvatar: VAvatar
     VBottomNavigation: VBottomNavigation
-    VBtnGroup: VBtnGroup
-    VBtnToggle: VBtnToggle
-    VCarousel: VCarousel
-    VCarouselItem: VCarouselItem
     VBtn: VBtn
+    VBanner: VBanner
+    VBannerActions: VBannerActions
+    VBannerText: VBannerText
     VCard: VCard
     VCardActions: VCardActions
     VCardItem: VCardItem
     VCardSubtitle: VCardSubtitle
     VCardText: VCardText
     VCardTitle: VCardTitle
-    VChip: VChip
+    VCarousel: VCarousel
+    VCarouselItem: VCarouselItem
+    VBtnGroup: VBtnGroup
+    VBottomSheet: VBottomSheet
+    VBtnToggle: VBtnToggle
+    VChipGroup: VChipGroup
     VCheckbox: VCheckbox
     VCheckboxBtn: VCheckboxBtn
-    VCode: VCode
-    VChipGroup: VChipGroup
-    VCounter: VCounter
+    VChip: VChip
     VColorPicker: VColorPicker
     VCombobox: VCombobox
+    VCode: VCode
     VDatePicker: VDatePicker
     VDatePickerControls: VDatePickerControls
     VDatePickerHeader: VDatePickerHeader
     VDatePickerMonth: VDatePickerMonth
     VDatePickerMonths: VDatePickerMonths
     VDatePickerYears: VDatePickerYears
-    VDivider: VDivider
-    VDialog: VDialog
-    VField: VField
-    VFieldLabel: VFieldLabel
+    VCounter: VCounter
     VEmptyState: VEmptyState
     VDataTable: VDataTable
     VDataTableHeaders: VDataTableHeaders
@@ -72210,26 +71810,27 @@ declare module 'vue' {
     VDataTableRow: VDataTableRow
     VDataTableVirtual: VDataTableVirtual
     VDataTableServer: VDataTableServer
+    VDialog: VDialog
+    VDivider: VDivider
+    VFab: VFab
     VExpansionPanels: VExpansionPanels
     VExpansionPanel: VExpansionPanel
     VExpansionPanelText: VExpansionPanelText
     VExpansionPanelTitle: VExpansionPanelTitle
-    VFooter: VFooter
-    VFab: VFab
     VFileInput: VFileInput
-    VInput: VInput
     VIcon: VIcon
     VComponentIcon: VComponentIcon
     VSvgIcon: VSvgIcon
     VLigatureIcon: VLigatureIcon
     VClassIcon: VClassIcon
+    VFooter: VFooter
+    VField: VField
+    VFieldLabel: VFieldLabel
+    VInfiniteScroll: VInfiniteScroll
     VItemGroup: VItemGroup
     VItem: VItem
+    VInput: VInput
     VImg: VImg
-    VInfiniteScroll: VInfiniteScroll
-    VKbd: VKbd
-    VMain: VMain
-    VMessages: VMessages
     VLabel: VLabel
     VList: VList
     VListGroup: VListGroup
@@ -72240,70 +71841,73 @@ declare module 'vue' {
     VListItemSubtitle: VListItemSubtitle
     VListItemTitle: VListItemTitle
     VListSubheader: VListSubheader
+    VMain: VMain
+    VKbd: VKbd
+    VMessages: VMessages
+    VMenu: VMenu
+    VNavigationDrawer: VNavigationDrawer
     VOverlay: VOverlay
+    VOtpInput: VOtpInput
+    VProgressLinear: VProgressLinear
+    VRadioGroup: VRadioGroup
     VProgressCircular: VProgressCircular
-    VNavigationDrawer: VNavigationDrawer
     VPagination: VPagination
-    VMenu: VMenu
-    VRadioGroup: VRadioGroup
-    VOtpInput: VOtpInput
     VRating: VRating
-    VProgressLinear: VProgressLinear
-    VSheet: VSheet
-    VSelectionControl: VSelectionControl
     VSelect: VSelect
-    VSelectionControlGroup: VSelectionControlGroup
+    VSelectionControl: VSelectionControl
+    VSheet: VSheet
+    VSnackbar: VSnackbar
     VSlideGroup: VSlideGroup
     VSlideGroupItem: VSlideGroupItem
-    VSnackbar: VSnackbar
+    VSelectionControlGroup: VSelectionControlGroup
     VSkeletonLoader: VSkeletonLoader
-    VSwitch: VSwitch
-    VTab: VTab
-    VTabs: VTabs
-    VTabsWindow: VTabsWindow
-    VTabsWindowItem: VTabsWindowItem
     VSlider: VSlider
-    VTable: VTable
     VStepper: VStepper
     VStepperActions: VStepperActions
     VStepperHeader: VStepperHeader
     VStepperItem: VStepperItem
     VStepperWindow: VStepperWindow
     VStepperWindowItem: VStepperWindowItem
+    VTab: VTab
+    VTabs: VTabs
+    VTabsWindow: VTabsWindow
+    VTabsWindowItem: VTabsWindowItem
     VSystemBar: VSystemBar
-    VTextarea: VTextarea
-    VTextField: VTextField
     VToolbar: VToolbar
     VToolbarTitle: VToolbarTitle
     VToolbarItems: VToolbarItems
-    VTimeline: VTimeline
-    VTimelineItem: VTimelineItem
+    VTextarea: VTextarea
+    VTextField: VTextField
+    VSwitch: VSwitch
+    VTable: VTable
     VTooltip: VTooltip
     VWindow: VWindow
     VWindowItem: VWindowItem
-    VDataIterator: VDataIterator
+    VTimeline: VTimeline
+    VTimelineItem: VTimelineItem
     VConfirmEdit: VConfirmEdit
+    VDataIterator: VDataIterator
     VDefaultsProvider: VDefaultsProvider
+    VForm: VForm
     VContainer: VContainer
     VCol: VCol
     VRow: VRow
     VSpacer: VSpacer
     VHover: VHover
-    VForm: VForm
-    VLazy: VLazy
     VLayout: VLayout
     VLayoutItem: VLayoutItem
+    VLazy: VLazy
     VLocaleProvider: VLocaleProvider
     VNoSsr: VNoSsr
     VParallax: VParallax
     VRadio: VRadio
-    VResponsive: VResponsive
     VRangeSlider: VRangeSlider
+    VResponsive: VResponsive
     VSparkline: VSparkline
     VSpeedDial: VSpeedDial
     VThemeProvider: VThemeProvider
-    VValidation: VValidation
     VVirtualScroll: VVirtualScroll
+    VValidation: VValidation
     VFabTransition: VFabTransition
     VDialogBottomTransition: VDialogBottomTransition
     VDialogTopTransition: VDialogTopTransition
@@ -72320,26 +71924,29 @@ declare module 'vue' {
     VExpandTransition: VExpandTransition
     VExpandXTransition: VExpandXTransition
     VDialogTransition: VDialogTransition
+    VAppBar: VAppBar
+    VAppBarNavIcon: VAppBarNavIcon
+    VAppBarTitle: VAppBarTitle
+    VNumberInput: VNumberInput
+    VPicker: VPicker
+    VPickerTitle: VPickerTitle
     VCalendar: VCalendar
     VCalendarDay: VCalendarDay
     VCalendarHeader: VCalendarHeader
     VCalendarInterval: VCalendarInterval
     VCalendarIntervalEvent: VCalendarIntervalEvent
     VCalendarMonthDay: VCalendarMonthDay
-    VNumberInput: VNumberInput
-    VPicker: VPicker
-    VPickerTitle: VPickerTitle
     VFileUpload: VFileUpload
     VFileUploadItem: VFileUploadItem
     VStepperVertical: VStepperVertical
     VStepperVerticalItem: VStepperVerticalItem
     VStepperVerticalActions: VStepperVerticalActions
-    VTimePicker: VTimePicker
-    VTimePickerClock: VTimePickerClock
-    VTimePickerControls: VTimePickerControls
     VTreeview: VTreeview
     VTreeviewItem: VTreeviewItem
     VTreeviewGroup: VTreeviewGroup
+    VTimePicker: VTimePicker
+    VTimePickerClock: VTimePickerClock
+    VTimePickerControls: VTimePickerControls
     VDateInput: VDateInput
     VPullToRefresh: VPullToRefresh
     VSnackbarQueue: VSnackbarQueue