Fix TypeScript TS7006: Parameter Implicitly Has Any Type (2026)

The TypeScript compiler is complaining because a function parameter doesn’t have an explicit type annotation, and it can’t infer one, meaning it defaults to any.

This happens when you declare a function like function greet(name) { ... } instead of function greet(name: string) { ... }. The compiler, by default, assumes this is an oversight and flags it as an error (TS7006) to prevent potential runtime issues.

Here’s a breakdown of the common causes and how to fix them:

1. Missing Type Annotation on a Function Parameter

This is the most straightforward and common reason. You’ve written a function that accepts an argument, but you haven’t told TypeScript what type that argument should be.

Diagnosis: Examine the function signature in your TypeScript file. Look for parameters without a colon followed by a type.

// Example of the problematic code
function processData(data) {
  console.log(data.length);
}

Fix: Add the explicit type annotation to the parameter.

// Corrected code
function processData(data: any[]) { // Or a more specific type like string[], number[], etc.
  console.log(data.length);
}

Why it works: You’re explicitly telling the TypeScript compiler the expected type of the data parameter. This allows the compiler to perform type checking on data within the function body, preventing errors like trying to access .length on a non-array type.

2. Type Inference Failure in Callback Functions

When using higher-order functions or callbacks, TypeScript might struggle to infer the types of the parameters passed to your callback if the context isn’t clear enough.

Diagnosis: Look for arrow functions or anonymous functions passed as arguments to other functions (like array methods map, filter, forEach, or event handlers).

// Example
const numbers = [1, 2, 3];
numbers.forEach(num => { // 'num' here might be inferred as 'any'
  console.log(num.toFixed(2));
});

Fix: Explicitly type the parameters of the callback function.

// Corrected code
const numbers = [1, 2, 3];
numbers.forEach((num: number) => {
  console.log(num.toFixed(2));
});

Why it works: Even though numbers is an array of numbers, the forEach method’s callback signature might not be perfectly inferred in all scenarios. Explicitly typing num as number ensures the compiler knows it can safely call .toFixed(2) on it.

3. Using any Type in Generic Functions Without Constraints

If you have a generic function that uses a type parameter T but doesn’t constrain it, and then you use that type parameter without further context, it might fall back to any.

Diagnosis: Find generic functions where the type parameter T is used directly as a parameter type without any specific constraints.

// Example
function identity<T>(arg: T): T {
  // If T isn't constrained, and arg is used in a way that doesn't
  // provide enough context for inference, it might be treated as 'any'.
  // This is less common for direct parameters but can happen in complex scenarios.
  return arg;
}

let result = identity("hello"); // Here, T is inferred as string.
let result2 = identity(123); // Here, T is inferred as number.

// The error might appear if T is used in a way that truly has no context.
function processUncertain<T>(value: T) {
  // If you did something like `console.log(value.length)` without T being constrained,
  // and T couldn't be inferred, it would be an issue.
  return value;
}

Fix: Ensure the generic type parameter T is used in a context where it can be reliably inferred, or add constraints if necessary.

// Example with a constraint
function processUncertain<T extends string | number>(value: T): T {
  if (typeof value === 'number') {
    return (value * 2) as T;
  }
  return (value.toUpperCase() + '!') as T;
}

Why it works: By constraining T to string | number, you’ve provided the compiler with a known set of types. If T is used in a way that implies string or number operations, the compiler can make a more informed decision. If the generic function is intended to be truly flexible, explicit typing on the call site is usually the solution.

4. Incorrectly Configured tsconfig.json (noImplicitAny)

The TS7006 error is directly controlled by the noImplicitAny compiler option in your tsconfig.json. If this is set to false, you wouldn’t even get this error. The error appears because noImplicitAny is true (which is the recommended setting for good TypeScript practice).

Diagnosis: Check your tsconfig.json file.

// tsconfig.json
{
  "compilerOptions": {
    "noImplicitAny": true, // This is what causes the error when types are missing
    // ... other options
  }
}

Fix: While you can set "noImplicitAny": false to suppress this error globally, this is strongly discouraged. The best fix is to go back to the individual code locations and add explicit type annotations as described in the other points. If you must suppress it for a specific file or directory, consider using ts-ignore comments sparingly, but this is generally a last resort.

Why it works: noImplicitAny: true is a safeguard. It forces you to be explicit about your types, preventing the compiler from silently treating potentially undefined or incorrectly typed variables as any. When you fix the missing types, you’re aligning your code with the intent of this compiler option.

5. Third-Party Libraries with Missing or Incorrect Type Definitions

Sometimes, the issue might stem from using a JavaScript library that either lacks TypeScript type definitions (.d.ts files) or has incomplete/incorrect ones.

Diagnosis: If the error occurs when calling functions or accessing properties from a third-party library, especially if you’ve installed its types via @types/library-name.

// Example: Using a hypothetical library 'magic-utils'
import { doSomething } from 'magic-utils';

// If doSomething is defined as `function doSomething(config)`
// and its types don't specify the type of 'config', you'll get TS7006.
doSomething({ enabled: true });

Fix:

• Install/Update Types: Ensure you have the correct type definitions installed (npm install --save-dev @types/magic-utils). Check for updates.

• Explicitly Type: If types are missing or incomplete, you might need to explicitly type the arguments you pass to the library’s functions.

  import { doSomething } from 'magic-utils';
  
  interface MagicConfig {
    enabled: boolean;
    // ... other properties
  }
  
  doSomething({ enabled: true } as MagicConfig); // Explicitly cast or type
  

• Use any Sparingly (Last Resort): If all else fails and you trust the library’s JavaScript, you might cast to any as a temporary measure, but this defeats the purpose of TypeScript.

  (doSomething as any)({ enabled: true });
  

Why it works: By providing explicit types (either via installed .d.ts files or your own interfaces), you’re giving the TypeScript compiler the information it needs to understand the library’s API, even if the library itself wasn’t written in TypeScript.

The next error you’ll likely encounter after fixing TS7006 everywhere is TS2304: Cannot find name 'X', which occurs when you reference a type or variable that hasn’t been declared or imported.