vee-validate 4.15.1 → 5.0.0-beta.0

package/README.md

@@ -18,7 +18,7 @@ Painless Vue forms
   <img src="https://img.shields.io/npm/dm/vee-validate.svg?color=05bd6d&label=">
 </a>
 
-<a href="https://vee-validate.logaretm.com/v4/" target="_blank">
+<a href="https://vee-validate.logaretm.com/v5/" target="_blank">
   <img src="https://img.shields.io/badge/-docs%20and%20demos-009f53">
 </a>
 
@@ -69,7 +69,7 @@ The main v4 version supports Vue 3.x only, for previous versions of Vue, check t
 | vue Version | vee-validate version | Documentation Link                                                                       |
 | ----------- | -------------------- | ---------------------------------------------------------------------------------------- |
 | `2.x`       | `2.x` or `3.x`       | [v2](https://vee-validate.logaretm.com/v2) or [v3](https://vee-validate.logaretm.com/v3) |
-| `3.x`       | `4.x`                | [v4](https://vee-validate.logaretm.com/v4)                                               |
+| `3.x`       | `4.x` or `5.x`       | [v4](https://vee-validate.logaretm.com/v4) or [v5](https://vee-validate.logaretm.com/v5) |
 
 ### Usage
 
@@ -117,7 +117,7 @@ const onSubmit = handleSubmit(values => {
 </template>
 ```
 
-You can do so much more than this, for more info [check the composition API documentation](https://vee-validate.logaretm.com/v4/guide/composition-api/getting-started/).
+You can do so much more than this, for more info [check the composition API documentation](https://vee-validate.logaretm.com/v5/guide/composition-api/getting-started/).
 
 #### Declarative Components
 
@@ -150,7 +150,7 @@ function onSubmit(values) {
 </template>
 ```
 
-The `Field` component renders an `input` of type `text` by default but you can [control that](https://vee-validate.logaretm.com/v4/api/field#rendering-fields)
+The `Field` component renders an `input` of type `text` by default but you can [control that](https://vee-validate.logaretm.com/v5/api/field#rendering-fields)
 
 ## 📚 Documentation
 

package/dist/vee-validate.cjs

@@ -1,5 +1,5 @@
 /**
-  * vee-validate v4.15.1
+  * vee-validate v5.0.0-beta.0
   * (c) 2025 Abdelrahman Awad
   * @license MIT
   */
@@ -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';
@@ -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;
@@ -177,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);
@@ -211,7 +186,6 @@ interface FieldMeta<TValue> {
     dirty: boolean;
     valid: boolean;
     validated: boolean;
-    required: boolean;
     pending: boolean;
     initialValue?: TValue;
 }
@@ -244,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;
@@ -415,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>>;
@@ -489,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;
@@ -551,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.
  */
@@ -1354,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>;
@@ -1363,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>;
@@ -1482,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 };