TypeScript TS2345: Argument of type 'X' is not assignable to parameter of type 'Y'

What causes this error

TS2345 fires at function call sites when the type of an argument expression is not assignable to the type declared for the corresponding parameter. TypeScript performs the same structural assignability check as TS2322, but TS2345 specifically targets call expressions. The error names both the argument type and the expected parameter type.

How to fix it

1. 01

   step 1

   Read the error message to identify the mismatch

   The error states the argument type and the expected parameter type. For object types, it may include a nested 'Types of property X are incompatible' chain that points directly at the diverging property.

   Argument of type '{ id: number; }' is not assignable to parameter of type 'User'.
     Property 'name' is missing in type '{ id: number; }' but required in type 'User'.

   Copy
2. 02

   step 2

   Narrow union types before passing

   The most common TS2345 trigger is passing a value that includes null or undefined to a function that expects a non-nullable type. Narrow with an if-check, nullish coalescing, or a non-null assertion (use sparingly).

   function process(id: number) { /* ... */ }
   
   const userId: number | null = getCurrentUser()?.id ?? null
   
   // TS2345: 'number | null' not assignable to 'number'
   process(userId)
   
   // Fix 1: guard
   if (userId !== null) {
     process(userId)  // userId is number
   }
   
   // Fix 2: default
   process(userId ?? 0)

   Copy
3. 03

   step 3

   Check callback parameter types

   Array methods like map, filter, and reduce expect callbacks with specific signatures. Passing a function with incompatible parameter or return types triggers TS2345.

   // TS2345: Argument of type '(x: string) => string' is not
   // assignable to parameter of type '(value: number) => string'
   const nums = [1, 2, 3]
   nums.map((x: string) => x.toUpperCase())
   
   // Fix: match the array's element type
   nums.map((x: number) => String(x))

   Copy
4. 04

   step 4

   Handle generic type parameter mismatches

   Generic functions infer type parameters from arguments. If two arguments constrain the same type parameter differently, TypeScript can't unify them and emits TS2345. Explicitly specify the type parameter or widen one argument.

   function merge<T>(a: T, b: T): T { return { ...a, ...b } }
   
   // TS2345: Argument of type '{ y: number }' not assignable
   // to parameter of type '{ x: number }'
   merge({ x: 1 }, { y: 2 })
   
   // Fix: explicit type parameter
   merge<{ x?: number; y?: number }>({ x: 1 }, { y: 2 })

   Copy
5. 05

   step 5

   Validate external data before passing to typed functions

   Data from JSON.parse, fetch responses, or form inputs is typically unknown or any. Validate it with a runtime check or schema library before passing to functions with strict parameter types.

   import { z } from 'zod'
   
   const UserSchema = z.object({ id: z.number(), name: z.string() })
   type User = z.infer<typeof UserSchema>
   
   function saveUser(user: User) { /* ... */ }
   
   const raw: unknown = await response.json()
   const user = UserSchema.parse(raw)  // throws if invalid
   saveUser(user)  // OK: user is User

   Copy

How to verify the fix

• Run tsc --noEmit and confirm TS2345 no longer appears
• Check that narrowed branches handle the null/undefined case correctly
• Verify callback return types match what the calling method expects