TS2416: Property 'X' in type 'Y' is not assignable to the same property in base type 'Z'

Workarounds

1. 92% success Widen the overriding member's type to be compatible with the base type using union or the base type itself

   // Before (error): method parameter is narrower than base
   class Base {
     handle(input: string | number): void { /* ... */ }
   }
   class Derived extends Base {
     handle(input: string): void { /* TS2416 */ }
   }
   
   // After: accept the full base type, narrow inside
   class Derived extends Base {
     handle(input: string | number): void {
       if (typeof input === 'string') {
         // string-specific logic
       }
     }
   }

   Sources: https://www.typescriptlang.org/docs/handbook/2/classes.html#overriding-methods

2. 88% success Use generics in the base class to allow subclasses to specialize types safely

   // Before: rigid base type
   class Base {
     data: Record<string, unknown> = {};
   }
   class Derived extends Base {
     data: { name: string; age: number } = { name: '', age: 0 }; // TS2416
   }
   
   // After: generic base allows type-safe specialization
   class Base<T extends Record<string, unknown> = Record<string, unknown>> {
     data: T;
     constructor(data: T) { this.data = data; }
   }
   class Derived extends Base<{ name: string; age: number }> {
     constructor() { super({ name: '', age: 0 }); }
   }

   Sources: https://www.typescriptlang.org/docs/handbook/2/generics.html#generic-classes

3. 80% success Use an interface with method overloads instead of class inheritance

   // Instead of class inheritance with incompatible overrides,
   // use an interface with overloaded signatures:
   interface Handler {
     handle(input: string): string;
     handle(input: number): number;
     handle(input: string | number): string | number;
   }
   
   class MyHandler implements Handler {
     handle(input: string): string;
     handle(input: number): number;
     handle(input: string | number): string | number {
       if (typeof input === 'string') return input.toUpperCase();
       return input * 2;
     }
   }

   Sources: https://www.typescriptlang.org/docs/handbook/2/functions.html#function-overloads