How to override interface in a function and maintain the correct return type?

I have a definePlugin function that accepts an object implementing the PluginConfig interface, with a default RequestValidator. I’m trying to override this interface, providing a custom validator while ensuring the returned value has the correct type. However, my current implementation results in the returned vueAuth having the type any. How do I override the interface while maintaining the correct return type?
Here’s my current code:

import { z } from 'zod'

// Create de default validator
export const EmailValidator = z.object({
  email: z
    .string({ required_error: 'auth.validation.email' })
    .email({ message: 'auth.validation.email_format' })
})

// The default interface the generic should at least implement
interface PluginConfig {
  validator?: z.ZodType
}

// The default interface with the default validator to use if not overriden
interface DefaultPluginConfig {
  validator?: typeof EmailValidator
}

const definePlugin = <T extends PluginConfig = DefaultPluginConfig>({
  validator = EmailValidator
}: T) => {
  return validator.parse({})
}

const test = definePlugin({})
// Object should look like EmailValidator but is any instead
test.email

// Create a custom validator
const CustomValidator = z.object({
  email: z.string(),
  username: z.string()
})

// Create a custom interface to use as generic
interface CustomConfig {
  validator?: typeof CustomValidator
}

const test2 = definePlugin<CustomConfig>({
  validator: CustomValidator
})
// Object should look like CustomValidator but is any instead
test2.username
test2.username

What changes should I make to ensure that definePlugin has the correct type when providing a custom validator?

There are some issues in your code which cause problem:

1. You have defined PluginConfig to property z.ZodType which is a type not a value. You can modify as:

   interface PluginConfig {
   validator?: z.Schema<any>;
   }

2. In your code your DefaultPluginConfig interface is not properly extending PluginConfig. You can change this as:

   interface DefaultPluginConfig extends PluginConfig {
   validator?: typeof EmailValidator;
   }

Your code would look like:

import { z } from 'zod';

// Create the default validator
export const EmailValidator = z.object({
  email: z
    .string({ required_error: 'auth.validation.email' })
    .email({ message: 'auth.validation.email_format' }),
});

// The default interface the generic should at least implement
interface PluginConfig {
  validator?: z.Schema<any>;
}

// The default interface with the default validator to use if not overridden
interface DefaultPluginConfig extends PluginConfig {
  validator?: typeof EmailValidator;
}

const definePlugin = <T extends PluginConfig = DefaultPluginConfig>({
  validator = EmailValidator,
}: T) => {
  return validator.parse({});
};

const test = definePlugin({});
test.email; // Object has the correct type EmailValidator

// Create a custom validator
const CustomValidator = z.object({
  email: z.string(),
  username: z.string(),
});

// Create a custom interface to use as generic
interface CustomConfig extends PluginConfig {
  validator?: typeof CustomValidator;
}

const test2 = definePlugin<CustomConfig>({
  validator: CustomValidator,
});
test2.username; // Object has the correct type CustomValidator
test2.email; // Object has the correct type CustomValidator (from CustomValidator)

Let me know if you still face any issue.

UPDATED CODE (FINAL):

As per discussion on chat the correct answer is:

import { z, ZodType } from "zod";

// Create the default validator
export const EmailValidator = z.object({
  email: z.string().default("")
});

// The default interface the generic should at least implement
interface PluginConfig<T extends ZodType = typeof EmailValidator> {
  validator?: T;
}

const definePlugin = <
  T extends PluginConfig = PluginConfig<typeof EmailValidator>,
  R = T extends PluginConfig<infer V> ? V : ZodType
>({
  validator = EmailValidator
}: T): R extends ZodType<infer P> ? P : never => {
  return validator.parse({}) as any;
};

const test = definePlugin({});
test.email; // Object has the correct type EmailValidator

const CustomValidator = z.object({
  email: z.string().default(""),
  username: z.string().default("")
});

type CustomConfig = PluginConfig<typeof CustomValidator>;

const test2 = definePlugin<CustomConfig>({
  validator: CustomValidator
});

console.log(test2.username);

So here Generic V and P are used to capture the types from PluginConfig and ZodType respectively.

Here,<br>
V - represents inferred types of validator property in PluginConfig<br>
P - represents the inferred type of the ZodType

These generics V and P allow the function to handle different validator configurations and return suitable inferred type based on it.

1. The basic solution is to z.infer

const definePlugin = <T extends PluginConfig = DefaultPluginConfig>({
  validator = EmailValidator
}: T): z.infer<NonNullable<T['validator']>> => {
  return validator.parse({})
}

This will work fine with provided generic parameter, but will fail to provide a default

2. Overloads are the best way to work with call corner cases, as they have order of inference tries. I would recommend to use them.

function definePlugin({validator}: DefaultPluginConfig): z.infer<NonNullable<DefaultPluginConfig['validator']>>;
function definePlugin<T extends PluginConfig>({validator}: T): z.infer<NonNullable<T['validator']>>;
function definePlugin({validator = EmailValidator}: PluginConfig) {
  return validator.parse({})
}