vee-validate 4.15.0 → 5.0.0-beta.0

package/dist/vee-validate.cjs

@@ -1,6 +1,6 @@
 /**
-  * vee-validate v4.15.0
-  * (c) 2024 Abdelrahman Awad
+  * vee-validate v5.0.0-beta.0
+  * (c) 2025 Abdelrahman Awad
   * @license MIT
   */
 'use strict';
@@ -164,11 +164,8 @@ const isClient = typeof window !== 'undefined';
 function isLocator(value) {
     return isCallable(value) && !!value.__locatorRef;
 }
-function isTypedSchema(value) {
-    return !!value && isCallable(value.parse) && value.__type === 'VVTypedSchema';
-}
-function isYupValidator(value) {
-    return !!value && isCallable(value.validate);
+function isStandardSchema(value) {
+    return isObject(value) && '~standard' in value;
 }
 function hasCheckedAttr(type) {
     return type === 'checkbox' || type === 'radio';
@@ -312,14 +309,16 @@ function isEqual(a, b) {
             return a.valueOf() === b.valueOf();
         if (a.toString !== Object.prototype.toString)
             return a.toString() === b.toString();
+        // Remove undefined values before object comparison
+        a = normalizeObject(a);
+        b = normalizeObject(b);
         keys = Object.keys(a);
-        length = keys.length - countUndefinedValues(a, keys);
-        if (length !== Object.keys(b).length - countUndefinedValues(b, Object.keys(b)))
+        length = keys.length;
+        if (length !== Object.keys(b).length)
             return false;
-        for (i = length; i-- !== 0;) {
+        for (i = length; i-- !== 0;)
             if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
                 return false;
-        }
         for (i = length; i-- !== 0;) {
             // eslint-disable-next-line no-var
             var key = keys[i];
@@ -331,15 +330,13 @@ function isEqual(a, b) {
     // true if both NaN, false otherwise
     return a !== a && b !== b;
 }
-function countUndefinedValues(a, keys) {
-    let result = 0;
-    for (let i = keys.length; i-- !== 0;) {
-        // eslint-disable-next-line no-var
-        var key = keys[i];
-        if (a[key] === undefined)
-            result++;
-    }
-    return result;
+/**
+ * Returns a new object where keys with an `undefined` value are removed.
+ *
+ * @param a object to normalize
+ */
+function normalizeObject(a) {
+    return Object.fromEntries(Object.entries(a).filter(([, value]) => value !== undefined));
 }
 function isFile(a) {
     if (!isClient) {
@@ -348,6 +345,27 @@ function isFile(a) {
     return a instanceof File;
 }
 
+// src/getDotPath/getDotPath.ts
+function getDotPath(issue) {
+  if (issue.path?.length) {
+    let dotPath = "";
+    for (const item of issue.path) {
+      const key = typeof item === "object" ? item.key : item;
+      if (typeof key === "string" || typeof key === "number") {
+        if (dotPath) {
+          dotPath += `.${key}`;
+        } else {
+          dotPath += key;
+        }
+      } else {
+        return null;
+      }
+    }
+    return dotPath;
+  }
+  return null;
+}
+
 function cleanupNonNestedPath(path) {
     if (isNotNestedPath(path)) {
         return path.replace(/\[|\]/gi, '');
@@ -563,6 +581,31 @@ function debounceNextTick(inner) {
         return new Promise(resolve => resolves.push(resolve));
     };
 }
+function _combineIssueItems(items, getPath) {
+    const issueMap = {};
+    for (const item of items) {
+        const path = getPath(item);
+        if (!issueMap[path]) {
+            issueMap[path] = {
+                path,
+                messages: [],
+            };
+        }
+        if ('messages' in item) {
+            issueMap[path].messages.push(...item.messages);
+        }
+        else {
+            issueMap[path].messages.push(item.message);
+        }
+    }
+    return Object.values(issueMap);
+}
+/**
+ * Aggregates standard schema issues by path.
+ */
+function combineStandardIssues(issues) {
+    return _combineIssueItems(issues, issue => { var _a; return (issue.path ? (_a = getDotPath(issue)) !== null && _a !== void 0 ? _a : '' : ''); });
+}
 
 function normalizeChildren(tag, context, slotProps) {
     if (!context.slots.default) {
@@ -769,8 +812,8 @@ async function validate(value, rules, options = {}) {
  */
 async function _validate(field, value) {
     const rules = field.rules;
-    if (isTypedSchema(rules) || isYupValidator(rules)) {
-        return validateFieldWithTypedSchema(value, Object.assign(Object.assign({}, field), { rules }));
+    if (isStandardSchema(rules)) {
+        return validateFieldWithStandardSchema(value, Object.assign(Object.assign({}, field), { rules }));
     }
     // if a generic function or chain of generic functions
     if (isCallable(rules) || Array.isArray(rules)) {
@@ -832,58 +875,24 @@ async function _validate(field, value) {
         errors,
     };
 }
-function isYupError(err) {
-    return !!err && err.name === 'ValidationError';
-}
-function yupToTypedSchema(yupSchema) {
-    const schema = {
-        __type: 'VVTypedSchema',
-        async parse(values, context) {
-            var _a;
-            try {
-                const output = await yupSchema.validate(values, { abortEarly: false, context: (context === null || context === void 0 ? void 0 : context.formData) || {} });
-                return {
-                    output,
-                    errors: [],
-                };
-            }
-            catch (err) {
-                // Yup errors have a name prop one them.
-                // https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string
-                if (!isYupError(err)) {
-                    throw err;
-                }
-                if (!((_a = err.inner) === null || _a === void 0 ? void 0 : _a.length) && err.errors.length) {
-                    return { errors: [{ path: err.path, errors: err.errors }] };
-                }
-                const errors = err.inner.reduce((acc, curr) => {
-                    const path = curr.path || '';
-                    if (!acc[path]) {
-                        acc[path] = { errors: [], path };
-                    }
-                    acc[path].errors.push(...curr.errors);
-                    return acc;
-                }, {});
-                return { errors: Object.values(errors) };
-            }
-        },
-    };
-    return schema;
-}
 /**
  * Handles yup validation
  */
-async function validateFieldWithTypedSchema(value, context) {
-    const typedSchema = isTypedSchema(context.rules) ? context.rules : yupToTypedSchema(context.rules);
-    const result = await typedSchema.parse(value, { formData: context.formData });
+async function validateFieldWithStandardSchema(value, context) {
+    const result = await context.rules['~standard'].validate(value);
+    if (!result.issues) {
+        return {
+            value: result.value,
+            errors: [],
+        };
+    }
     const messages = [];
-    for (const error of result.errors) {
-        if (error.errors.length) {
-            messages.push(...error.errors);
+    for (const error of result.issues) {
+        if (error.message) {
+            messages.push(error.message);
         }
     }
     return {
-        value: result.value,
         errors: messages,
     };
 }
@@ -939,27 +948,33 @@ function fillTargetValues(params, crossTable) {
         return acc;
     }, {});
 }
-async function validateTypedSchema(schema, values) {
-    const typedSchema = isTypedSchema(schema) ? schema : yupToTypedSchema(schema);
-    const validationResult = await typedSchema.parse(klona(values), { formData: klona(values) });
+async function validateStandardSchema(schema, values) {
+    const validationResult = await schema['~standard'].validate(klona(values));
     const results = {};
     const errors = {};
-    for (const error of validationResult.errors) {
-        const messages = error.errors;
-        // Fixes issue with path mapping with Yup 1.0 including quotes around array indices
-        const path = (error.path || '').replace(/\["(\d+)"\]/g, (_, m) => {
-            return `[${m}]`;
-        });
+    if (!validationResult.issues) {
+        return {
+            valid: true,
+            results: {},
+            errors: {},
+            values: validationResult.value,
+            source: 'schema',
+        };
+    }
+    const combinedIssues = combineStandardIssues(validationResult.issues || []);
+    for (const error of combinedIssues) {
+        const messages = error.messages;
+        const path = error.path;
         results[path] = { valid: !messages.length, errors: messages };
         if (messages.length) {
             errors[path] = messages[0];
         }
     }
     return {
-        valid: !validationResult.errors.length,
+        valid: !combinedIssues.length,
         results,
         errors,
-        values: validationResult.value,
+        values: undefined,
         source: 'schema',
     };
 }
@@ -1004,7 +1019,7 @@ function useFieldState(path, init) {
     if (!init.form) {
         const { errors, setErrors } = createFieldErrors();
         const id = ID_COUNTER >= Number.MAX_SAFE_INTEGER ? 0 : ++ID_COUNTER;
-        const meta = createFieldMeta(value, initialValue, errors, init.schema);
+        const meta = createFieldMeta(value, initialValue, errors);
         function setState(state) {
             var _a;
             if ('value' in state) {
@@ -1036,7 +1051,6 @@ function useFieldState(path, init) {
         label: init.label,
         type: init.type,
         validate: init.validate,
-        schema: init.schema,
     });
     const errors = vue.computed(() => state.errors);
     function setState(state) {
@@ -1132,13 +1146,11 @@ function resolveModelValue(modelValue, form, initialValue, path) {
 /**
  * Creates meta flags state and some associated effects with them
  */
-function createFieldMeta(currentValue, initialValue, errors, schema) {
-    const isRequired = vue.computed(() => { var _a, _b, _c; return (_c = (_b = (_a = vue.toValue(schema)) === null || _a === void 0 ? void 0 : _a.describe) === null || _b === void 0 ? void 0 : _b.call(_a).required) !== null && _c !== void 0 ? _c : false; });
+function createFieldMeta(currentValue, initialValue, errors) {
     const meta = vue.reactive({
         touched: false,
         pending: false,
         valid: true,
-        required: isRequired,
         validated: !!vue.unref(errors).length,
         initialValue: vue.computed(() => vue.unref(initialValue)),
         dirty: vue.computed(() => {
@@ -1186,15 +1198,11 @@ function _useField(path, rules, opts) {
             return undefined;
         }
         const rulesValue = vue.unref(rules);
-        if (isYupValidator(rulesValue) ||
-            isTypedSchema(rulesValue) ||
-            isCallable(rulesValue) ||
-            Array.isArray(rulesValue)) {
+        if (isStandardSchema(rulesValue) || isCallable(rulesValue) || Array.isArray(rulesValue)) {
             return rulesValue;
         }
         return normalizeRules(rulesValue);
     });
-    const isTyped = !isCallable(validator.value) && isTypedSchema(vue.toValue(rules));
     const { id, value, initialValue, meta, setState, errors, flags } = useFieldState(name, {
         modelValue,
         form,
@@ -1202,7 +1210,6 @@ function _useField(path, rules, opts) {
         label,
         type,
         validate: validator.value ? validate$1 : undefined,
-        schema: isTyped ? rules : undefined,
     });
     const errorMessage = vue.computed(() => errors.value[0]);
     if (syncVModel) {
@@ -1354,12 +1361,8 @@ function _useField(path, rules, opts) {
     // extract cross-field dependencies in a computed prop
     const dependencies = vue.computed(() => {
         const rulesVal = validator.value;
-        // is falsy, a function schema or a yup schema
-        if (!rulesVal ||
-            isCallable(rulesVal) ||
-            isYupValidator(rulesVal) ||
-            isTypedSchema(rulesVal) ||
-            Array.isArray(rulesVal)) {
+        // is falsy, a function schema or a standard schema
+        if (!rulesVal || isCallable(rulesVal) || isStandardSchema(rulesVal) || Array.isArray(rulesVal)) {
             return {};
         }
         return Object.keys(rulesVal).reduce((acc, rule) => {
@@ -1734,10 +1737,6 @@ const PRIVATE_PATH_STATE_KEYS = ['bails', 'fieldsCount', 'id', 'multiple', 'type
 function resolveInitialValues(opts) {
     const givenInitial = (opts === null || opts === void 0 ? void 0 : opts.initialValues) || {};
     const providedValues = Object.assign({}, vue.toValue(givenInitial));
-    const schema = vue.unref(opts === null || opts === void 0 ? void 0 : opts.validationSchema);
-    if (schema && isTypedSchema(schema) && isCallable(schema.cast)) {
-        return klona(schema.cast(providedValues) || {});
-    }
     return klona(providedValues);
 }
 function useForm(opts) {
@@ -1872,19 +1871,6 @@ function useForm(opts) {
         if (unsetBatchIndex !== -1) {
             UNSET_BATCH.splice(unsetBatchIndex, 1);
         }
-        const isRequired = vue.computed(() => {
-            var _a, _b, _c, _d;
-            const schemaValue = vue.toValue(schema);
-            if (isTypedSchema(schemaValue)) {
-                return (_b = (_a = schemaValue.describe) === null || _a === void 0 ? void 0 : _a.call(schemaValue, vue.toValue(path)).required) !== null && _b !== void 0 ? _b : false;
-            }
-            // Path own schema
-            const configSchemaValue = vue.toValue(config === null || config === void 0 ? void 0 : config.schema);
-            if (isTypedSchema(configSchemaValue)) {
-                return (_d = (_c = configSchemaValue.describe) === null || _c === void 0 ? void 0 : _c.call(configSchemaValue).required) !== null && _d !== void 0 ? _d : false;
-            }
-            return false;
-        });
         const id = FIELD_ID_COUNTER++;
         const state = vue.reactive({
             id,
@@ -1893,7 +1879,6 @@ function useForm(opts) {
             pending: false,
             valid: true,
             validated: !!((_a = initialErrors[pathValue]) === null || _a === void 0 ? void 0 : _a.length),
-            required: isRequired,
             initialValue,
             errors: vue.shallowRef([]),
             bails: (_b = config === null || config === void 0 ? void 0 : config.bails) !== null && _b !== void 0 ? _b : false,
@@ -2306,7 +2291,6 @@ function useForm(opts) {
     function resetForm(resetState, opts) {
         let newValues = klona((resetState === null || resetState === void 0 ? void 0 : resetState.values) ? resetState.values : originalInitialValues.value);
         newValues = (opts === null || opts === void 0 ? void 0 : opts.force) ? newValues : merge(originalInitialValues.value, newValues);
-        newValues = isTypedSchema(schema) && isCallable(schema.cast) ? schema.cast(newValues) : newValues;
         setInitialValues(newValues, { force: opts === null || opts === void 0 ? void 0 : opts.force });
         mutateAllPathState(state => {
             var _a;
@@ -2419,8 +2403,8 @@ function useForm(opts) {
             return { valid: true, results: {}, errors: {}, source: 'none' };
         }
         isValidating.value = true;
-        const formResult = isYupValidator(schemaValue) || isTypedSchema(schemaValue)
-            ? await validateTypedSchema(schemaValue, formValues)
+        const formResult = isStandardSchema(schemaValue)
+            ? await validateStandardSchema(schemaValue, formValues)
             : await validateObjectSchema(schemaValue, formValues, {
                 names: fieldNames.value,
                 bailsMap: fieldBailsMap.value,

package/dist/vee-validate.d.ts

@@ -1,6 +1,7 @@
 import * as vue from 'vue';
 import { MaybeRef, Ref, MaybeRefOrGetter, ComputedRef, PropType, VNode, UnwrapRef, InjectionKey } from 'vue';
 import { PartialDeep } from 'type-fest';
+import { StandardSchemaV1 } from '@standard-schema/spec';
 
 type BrowserNativeObject = Date | FileList | File;
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
@@ -59,24 +60,41 @@ type AnyIsEqual<T1, T2> = T1 extends T2 ? (IsEqual<T1, T2> extends true ? true :
  */
 type TupleKeys<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
 /**
- * Helper type for recursively constructing paths through a type.
- * This actually constructs the strings and recurses into nested
- * object types.
+ * Helper type to construct tuple key paths and recurse into its elements.
+ *
+ * See {@link Path}
+ */
+type PathInternalTuple<TValue extends ReadonlyArray<any>, TraversedTypes> = {
+    [Key in TupleKeys<TValue> & string]: `[${Key}]` | `[${Key}]${PathInternal<TValue[Key], TraversedTypes, false>}`;
+}[TupleKeys<TValue> & string];
+/**
+ * Helper type to construct array key paths and recurse into its elements.
+ *
+ * See {@link Path}
+ */
+type PathInternalArray<TValue extends ReadonlyArray<any>, TraversedTypes> = `[${ArrayKey}]` | `[${ArrayKey}]${PathInternal<TValue[ArrayKey], TraversedTypes, false>}`;
+/**
+ * Helper type to construct object key paths and recurse into its nested values.
+ *
+ * See {@link Path}
+ */
+type PathInternalObject<TValue, TraversedTypes, First extends boolean> = {
+    [Key in keyof TValue & string]: First extends true ? `${Key}` | `${Key}${PathInternal<TValue[Key], TraversedTypes, false>}` : `.${Key}` | `.${Key}${PathInternal<TValue[Key], TraversedTypes, false>}`;
+}[keyof TValue & string];
+/**
+ * Helper type to construct nested any object key paths.
  *
  * See {@link Path}
  */
-type PathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? `${K}` : true extends AnyIsEqual<TraversedTypes, V> ? `${K}` : `${K}` | `${K}.${PathInternal<V, TraversedTypes | V>}`;
+type PathInternalAny = `.${string}` | `[${string}]` | `[${string}].${string}`;
 /**
  * Helper type for recursively constructing paths through a type.
- * This obscures the internal type param TraversedTypes from ed contract.
+ *
+ * This obscures internal type params TraversedTypes and First from ed contract.
  *
  * See {@link Path}
  */
-type PathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-    [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], TraversedTypes>;
-}[TupleKeys<T>] : PathImpl<ArrayKey, V, TraversedTypes> : {
-    [K in keyof T]-?: PathImpl<K & string, T[K], TraversedTypes>;
-}[keyof T];
+type PathInternal<TValue, TraversedTypes, First extends boolean> = TValue extends Primitive | BrowserNativeObject ? IsAny<TValue> extends true ? PathInternalAny : never : TValue extends ReadonlyArray<any> ? true extends AnyIsEqual<TraversedTypes, TValue> ? never : IsTuple<TValue> extends true ? PathInternalTuple<TValue, TraversedTypes | TValue> : PathInternalArray<TValue, TraversedTypes | TValue> : TValue extends Record<string, any> ? PathInternalObject<TValue, TraversedTypes | TValue, First> : '';
 /**
  * Helper type for recursively constructing paths through a type.
  * This actually constructs the strings and recurses into nested
@@ -125,7 +143,7 @@ type PathValue<T, P extends Path<T> | ArrayPath<T>> = T extends any ? P extends
  * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
  * ```
  */
-type Path<T> = T extends any ? PathInternal<T> : never;
+type Path<T> = T extends any ? PathInternal<T, T, true> & string : never;
 
 type GenericObject = Record<string, any>;
 type MaybeArray<T> = T | T[];
@@ -160,32 +178,6 @@ interface ValidationResult<TValue = unknown> {
 type FlattenAndMapPathsValidationResult<TInput extends GenericObject, TOutput extends GenericObject> = {
     [K in Path<TInput>]: ValidationResult<TOutput[K]>;
 };
-interface TypedSchemaError {
-    path?: string;
-    errors: string[];
-}
-interface TypedSchemaPathDescription {
-    required: boolean;
-    exists: boolean;
-}
-interface TypedSchemaContext {
-    formData: GenericObject;
-}
-interface TypedSchema<TInput = any, TOutput = TInput> {
-    __type: 'VVTypedSchema';
-    parse(values: TInput, context?: TypedSchemaContext): Promise<{
-        value?: TOutput;
-        errors: TypedSchemaError[];
-    }>;
-    cast?(values: Partial<TInput>): TInput;
-    describe?(path?: Path<TInput>): Partial<TypedSchemaPathDescription>;
-}
-type InferOutput<TSchema extends TypedSchema> = TSchema extends TypedSchema<any, infer TOutput> ? TOutput : never;
-type InferInput<TSchema extends TypedSchema> = TSchema extends TypedSchema<infer TInput, any> ? TInput : never;
-type YupSchema<TValues = any> = {
-    __isYupSchema__: boolean;
-    validate(value: any, options: GenericObject): Promise<any>;
-};
 type Locator = {
     __locatorRef: string;
 } & ((values: GenericObject) => unknown);
@@ -194,7 +186,6 @@ interface FieldMeta<TValue> {
     dirty: boolean;
     valid: boolean;
     validated: boolean;
-    required: boolean;
     pending: boolean;
     initialValue?: TValue;
 }
@@ -227,15 +218,18 @@ interface PathStateConfig<TOutput> {
     label: MaybeRefOrGetter<string | undefined>;
     type: InputType;
     validate: FieldValidator<TOutput>;
-    schema?: MaybeRefOrGetter<TypedSchema | undefined>;
+    schema?: MaybeRefOrGetter<StandardSchemaV1 | undefined>;
 }
+type IssueCollection<TPath = string> = {
+    path: TPath;
+    messages: string[];
+};
 interface PathState<TInput = unknown, TOutput = TInput> {
     id: number | number[];
     path: string;
     touched: boolean;
     dirty: boolean;
     valid: boolean;
-    required: boolean;
     validated: boolean;
     pending: boolean;
     initialValue: TInput | undefined;
@@ -305,8 +299,8 @@ interface FormState<TValues> {
     touched: Partial<Record<Path<TValues>, boolean>>;
     submitCount: number;
 }
-type FormErrors<TValues extends GenericObject> = Partial<Record<Path<TValues>, string | undefined>>;
-type FormErrorBag<TValues extends GenericObject> = Partial<Record<Path<TValues>, string[]>>;
+type FormErrors<TValues extends GenericObject> = Partial<Record<Path<TValues> | '', string | undefined>>;
+type FormErrorBag<TValues extends GenericObject> = Partial<Record<Path<TValues> | '', string[]>>;
 interface ResetFormOpts {
     force: boolean;
 }
@@ -398,7 +392,7 @@ interface PrivateFormContext<TValues extends GenericObject = GenericObject, TOut
     controlledValues: Ref<TValues>;
     fieldArrays: PrivateFieldArrayContext[];
     submitCount: Ref<number>;
-    schema?: MaybeRef<RawFormSchema<TValues> | TypedSchema<TValues, TOutput> | YupSchema<TValues> | undefined>;
+    schema?: MaybeRef<RawFormSchema<TValues> | StandardSchemaV1<TValues, TOutput> | undefined>;
     errorBag: Ref<FormErrorBag<TValues>>;
     errors: ComputedRef<FormErrors<TValues>>;
     meta: ComputedRef<FormMeta<TValues>>;
@@ -472,7 +466,7 @@ interface ValidationOptions {
 /**
  * Validates a value against the rules.
  */
-declare function validate<TInput, TOutput>(value: TInput, rules: string | Record<string, unknown | unknown[]> | GenericValidateFunction<TInput> | GenericValidateFunction<TInput>[] | TypedSchema<TInput, TOutput>, options?: ValidationOptions): Promise<ValidationResult<TOutput>>;
+declare function validate<TInput, TOutput>(value: TInput, rules: string | Record<string, unknown | unknown[]> | GenericValidateFunction<TInput> | GenericValidateFunction<TInput>[] | StandardSchemaV1<TInput, TOutput>, options?: ValidationOptions): Promise<ValidationResult<TOutput>>;
 declare function validateObjectSchema<TValues extends GenericObject, TOutput extends GenericObject>(schema: RawFormSchema<TValues>, values: TValues | undefined, opts?: Partial<{
     names: Record<string, {
         name: string;
@@ -534,7 +528,7 @@ interface FieldOptions<TValue = unknown> {
     syncVModel?: boolean | string;
     form?: FormContext;
 }
-type RuleExpression<TValue> = string | Record<string, unknown> | GenericValidateFunction<TValue> | GenericValidateFunction<TValue>[] | TypedSchema<TValue> | YupSchema<TValue> | undefined;
+type RuleExpression<TValue> = string | Record<string, unknown> | GenericValidateFunction<TValue> | GenericValidateFunction<TValue>[] | StandardSchemaV1<TValue> | undefined;
 /**
  * Creates a field composite.
  */
@@ -1337,8 +1331,8 @@ declare const ErrorMessage: {
 });
 
 type FormSchema<TValues extends Record<string, unknown>> = FlattenAndSetPathsType<TValues, GenericValidateFunction | string | GenericObject> | undefined;
-interface FormOptions<TValues extends GenericObject, TOutput = TValues, TSchema extends TypedSchema<TValues, TOutput> | FormSchema<TValues> = FormSchema<TValues> | TypedSchema<TValues, TOutput>> {
-    validationSchema?: MaybeRef<TSchema extends TypedSchema ? TypedSchema<TValues, TOutput> : any>;
+interface FormOptions<TValues extends GenericObject, TOutput = TValues, TSchema extends StandardSchemaV1<TValues, TOutput> | FormSchema<TValues> = FormSchema<TValues>> {
+    validationSchema?: MaybeRef<TSchema extends StandardSchemaV1 ? StandardSchemaV1<TValues, TOutput> : any>;
     initialValues?: PartialDeep<TValues> | undefined | null;
     initialErrors?: FlattenAndSetPathsType<TValues, string | undefined>;
     initialTouched?: FlattenAndSetPathsType<TValues, boolean>;
@@ -1346,7 +1340,7 @@ interface FormOptions<TValues extends GenericObject, TOutput = TValues, TSchema
     keepValuesOnUnmount?: MaybeRef<boolean>;
     name?: string;
 }
-declare function useForm<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues, TSchema extends FormSchema<TValues> | TypedSchema<TValues, TOutput> = FormSchema<TValues> | TypedSchema<TValues, TOutput>>(opts?: FormOptions<TValues, TOutput, TSchema>): FormContext<TValues, TOutput>;
+declare function useForm<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues, TSchema extends FormSchema<TValues> | StandardSchemaV1<TValues, TOutput> = FormSchema<TValues>>(opts?: FormOptions<TValues, TOutput, TSchema>): FormContext<TValues, TOutput>;
 declare function useFormContext<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues>(): FormContext<TValues, TOutput>;
 
 declare function useFieldArray<TValue = unknown>(arrayPath: MaybeRefOrGetter<string>): FieldArrayContext<TValue>;
@@ -1421,7 +1415,7 @@ declare function useFormValues<TValues extends Record<string, any> = Record<stri
 /**
  * Gives access to all form errors
  */
-declare function useFormErrors<TValues extends Record<string, unknown> = Record<string, unknown>>(): vue.ComputedRef<Partial<Record<Path<TValues>, string>>>;
+declare function useFormErrors<TValues extends Record<string, unknown> = Record<string, unknown>>(): vue.ComputedRef<Partial<Record<"" | Path<TValues>, string>>>;
 
 /**
  * Gives access to a single field error
@@ -1465,4 +1459,4 @@ declare const PublicFormContextKey: InjectionKey<FormContext>;
 declare const FieldContextKey: InjectionKey<PrivateFieldContext<unknown>>;
 declare const IS_ABSENT: unique symbol;
 
-export { type BaseComponentBinds, type BaseFieldProps, type BaseInputBinds, type ComponentBindsConfig, type ComponentFieldBindingObject, type ComponentModelBinds, type ComponentModellessBinds, type DevtoolsPluginFieldState, type DevtoolsPluginFormState, ErrorMessage, Field, FieldArray, type FieldArrayContext, type FieldBindingObject, type FieldContext, FieldContextKey, type FieldEntry, type FieldMeta, type FieldOptions, type FieldPathLookup, type FieldSlotProps, type FieldState, type FieldValidator, type FlattenAndMapPathsValidationResult, type FlattenAndSetPathsType, Form, type FormActions, type FormContext, FormContextKey, type FormErrorBag, type FormErrors, type FormMeta, type FormOptions, type FormSlotProps, type FormState, type FormValidationResult, type GenericObject, type GenericValidateFunction, IS_ABSENT, type InferInput, type InferOutput, type InputBindsConfig, type InputType, type InvalidSubmissionContext, type InvalidSubmissionHandler, type IsAny, type IsEqual, type LazyComponentBindsConfig, type LazyInputBindsConfig, type Locator, type MapValuesPathsToRefs, type MaybeArray, type MaybePromise, type Path, type PathState, type PathStateConfig, type PathValue, type PrivateFieldArrayContext, type PrivateFieldContext, type PrivateFormContext, PublicFormContextKey, type PublicPathState, type RawFormSchema, type ResetFormOpts, type RuleExpression, type SchemaValidationMode, type SubmissionContext, type SubmissionHandler, type TypedSchema, type TypedSchemaContext, type TypedSchemaError, type TypedSchemaPathDescription, type ValidationOptions$1 as ValidationOptions, type ValidationResult, type YupSchema, cleanupNonNestedPath, configure, defineRule, isNotNestedPath, normalizeRules, useField, useFieldArray, useFieldError, useFieldValue, useForm, useFormContext, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useIsValidating, useResetForm, useSetFieldError, useSetFieldTouched, useSetFieldValue, useSetFormErrors, useSetFormTouched, useSetFormValues, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate, validateObjectSchema as validateObject };
+export { type BaseComponentBinds, type BaseFieldProps, type BaseInputBinds, type ComponentBindsConfig, type ComponentFieldBindingObject, type ComponentModelBinds, type ComponentModellessBinds, type DevtoolsPluginFieldState, type DevtoolsPluginFormState, ErrorMessage, Field, FieldArray, type FieldArrayContext, type FieldBindingObject, type FieldContext, FieldContextKey, type FieldEntry, type FieldMeta, type FieldOptions, type FieldPathLookup, type FieldSlotProps, type FieldState, type FieldValidator, type FlattenAndMapPathsValidationResult, type FlattenAndSetPathsType, Form, type FormActions, type FormContext, FormContextKey, type FormErrorBag, type FormErrors, type FormMeta, type FormOptions, type FormSlotProps, type FormState, type FormValidationResult, type GenericObject, type GenericValidateFunction, IS_ABSENT, type InputBindsConfig, type InputType, type InvalidSubmissionContext, type InvalidSubmissionHandler, type IsAny, type IsEqual, type IssueCollection, type LazyComponentBindsConfig, type LazyInputBindsConfig, type Locator, type MapValuesPathsToRefs, type MaybeArray, type MaybePromise, type Path, type PathState, type PathStateConfig, type PathValue, type PrivateFieldArrayContext, type PrivateFieldContext, type PrivateFormContext, PublicFormContextKey, type PublicPathState, type RawFormSchema, type ResetFormOpts, type RuleExpression, type SchemaValidationMode, type SubmissionContext, type SubmissionHandler, type ValidationOptions$1 as ValidationOptions, type ValidationResult, cleanupNonNestedPath, configure, defineRule, isNotNestedPath, normalizeRules, useField, useFieldArray, useFieldError, useFieldValue, useForm, useFormContext, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useIsValidating, useResetForm, useSetFieldError, useSetFieldTouched, useSetFieldValue, useSetFormErrors, useSetFormTouched, useSetFormValues, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate, validateObjectSchema as validateObject };