How to fix Type parameter 'X' is not used in the function signature in TypeScript

Examine your function signature to see if the type parameter appears in:
- Parameter types
- Return type
- Type constraints

Example of unused type parameter:

function example<T>(): void {
  // T is declared but never used in signature
}

The type parameter T is declared but doesn't appear in the function parameters or return type, making it useless.

If the type parameter doesn't relate types in your function, simply remove it:

Before:

function doSomething<T>(message: string): void {
  console.log(message);
}

After:

function doSomething(message: string): void {
  console.log(message);
}

This is the cleanest solution when the generic provides no value.

If you need the generic behavior, ensure the type parameter relates at least two values:

Before (incorrect):

function identity<T>(): string {
  return "something";
}

After (correct):

function identity<T>(value: T): T {
  return value;
}

Now T relates the input type to the output type, providing real type safety.

If you're using the generic just to force a specific type, use explicit types instead:

Before (bad pattern):

function getData<T>(): T {
  return JSON.parse(data) as T;
}
const user = getData<User>();

After (better):

function getData(): unknown {
  return JSON.parse(data);
}
const user = getData() as User;

Or even better, use proper type guards or validation.

If you need to constrain what can be passed to a function, ensure the type parameter is used:

Correct usage:

function processArray<T extends string | number>(items: T[]): T[] {
  return items.filter(item => item !== null);
}

Here T is used in both the parameter type and return type, creating a proper relationship.

Add the @typescript-eslint/no-unnecessary-type-parameters rule to your ESLint configuration:

{
  "rules": {
    "@typescript-eslint/no-unnecessary-type-parameters": "error"
  }
}

This will automatically flag unused type parameters during development, helping you maintain cleaner code.