TypeScript TS7006: Parameter 'x' implicitly has an 'any' type

What causes this error

TS7006 fires when noImplicitAny is enabled (included in strict mode) and a function parameter has no explicit type annotation and TypeScript cannot infer its type from context. Without a type annotation or contextual typing (such as when a callback is passed to a typed function), the parameter defaults to 'any'. The noImplicitAny flag turns this silent default into a compile error.

How to fix it

1. 01

   step 1

   Add an explicit type annotation

   The direct fix is to declare the parameter's type. For DOM event handlers, use the appropriate Event subtype. For Express/Koa handlers, use the framework's request/response types. For generic callbacks, determine the type from the calling code.

   // DOM events
   function handleSubmit(event: SubmitEvent) { /* ... */ }
   function handleInput(event: InputEvent) { /* ... */ }
   
   // Express
   import type { Request, Response } from 'express'
   function getUsers(req: Request, res: Response) { /* ... */ }
   
   // Generic callback
   function process(item: string, index: number) { /* ... */ }

   Copy
2. 02

   step 2

   Let contextual typing infer the parameter type

   When a function is passed as a callback to a typed function, TypeScript infers parameter types from the callback signature. If TS7006 fires on a callback, the issue is usually that the parent function isn't properly typed or the callback is defined separately.

   // Inline callback — TypeScript infers 'user' as User
   const names = users.map(user => user.name)  // OK: contextual typing
   
   // Separate function — no context, TS7006 fires
   function getName(user) { return user.name }  // Error
   const names = users.map(getName)
   
   // Fix: type the standalone function
   function getName(user: User) { return user.name }  // OK

   Copy
3. 03

   step 3

   Type destructured parameters

   Destructured parameters in function signatures need the type annotation on the whole parameter object, not on individual destructured names.

   // TS7006 on destructured params
   function createUser({ name, email }) {  // Error on name and email
     return { name, email }
   }
   
   // Fix: annotate the entire parameter object
   function createUser({ name, email }: { name: string; email: string }) {
     return { name, email }
   }
   
   // Or use a named type
   interface CreateUserInput { name: string; email: string }
   function createUser({ name, email }: CreateUserInput) {
     return { name, email }
   }

   Copy
4. 04

   step 4

   Handle rest parameters and array callbacks

   Rest parameters and some callback patterns lose contextual typing. Add explicit types to restore type safety.

   // Rest params need a type
   function log(...args: unknown[]) {
     console.log(...args)
   }
   
   // reduce callback — TypeScript infers accumulator from initial value
   // but if initial value is ambiguous, annotate the callback
   const total = items.reduce(
     (sum: number, item: Item) => sum + item.price,
     0
   )

   Copy
5. 05

   step 5

   Use 'unknown' instead of 'any' for truly dynamic parameters

   If a parameter genuinely accepts any type, annotate it as unknown rather than any. This preserves type safety by requiring narrowing before use, while still accepting all input types.

   // Bad: explicit any disables all type checking
   function serialize(value: any): string {
     return JSON.stringify(value)  // no checking inside
   }
   
   // Better: unknown requires narrowing
   function serialize(value: unknown): string {
     if (typeof value === 'object' && value !== null) {
       return JSON.stringify(value)
     }
     return String(value)
   }

   Copy

How to verify the fix

• Run tsc --noEmit and confirm TS7006 no longer appears
• Check that added type annotations match the actual runtime values
• Verify no 'any' was used as a shortcut — prefer unknown for truly dynamic values