How to fix Type parameter 'X' is defined but never used in TypeScript

Look at the error message to see which type parameter is flagged as unused. Check your function, class, or interface declaration:

// Error: Type parameter 'T' is defined but never used
function processData<T>(id: number): void {
  console.log(id);
}

The type parameter T is declared but not referenced in the parameter list, return type, or function body.

Ask yourself: Does this function or class need to be generic? If the type parameter was meant to be used, add it to your signature:

// Fix: Use the type parameter
function processData<T>(data: T): T {
  console.log(data);
  return data;
}

// Or in the return type
function createArray<T>(): T[] {
  return [];
}

If you don't need it at all, the next step shows how to remove it.

If the generic isn't needed, simply remove it from the declaration:

// Before
function processData<T>(id: number): void {
  console.log(id);
}

// After - no generic needed
function processData(id: number): void {
  console.log(id);
}

This is the cleanest solution when the type parameter serves no purpose.

For phantom type parameters that you need to keep for type-level reasons (like type branding or constraint enforcement), prefix the name with an underscore:

// Phantom type parameter for type branding
function createBranded<_Brand>(value: string): string & { __brand: _Brand } {
  return value as string & { __brand: _Brand };
}

// Or when implementing an interface that requires the generic
interface Handler<T> {
  handle(event: unknown): void;
}

// Implementation doesn't use T but must match interface
class MyHandler<_T> implements Handler<_T> {
  handle(event: unknown): void {
    console.log('handled');
  }
}

The underscore prefix tells TypeScript and ESLint to ignore this parameter.

If you have many intentionally unused type parameters, configure your ESLint rule to ignore them:

// .eslintrc.json
{
  "rules": {
    "@typescript-eslint/no-unused-vars": [
      "error",
      {
        "argsIgnorePattern": "^_",
        "varsIgnorePattern": "^_"
      }
    ]
  }
}

This allows any parameter or variable starting with underscore to be unused without triggering errors.

For projects where this check is too strict, you can disable it in your TypeScript configuration:

// tsconfig.json
{
  "compilerOptions": {
    "noUnusedParameters": false,
    "noUnusedLocals": false
  }
}

However, this is not recommended as it reduces type safety. Only use this as a last resort, and prefer using ESLint rules for more granular control.