feat: implement typed Input/Output interface for resolvers

README.md

@@ -55,6 +55,41 @@ Install your preferred validation library alongside `@hookform/resolvers`.
 | zod  | ✅ | `firstError | all` |
 </details>
 
+## TypeScript
+
+Most of the resolvers can infer the output type from the schema. See comparison table for more details.
+
+```tsx
+useForm<Input, Context, Output>()
+```
+
+Example:
+
+```tsx
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { z } from 'zod';
+
+const schema = z.object({
+  id: z.number(),
+});
+
+// Automatically infers the output type from the schema
+useForm({
+  resolver: zodResolver(schema),
+});
+
+// Different input type
+useForm<{ id: string }>({
+  resolver: zodResolver(schema),
+});
+
+// Force the output type
+useForm<z.input<typeof schema>, any, { id: boolean }>({
+  resolver: zodResolver(schema),
+});
+```
+
 ## Links
 
 - [React-hook-form validation resolver documentation ](https://react-hook-form.com/docs/useform#resolver)

zod/src/__tests__/zod.ts

@@ -1,3 +1,5 @@
+import { FieldValues, Resolver, SubmitHandler, useForm } from 'react-hook-form';
+import { z } from 'zod';
 import { zodResolver } from '..';
 import { fields, invalidData, schema, validData } from './__fixtures__/data';
 
@@ -89,4 +91,74 @@ describe('zodResolver', () => {
 
     await expect(promise).rejects.toThrow('custom error');
   });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a zod schema', () => {
+    const resolver = zodResolver(z.object({ id: z.number() }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<FieldValues, unknown, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a zod schema when a different input type is specified', () => {
+    const schema = z.object({ id: z.number() });
+    const resolver = zodResolver<{ id: string }, any, z.output<typeof schema>>(
+      schema,
+    );
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: string }, any, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a zod schema when different input and output types are specified', () => {
+    const resolver = zodResolver<
+      { id: string },
+      { context: any },
+      { id: number }
+    >(z.object({ id: z.number() }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: string }, { context: any }, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a Zod schema for the handleSubmit function in useForm', () => {
+    const { handleSubmit } = useForm({
+      resolver: zodResolver(z.object({ id: z.number() })),
+    });
+
+    expectTypeOf(handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: number;
+      }>
+    >();
+  });
+
+  it('should correctly infer the output type from a Zod schema when a different input type is specified for the handleSubmit function in useForm', () => {
+    const { handleSubmit } = useForm<{ id: number }>({
+      resolver: zodResolver(z.object({ id: z.string() })),
+    });
+
+    expectTypeOf(handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: string;
+      }>
+    >();
+  });
+
+  it('should correctly infer the output type from a Zod schema when different input and output types are specified for the handleSubmit function in useForm', () => {
+    const { handleSubmit } = useForm<{ id: string }, any, { id: boolean }>({
+      resolver: zodResolver(z.object({ id: z.number() })),
+    });
+
+    expectTypeOf(handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: boolean;
+      }>
+    >();
+  });
 });

zod/src/zod.ts

@@ -63,12 +63,12 @@ function parseErrorSchema(
 
 /**
  * Creates a resolver function for react-hook-form that validates form data using a Zod schema
- * @param {z.ZodSchema<TFieldValues>} schema - The Zod schema used to validate the form data
+ * @param {z.ZodSchema<Input>} schema - The Zod schema used to validate the form data
  * @param {Partial<z.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing
  * @param {Object} [resolverOptions] - Optional resolver-specific configuration
  * @param {('async'|'sync')} [resolverOptions.mode='async'] - Validation mode. Use 'sync' for synchronous validation
  * @param {boolean} [resolverOptions.raw=false] - If true, returns the raw form values instead of the parsed data
- * @returns {Resolver<z.infer<typeof schema>>} A resolver function compatible with react-hook-form
+ * @returns {Resolver<z.ouput<typeof schema>>} A resolver function compatible with react-hook-form
  * @throws {Error} Throws if validation fails with a non-Zod error
  * @example
  * const schema = z.object({
@@ -80,14 +80,27 @@ function parseErrorSchema(
  *   resolver: zodResolver(schema)
  * });
  */
-export function zodResolver<TFieldValues extends FieldValues>(
-  schema: z.ZodSchema<TFieldValues, any, any>,
+export function zodResolver<
+  Input extends FieldValues,
+  Context,
+  Output,
+  Schema extends z.ZodSchema<Output, any, any> = z.ZodSchema<Output, any, any>,
+>(
+  schema: Schema,
   schemaOptions?: Partial<z.ParseParams>,
   resolverOptions: {
     mode?: 'async' | 'sync';
     raw?: boolean;
   } = {},
-): Resolver<z.infer<typeof schema>> {
+): Resolver<
+  Input,
+  Context,
+  (typeof resolverOptions)['raw'] extends true
+    ? Input
+    : unknown extends Output
+      ? z.output<Schema>
+      : Output
+> {
   return async (values, _, options) => {
     try {
       const data = await schema[