Conversion of type 'X' to type 'Y' may be a mistake

Option 1: Double assertion via 'unknown' (escape hatch)

// Force any cast by going through 'unknown' first
const str = (num as unknown) as string;
// Use only when you know what you're doing — no type safety

Option 2: Fix the actual type mismatch instead of casting

// Convert the value properly
const str = String(num); // number → string
const strNum = parseInt(str, 10); // string → number

Option 3: Add shared structure to allow the cast

interface Animal { name: string }
interface Cat extends Animal { meow(): void }
interface Dog extends Animal { bark(): void }
// Now Cat and Dog share 'name', so casting is less likely an error

What does TS2352 mean?

TS2352 means your type cast using 'as' looks suspicious — the two types have no overlap, so TypeScript thinks you might be making a mistake. It's a safeguard against unintentional casts.

How do I force a cast when I'm sure it's correct?

Use double assertion through unknown: (value as unknown) as TargetType. This is an escape hatch — TypeScript won't check it, so only use it when you're certain.

When is it safe to use the double assertion?

When you have external knowledge TypeScript can't verify — for example, a value from an API that you know matches the type, or when integrating with untyped JavaScript code.

TS2352 in test files — how to fix?

Common in mocks. Use jest.fn() with proper generic types, or cast through unknown for mock objects that don't fully implement an interface.

Why doesn't TypeScript allow casting between unrelated types?

TypeScript's type system is structural — if two types share no common shape, a cast between them is almost always a bug. The TS2352 error exists specifically to catch accidental as-casts.