react-hook-form 7.43.6 → 7.43.7

package/dist/types/path/eager.d.ts

@@ -1,121 +1,121 @@
-import { FieldValues } from '../fields';
-import { BrowserNativeObject, IsAny, IsEqual, Primitive } from '../utils';
-import { ArrayKey, IsTuple, TupleKeys } from './common';
-/**
- * Helper function to break apart T1 and check if any are equal to T2
- *
- * See {@link IsEqual}
- */
-type AnyIsEqual<T1, T2> = T1 extends T2 ? IsEqual<T1, T2> extends true ? true : never : never;
-/**
- * Helper type for recursively constructing paths through a type.
- * This actually constructs the strings and recurses into nested
- * object types.
- *
- * 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>}`;
-/**
- * Helper type for recursively constructing paths through a type.
- * This obscures the internal type param TraversedTypes from exported 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 which eagerly collects all paths through a type
- * @typeParam T - type which should be introspected
- * @example
- * ```
- * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
- * ```
- */
-export type Path<T> = T extends any ? PathInternal<T> : never;
-/**
- * See {@link Path}
- */
-export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>;
-/**
- * Helper type for recursively constructing paths through a type.
- * This actually constructs the strings and recurses into nested
- * object types.
- *
- * See {@link ArrayPath}
- */
-type ArrayPathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : V extends ReadonlyArray<infer U> ? U extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}` | `${K}.${ArrayPathInternal<V, TraversedTypes | V>}` : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}.${ArrayPathInternal<V, TraversedTypes | V>}`;
-/**
- * Helper type for recursively constructing paths through a type.
- * This obscures the internal type param TraversedTypes from exported contract.
- *
- * See {@link ArrayPath}
- */
-type ArrayPathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-    [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
-}[TupleKeys<T>] : ArrayPathImpl<ArrayKey, V, TraversedTypes> : {
-    [K in keyof T]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
-}[keyof T];
-/**
- * Type which eagerly collects all paths through a type which point to an array
- * type.
- * @typeParam T - type which should be introspected.
- * @example
- * ```
- * Path<{foo: {bar: string[], baz: number[]}}> = 'foo.bar' | 'foo.baz'
- * ```
- */
-export type ArrayPath<T> = T extends any ? ArrayPathInternal<T> : never;
-/**
- * See {@link ArrayPath}
- */
-export type FieldArrayPath<TFieldValues extends FieldValues> = ArrayPath<TFieldValues>;
-/**
- * Type to evaluate the type which the given path points to.
- * @typeParam T - deeply nested type which is indexed by the path
- * @typeParam P - path into the deeply nested type
- * @example
- * ```
- * PathValue<{foo: {bar: string}}, 'foo.bar'> = string
- * PathValue<[number, string], '1'> = string
- * ```
- */
-export type PathValue<T, P extends Path<T> | ArrayPath<T>> = T extends any ? P extends `${infer K}.${infer R}` ? K extends keyof T ? R extends Path<T[K]> ? PathValue<T[K], R> : never : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValue<V, R & Path<V>> : never : never : P extends keyof T ? T[P] : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V : never : never : never;
-/**
- * See {@link PathValue}
- */
-export type FieldPathValue<TFieldValues extends FieldValues, TFieldPath extends FieldPath<TFieldValues>> = PathValue<TFieldValues, TFieldPath>;
-/**
- * See {@link PathValue}
- */
-export type FieldArrayPathValue<TFieldValues extends FieldValues, TFieldArrayPath extends FieldArrayPath<TFieldValues>> = PathValue<TFieldValues, TFieldArrayPath>;
-/**
- * Type to evaluate the type which the given paths point to.
- * @typeParam TFieldValues - field values which are indexed by the paths
- * @typeParam TPath        - paths into the deeply nested field values
- * @example
- * ```
- * FieldPathValues<{foo: {bar: string}}, ['foo', 'foo.bar']>
- *   = [{bar: string}, string]
- * ```
- */
-export type FieldPathValues<TFieldValues extends FieldValues, TPath extends FieldPath<TFieldValues>[] | readonly FieldPath<TFieldValues>[]> = {} & {
-    [K in keyof TPath]: FieldPathValue<TFieldValues, TPath[K] & FieldPath<TFieldValues>>;
-};
-/**
- * Type which eagerly collects all paths through a fieldType that matches a give type
- * @typeParam TFieldValues - field values which are indexed by the paths
- * @typeParam TValue       - the value you want to match into each type
- * @example
- * ```typescript
- * FieldPathByValue<{foo: {bar: number}, baz: number, bar: string}, number>
- *   = 'foo.bar' | 'baz'
- * ```
- */
-export type FieldPathByValue<TFieldValues extends FieldValues, TValue> = {
-    [Key in FieldPath<TFieldValues>]: FieldPathValue<TFieldValues, Key> extends TValue ? Key : never;
-}[FieldPath<TFieldValues>];
-export {};
+import { FieldValues } from '../fields';
+import { BrowserNativeObject, IsAny, IsEqual, Primitive } from '../utils';
+import { ArrayKey, IsTuple, TupleKeys } from './common';
+/**
+ * Helper function to break apart T1 and check if any are equal to T2
+ *
+ * See {@link IsEqual}
+ */
+type AnyIsEqual<T1, T2> = T1 extends T2 ? IsEqual<T1, T2> extends true ? true : never : never;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This actually constructs the strings and recurses into nested
+ * object types.
+ *
+ * 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>}`;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This obscures the internal type param TraversedTypes from exported 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 which eagerly collects all paths through a type
+ * @typeParam T - type which should be introspected
+ * @example
+ * ```
+ * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
+ * ```
+ */
+export type Path<T> = T extends any ? PathInternal<T> : never;
+/**
+ * See {@link Path}
+ */
+export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This actually constructs the strings and recurses into nested
+ * object types.
+ *
+ * See {@link ArrayPath}
+ */
+type ArrayPathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : V extends ReadonlyArray<infer U> ? U extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}` | `${K}.${ArrayPathInternal<V, TraversedTypes | V>}` : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}.${ArrayPathInternal<V, TraversedTypes | V>}`;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This obscures the internal type param TraversedTypes from exported contract.
+ *
+ * See {@link ArrayPath}
+ */
+type ArrayPathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
+}[TupleKeys<T>] : ArrayPathImpl<ArrayKey, V, TraversedTypes> : {
+    [K in keyof T]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
+}[keyof T];
+/**
+ * Type which eagerly collects all paths through a type which point to an array
+ * type.
+ * @typeParam T - type which should be introspected.
+ * @example
+ * ```
+ * Path<{foo: {bar: string[], baz: number[]}}> = 'foo.bar' | 'foo.baz'
+ * ```
+ */
+export type ArrayPath<T> = T extends any ? ArrayPathInternal<T> : never;
+/**
+ * See {@link ArrayPath}
+ */
+export type FieldArrayPath<TFieldValues extends FieldValues> = ArrayPath<TFieldValues>;
+/**
+ * Type to evaluate the type which the given path points to.
+ * @typeParam T - deeply nested type which is indexed by the path
+ * @typeParam P - path into the deeply nested type
+ * @example
+ * ```
+ * PathValue<{foo: {bar: string}}, 'foo.bar'> = string
+ * PathValue<[number, string], '1'> = string
+ * ```
+ */
+export type PathValue<T, P extends Path<T> | ArrayPath<T>> = T extends any ? P extends `${infer K}.${infer R}` ? K extends keyof T ? R extends Path<T[K]> ? PathValue<T[K], R> : never : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValue<V, R & Path<V>> : never : never : P extends keyof T ? T[P] : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V : never : never : never;
+/**
+ * See {@link PathValue}
+ */
+export type FieldPathValue<TFieldValues extends FieldValues, TFieldPath extends FieldPath<TFieldValues>> = PathValue<TFieldValues, TFieldPath>;
+/**
+ * See {@link PathValue}
+ */
+export type FieldArrayPathValue<TFieldValues extends FieldValues, TFieldArrayPath extends FieldArrayPath<TFieldValues>> = PathValue<TFieldValues, TFieldArrayPath>;
+/**
+ * Type to evaluate the type which the given paths point to.
+ * @typeParam TFieldValues - field values which are indexed by the paths
+ * @typeParam TPath        - paths into the deeply nested field values
+ * @example
+ * ```
+ * FieldPathValues<{foo: {bar: string}}, ['foo', 'foo.bar']>
+ *   = [{bar: string}, string]
+ * ```
+ */
+export type FieldPathValues<TFieldValues extends FieldValues, TPath extends FieldPath<TFieldValues>[] | readonly FieldPath<TFieldValues>[]> = {} & {
+    [K in keyof TPath]: FieldPathValue<TFieldValues, TPath[K] & FieldPath<TFieldValues>>;
+};
+/**
+ * Type which eagerly collects all paths through a fieldType that matches a give type
+ * @typeParam TFieldValues - field values which are indexed by the paths
+ * @typeParam TValue       - the value you want to match into each type
+ * @example
+ * ```typescript
+ * FieldPathByValue<{foo: {bar: number}, baz: number, bar: string}, number>
+ *   = 'foo.bar' | 'baz'
+ * ```
+ */
+export type FieldPathByValue<TFieldValues extends FieldValues, TValue> = {
+    [Key in FieldPath<TFieldValues>]: FieldPathValue<TFieldValues, Key> extends TValue ? Key : never;
+}[FieldPath<TFieldValues>];
+export {};
 //# sourceMappingURL=eager.d.ts.map

package/dist/types/path/index.d.ts

@@ -1,4 +1,4 @@
-/** Re-export public API */
-export { PathString } from './common';
-export { ArrayPath, FieldArrayPath, FieldArrayPathValue, FieldPath, FieldPathByValue, FieldPathValue, FieldPathValues, Path, PathValue, } from './eager';
+/** Re-export public API */
+export { PathString } from './common';
+export { ArrayPath, FieldArrayPath, FieldArrayPathValue, FieldPath, FieldPathByValue, FieldPathValue, FieldPathValues, Path, PathValue, } from './eager';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/resolvers.d.ts

@@ -1,20 +1,20 @@
-import { FieldErrors } from './errors';
-import { Field, FieldName, FieldValues, InternalFieldName } from './fields';
-import { CriteriaMode } from './form';
-export type ResolverSuccess<TFieldValues extends FieldValues = FieldValues> = {
-    values: TFieldValues;
-    errors: {};
-};
-export type ResolverError<TFieldValues extends FieldValues = FieldValues> = {
-    values: {};
-    errors: FieldErrors<TFieldValues>;
-};
-export type ResolverResult<TFieldValues extends FieldValues = FieldValues> = ResolverSuccess<TFieldValues> | ResolverError<TFieldValues>;
-export interface ResolverOptions<TFieldValues extends FieldValues> {
-    criteriaMode?: CriteriaMode;
-    fields: Record<InternalFieldName, Field['_f']>;
-    names?: FieldName<TFieldValues>[];
-    shouldUseNativeValidation: boolean | undefined;
-}
-export type Resolver<TFieldValues extends FieldValues = FieldValues, TContext = any> = (values: TFieldValues, context: TContext | undefined, options: ResolverOptions<TFieldValues>) => Promise<ResolverResult<TFieldValues>> | ResolverResult<TFieldValues>;
+import { FieldErrors } from './errors';
+import { Field, FieldName, FieldValues, InternalFieldName } from './fields';
+import { CriteriaMode } from './form';
+export type ResolverSuccess<TFieldValues extends FieldValues = FieldValues> = {
+    values: TFieldValues;
+    errors: {};
+};
+export type ResolverError<TFieldValues extends FieldValues = FieldValues> = {
+    values: {};
+    errors: FieldErrors<TFieldValues>;
+};
+export type ResolverResult<TFieldValues extends FieldValues = FieldValues> = ResolverSuccess<TFieldValues> | ResolverError<TFieldValues>;
+export interface ResolverOptions<TFieldValues extends FieldValues> {
+    criteriaMode?: CriteriaMode;
+    fields: Record<InternalFieldName, Field['_f']>;
+    names?: FieldName<TFieldValues>[];
+    shouldUseNativeValidation: boolean | undefined;
+}
+export type Resolver<TFieldValues extends FieldValues = FieldValues, TContext = any> = (values: TFieldValues, context: TContext | undefined, options: ResolverOptions<TFieldValues>) => Promise<ResolverResult<TFieldValues>> | ResolverResult<TFieldValues>;
 //# sourceMappingURL=resolvers.d.ts.map

package/dist/types/utils.d.ts

@@ -1,71 +1,71 @@
-import { NestedValue } from './form';
-export type Noop = () => void;
-interface File extends Blob {
-    readonly lastModified: number;
-    readonly name: string;
-}
-interface FileList {
-    readonly length: number;
-    item(index: number): File | null;
-    [index: number]: File;
-}
-export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-export type BrowserNativeObject = Date | FileList | File;
-export type EmptyObject = {
-    [K in string | number]: never;
-};
-export type NonUndefined<T> = T extends undefined ? never : T;
-export type LiteralUnion<T extends U, U extends Primitive> = T | (U & {
-    _?: never;
-});
-export type DeepPartial<T> = T extends BrowserNativeObject | NestedValue ? T : {
-    [K in keyof T]?: DeepPartial<T[K]>;
-};
-export type DeepPartialSkipArrayKey<T> = T extends BrowserNativeObject | NestedValue ? T : T extends ReadonlyArray<any> ? {
-    [K in keyof T]: DeepPartialSkipArrayKey<T[K]>;
-} : {
-    [K in keyof T]?: DeepPartialSkipArrayKey<T[K]>;
-};
-/**
- * Checks whether the type is any
- * See {@link https://stackoverflow.com/a/49928360/3406963}
- * @typeParam T - type which may be any
- * ```
- * IsAny<any> = true
- * IsAny<string> = false
- * ```
- */
-export type IsAny<T> = 0 extends 1 & T ? true : false;
-/**
- * Checks whether the type is never
- * @typeParam T - type which may be never
- * ```
- * IsAny<never> = true
- * IsAny<string> = false
- * ```
- */
-export type IsNever<T> = [T] extends [never] ? true : false;
-/**
- * Checks whether T1 can be exactly (mutually) assigned to T2
- * @typeParam T1 - type to check
- * @typeParam T2 - type to check against
- * ```
- * IsEqual<string, string> = true
- * IsEqual<'foo', 'foo'> = true
- * IsEqual<string, number> = false
- * IsEqual<string, number> = false
- * IsEqual<string, 'foo'> = false
- * IsEqual<'foo', string> = false
- * IsEqual<'foo' | 'bar', 'foo'> = boolean // 'foo' is assignable, but 'bar' is not (true | false) -> boolean
- * ```
- */
-export type IsEqual<T1, T2> = T1 extends T2 ? (<G>() => G extends T1 ? 1 : 2) extends <G>() => G extends T2 ? 1 : 2 ? true : false : false;
-export type DeepMap<T, TValue> = IsAny<T> extends true ? any : T extends BrowserNativeObject | NestedValue ? TValue : T extends object ? {
-    [K in keyof T]: DeepMap<NonUndefined<T[K]>, TValue>;
-} : TValue;
-export type IsFlatObject<T extends object> = Extract<Exclude<T[keyof T], NestedValue | Date | FileList>, any[] | object> extends never ? true : false;
-export type Merge<A, B> = {
-    [K in keyof A | keyof B]?: K extends keyof A & keyof B ? [A[K], B[K]] extends [object, object] ? Merge<A[K], B[K]> : A[K] | B[K] : K extends keyof A ? A[K] : K extends keyof B ? B[K] : never;
-};
-export {};
+import { NestedValue } from './form';
+export type Noop = () => void;
+interface File extends Blob {
+    readonly lastModified: number;
+    readonly name: string;
+}
+interface FileList {
+    readonly length: number;
+    item(index: number): File | null;
+    [index: number]: File;
+}
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+export type BrowserNativeObject = Date | FileList | File;
+export type EmptyObject = {
+    [K in string | number]: never;
+};
+export type NonUndefined<T> = T extends undefined ? never : T;
+export type LiteralUnion<T extends U, U extends Primitive> = T | (U & {
+    _?: never;
+});
+export type DeepPartial<T> = T extends BrowserNativeObject | NestedValue ? T : {
+    [K in keyof T]?: DeepPartial<T[K]>;
+};
+export type DeepPartialSkipArrayKey<T> = T extends BrowserNativeObject | NestedValue ? T : T extends ReadonlyArray<any> ? {
+    [K in keyof T]: DeepPartialSkipArrayKey<T[K]>;
+} : {
+    [K in keyof T]?: DeepPartialSkipArrayKey<T[K]>;
+};
+/**
+ * Checks whether the type is any
+ * See {@link https://stackoverflow.com/a/49928360/3406963}
+ * @typeParam T - type which may be any
+ * ```
+ * IsAny<any> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Checks whether the type is never
+ * @typeParam T - type which may be never
+ * ```
+ * IsAny<never> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Checks whether T1 can be exactly (mutually) assigned to T2
+ * @typeParam T1 - type to check
+ * @typeParam T2 - type to check against
+ * ```
+ * IsEqual<string, string> = true
+ * IsEqual<'foo', 'foo'> = true
+ * IsEqual<string, number> = false
+ * IsEqual<string, number> = false
+ * IsEqual<string, 'foo'> = false
+ * IsEqual<'foo', string> = false
+ * IsEqual<'foo' | 'bar', 'foo'> = boolean // 'foo' is assignable, but 'bar' is not (true | false) -> boolean
+ * ```
+ */
+export type IsEqual<T1, T2> = T1 extends T2 ? (<G>() => G extends T1 ? 1 : 2) extends <G>() => G extends T2 ? 1 : 2 ? true : false : false;
+export type DeepMap<T, TValue> = IsAny<T> extends true ? any : T extends BrowserNativeObject | NestedValue ? TValue : T extends object ? {
+    [K in keyof T]: DeepMap<NonUndefined<T[K]>, TValue>;
+} : TValue;
+export type IsFlatObject<T extends object> = Extract<Exclude<T[keyof T], NestedValue | Date | FileList>, any[] | object> extends never ? true : false;
+export type Merge<A, B> = {
+    [K in keyof A | keyof B]?: K extends keyof A & keyof B ? [A[K], B[K]] extends [object, object] ? Merge<A[K], B[K]> : A[K] | B[K] : K extends keyof A ? A[K] : K extends keyof B ? B[K] : never;
+};
+export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/types/validator.d.ts

@@ -1,39 +1,39 @@
-import { Message } from './errors';
-import { FieldValues, InternalFieldName } from './fields';
-import { FieldPath, FieldPathValue } from './path';
-export type ValidationValue = boolean | number | string | RegExp;
-export type ValidationRule<TValidationValue extends ValidationValue = ValidationValue> = TValidationValue | ValidationValueMessage<TValidationValue>;
-export type ValidationValueMessage<TValidationValue extends ValidationValue = ValidationValue> = {
-    value: TValidationValue;
-    message: Message;
-};
-export type ValidateResult = Message | Message[] | boolean | undefined;
-export type Validate<TFieldValue, TFormValues> = (value: TFieldValue, formValues: TFormValues) => ValidateResult | Promise<ValidateResult>;
-export type RegisterOptions<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Partial<{
-    required: Message | ValidationRule<boolean>;
-    min: ValidationRule<number | string>;
-    max: ValidationRule<number | string>;
-    maxLength: ValidationRule<number>;
-    minLength: ValidationRule<number>;
-    validate: Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues> | Record<string, Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues>>;
-    value: FieldPathValue<TFieldValues, TFieldName>;
-    setValueAs: (value: any) => any;
-    shouldUnregister?: boolean;
-    onChange?: (event: any) => void;
-    onBlur?: (event: any) => void;
-    disabled: boolean;
-    deps: InternalFieldName | InternalFieldName[];
-}> & ({
-    pattern?: ValidationRule<RegExp>;
-    valueAsNumber?: false;
-    valueAsDate?: false;
-} | {
-    pattern?: undefined;
-    valueAsNumber?: false;
-    valueAsDate?: true;
-} | {
-    pattern?: undefined;
-    valueAsNumber?: true;
-    valueAsDate?: false;
-});
+import { Message } from './errors';
+import { FieldValues, InternalFieldName } from './fields';
+import { FieldPath, FieldPathValue } from './path';
+export type ValidationValue = boolean | number | string | RegExp;
+export type ValidationRule<TValidationValue extends ValidationValue = ValidationValue> = TValidationValue | ValidationValueMessage<TValidationValue>;
+export type ValidationValueMessage<TValidationValue extends ValidationValue = ValidationValue> = {
+    value: TValidationValue;
+    message: Message;
+};
+export type ValidateResult = Message | Message[] | boolean | undefined;
+export type Validate<TFieldValue, TFormValues> = (value: TFieldValue, formValues: TFormValues) => ValidateResult | Promise<ValidateResult>;
+export type RegisterOptions<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Partial<{
+    required: Message | ValidationRule<boolean>;
+    min: ValidationRule<number | string>;
+    max: ValidationRule<number | string>;
+    maxLength: ValidationRule<number>;
+    minLength: ValidationRule<number>;
+    validate: Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues> | Record<string, Validate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues>>;
+    value: FieldPathValue<TFieldValues, TFieldName>;
+    setValueAs: (value: any) => any;
+    shouldUnregister?: boolean;
+    onChange?: (event: any) => void;
+    onBlur?: (event: any) => void;
+    disabled: boolean;
+    deps: InternalFieldName | InternalFieldName[];
+}> & ({
+    pattern?: ValidationRule<RegExp>;
+    valueAsNumber?: false;
+    valueAsDate?: false;
+} | {
+    pattern?: undefined;
+    valueAsNumber?: false;
+    valueAsDate?: true;
+} | {
+    pattern?: undefined;
+    valueAsNumber?: true;
+    valueAsDate?: false;
+});
 //# sourceMappingURL=validator.d.ts.map

package/dist/useController.d.ts

@@ -1,27 +1,27 @@
-import { FieldPath, FieldValues, UseControllerProps, UseControllerReturn } from './types';
-/**
- * Custom hook to work with controlled component, this function provide you with both form and field level state. Re-render is isolated at the hook level.
- *
- * @remarks
- * [API](https://react-hook-form.com/api/usecontroller) • [Demo](https://codesandbox.io/s/usecontroller-0o8px)
- *
- * @param props - the path name to the form field value, and validation rules.
- *
- * @returns field properties, field and form state. {@link UseControllerReturn}
- *
- * @example
- * ```tsx
- * function Input(props) {
- *   const { field, fieldState, formState } = useController(props);
- *   return (
- *     <div>
- *       <input {...field} placeholder={props.name} />
- *       <p>{fieldState.isTouched && "Touched"}</p>
- *       <p>{formState.isSubmitted ? "submitted" : ""}</p>
- *     </div>
- *   );
- * }
- * ```
- */
-export declare function useController<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: UseControllerProps<TFieldValues, TName>): UseControllerReturn<TFieldValues, TName>;
+import { FieldPath, FieldValues, UseControllerProps, UseControllerReturn } from './types';
+/**
+ * Custom hook to work with controlled component, this function provide you with both form and field level state. Re-render is isolated at the hook level.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/api/usecontroller) • [Demo](https://codesandbox.io/s/usecontroller-0o8px)
+ *
+ * @param props - the path name to the form field value, and validation rules.
+ *
+ * @returns field properties, field and form state. {@link UseControllerReturn}
+ *
+ * @example
+ * ```tsx
+ * function Input(props) {
+ *   const { field, fieldState, formState } = useController(props);
+ *   return (
+ *     <div>
+ *       <input {...field} placeholder={props.name} />
+ *       <p>{fieldState.isTouched && "Touched"}</p>
+ *       <p>{formState.isSubmitted ? "submitted" : ""}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useController<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: UseControllerProps<TFieldValues, TName>): UseControllerReturn<TFieldValues, TName>;
 //# sourceMappingURL=useController.d.ts.map

package/dist/useFieldArray.d.ts

@@ -1,40 +1,40 @@
-import { FieldArrayPath, FieldValues, UseFieldArrayProps, UseFieldArrayReturn } from './types';
-/**
- * A custom hook that exposes convenient methods to perform operations with a list of dynamic inputs that need to be appended, updated, removed etc. • [Demo](https://codesandbox.io/s/react-hook-form-usefieldarray-ssugn) • [Video](https://youtu.be/4MrbfGSFY2A)
- *
- * @remarks
- * [API](https://react-hook-form.com/api/usefieldarray) • [Demo](https://codesandbox.io/s/react-hook-form-usefieldarray-ssugn)
- *
- * @param props - useFieldArray props
- *
- * @returns methods - functions to manipulate with the Field Arrays (dynamic inputs) {@link UseFieldArrayReturn}
- *
- * @example
- * ```tsx
- * function App() {
- *   const { register, control, handleSubmit, reset, trigger, setError } = useForm({
- *     defaultValues: {
- *       test: []
- *     }
- *   });
- *   const { fields, append } = useFieldArray({
- *     control,
- *     name: "test"
- *   });
- *
- *   return (
- *     <form onSubmit={handleSubmit(data => console.log(data))}>
- *       {fields.map((item, index) => (
- *          <input key={item.id} {...register(`test.${index}.firstName`)}  />
- *       ))}
- *       <button type="button" onClick={() => append({ firstName: "bill" })}>
- *         append
- *       </button>
- *       <input type="submit" />
- *     </form>
- *   );
- * }
- * ```
- */
-export declare function useFieldArray<TFieldValues extends FieldValues = FieldValues, TFieldArrayName extends FieldArrayPath<TFieldValues> = FieldArrayPath<TFieldValues>, TKeyName extends string = 'id'>(props: UseFieldArrayProps<TFieldValues, TFieldArrayName, TKeyName>): UseFieldArrayReturn<TFieldValues, TFieldArrayName, TKeyName>;
+import { FieldArrayPath, FieldValues, UseFieldArrayProps, UseFieldArrayReturn } from './types';
+/**
+ * A custom hook that exposes convenient methods to perform operations with a list of dynamic inputs that need to be appended, updated, removed etc. • [Demo](https://codesandbox.io/s/react-hook-form-usefieldarray-ssugn) • [Video](https://youtu.be/4MrbfGSFY2A)
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/api/usefieldarray) • [Demo](https://codesandbox.io/s/react-hook-form-usefieldarray-ssugn)
+ *
+ * @param props - useFieldArray props
+ *
+ * @returns methods - functions to manipulate with the Field Arrays (dynamic inputs) {@link UseFieldArrayReturn}
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { register, control, handleSubmit, reset, trigger, setError } = useForm({
+ *     defaultValues: {
+ *       test: []
+ *     }
+ *   });
+ *   const { fields, append } = useFieldArray({
+ *     control,
+ *     name: "test"
+ *   });
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit(data => console.log(data))}>
+ *       {fields.map((item, index) => (
+ *          <input key={item.id} {...register(`test.${index}.firstName`)}  />
+ *       ))}
+ *       <button type="button" onClick={() => append({ firstName: "bill" })}>
+ *         append
+ *       </button>
+ *       <input type="submit" />
+ *     </form>
+ *   );
+ * }
+ * ```
+ */
+export declare function useFieldArray<TFieldValues extends FieldValues = FieldValues, TFieldArrayName extends FieldArrayPath<TFieldValues> = FieldArrayPath<TFieldValues>, TKeyName extends string = 'id'>(props: UseFieldArrayProps<TFieldValues, TFieldArrayName, TKeyName>): UseFieldArrayReturn<TFieldValues, TFieldArrayName, TKeyName>;
 //# sourceMappingURL=useFieldArray.d.ts.map