How to fix Function return type must be assignable to base class return type 'X' in TypeScript

class Animal {
  makeSound(): string {
    return "generic animal sound";
  }
}

class Dog extends Animal {
  // This must return something assignable to string
  makeSound(): string {
    return "bark";
  }
}

class Animal {}
class Dog extends Animal {}
class Car {}

class AnimalHandler {
  getAnimal(): Animal {
    return new Animal();
  }
}

class DogHandler extends AnimalHandler {
  // OK: Dog is a subtype of Animal
  getAnimal(): Dog {
    return new Dog();
  }
}

class CarHandler extends AnimalHandler {
  // ERROR: Car is not a subtype of Animal
  getAnimal(): Car {
    return new Car();
  }
}

class Base {
  getValue(): string | number {
    return "hello";
  }
}

class Sub1 extends Base {
  // OK: string is assignable to string | number
  getValue(): string {
    return "subclass value";
  }
}

class Sub2 extends Base {
  // OK: number is assignable to string | number
  getValue(): number {
    return 42;
  }
}

class Sub3 extends Base {
  // ERROR: boolean is not assignable to string | number
  getValue(): boolean {
    return true;
  }
}

class Base<T> {
  process(value: T): T {
    return value;
  }
}

class Sub1 extends Base<string> {
  // OK: same type parameter
  process(value: string): string {
    return value.toUpperCase();
  }
}

class Sub2 extends Base<Animal> {
  // OK: returning Dog (subtype of Animal) where Animal is expected
  process(value: Animal): Dog {
    return new Dog();
  }
}

class Sub3 extends Base<number> {
  // ERROR: string is not assignable to number
  process(value: number): string {
    return value.toString();
  }
}

interface Shape {
  area(): number;
}

class Circle implements Shape {
  radius: number;
  
  // Must return number to satisfy Shape interface
  area(): number {
    return Math.PI * this.radius * this.radius;
  }
}

// If you try to return something more specific:
class Square implements Shape {
  side: number;
  
  // ERROR: {value: number, unit: string} is not assignable to number
  area(): {value: number, unit: string} {
    return {value: this.side * this.side, unit: "cm²"};
  }
  
  // CORRECT: return number
  area(): number {
    return this.side * this.side;
  }
}

interface Repository<T> {
  findById(id: string): T | null;
}

class UserRepository implements Repository<User> {
  // OK: User | null is assignable to User | null
  findById(id: string): User | null {
    // implementation
    return null;
  }
}

class ProductRepository implements Repository<Product> {
  // ERROR: Product is not assignable to Product | null
  // (missing null in return type)
  findById(id: string): Product {
    // implementation
    return new Product();
  }
  
  // CORRECT: include null
  findById(id: string): Product | null {
    // implementation
    return new Product();
  }
}

abstract class Parser {
  abstract parse(input: string): any;
}

class JsonParser extends Parser {
  // Using overloads for more specific return types
  parse(input: string): object;
  parse(input: string): any {
    try {
      return JSON.parse(input);
    } catch {
      return null;
    }
  }
}

// The implementation returns any, which is assignable to any
// The overload provides more specific type information to callers

{
  "compilerOptions": {
    "strict": true,  // Enables strict method override checking
    "noImplicitOverride": true  // Requires explicit `override` keyword
  }
}

class Base {
  method(): string {
    return "base";
  }
}

class Derived extends Base {
  override method(): string {
    return "derived";
  }
}