How to fix Property 'x' in type 'X' is not assignable to the same property in base type 'Y' in TypeScript

// Base class with string property
class Animal {
  name: string = "";
}

// Derived class trying to change property type
class Dog extends Animal {
  name: number = 0; // ERROR: Property 'name' in type 'Dog' is not assignable to the same property in base type 'Animal'
}

// Base class with Animal type property
class Zoo {
  animal: Animal = new Animal();
}

// Derived class - OK: Dog is a subtype of Animal
class DogZoo extends Zoo {
  animal: Dog = new Dog(); // OK: Dog extends Animal
}

// Derived class - ERROR: Animal is not a subtype of Dog
class AnimalZoo extends Zoo {
  animal: Animal = new Animal(); // Actually OK here, but shows the principle
}

// Base class
class Vehicle {
  speed: number = 0;
}

// WRONG - changing type
class Car extends Vehicle {
  speed: string = "fast"; // ERROR
}

// CORRECT - same type
class Car extends Vehicle {
  speed: number = 100; // OK
}

// CORRECT - union type that includes the base type
class HybridCar extends Vehicle {
  speed: number | "electric" = 0; // OK if "electric" is assignable to number
  // Actually, this might still error if "electric" is not assignable to number
}

// BETTER - use a different property
class Car extends Vehicle {
  speed: number = 100;
  speedDescription: string = "fast"; // Additional property
}

interface Base {
  name?: string;  // Optional
}

// OK - making optional property required
interface Derived extends Base {
  name: string;   // Required - OK because all Base values have name? (maybe undefined)
}

interface Base2 {
  name: string;   // Required
}

// ERROR - making required property optional
interface Derived2 extends Base2 {
  name?: string;  // Optional - ERROR because Base2 requires name
}

class Container<T> {
  value: T;
  constructor(value: T) {
    this.value = value;
  }
}

// ERROR - generic constraint mismatch
class StringContainer extends Container<string> {
  value: number; // ERROR: changing type parameter instantiation
}

// CORRECT - same generic instantiation
class StringContainer extends Container<string> {
  value: string; // OK - same type
}

// CORRECT - additional methods with same property type
class StringContainer extends Container<string> {
  getLength(): number {
    return this.value.length;
  }
}

interface A {
  prop: string;
}

interface B {
  prop: number;
}

// ERROR - conflicting property types
interface C extends A, B {
  // prop: string & number is impossible
}

// SOLUTION 1: Use a union type in the extending interface
interface C extends A {
  prop: string | number; // Still error: not assignable to A.prop (string)
}

// SOLUTION 2: Omit and redefine
interface C extends Omit<A, "prop">, Omit<B, "prop"> {
  prop: string | number; // Now OK - not conflicting with parent interfaces
}

// SOLUTION 3: Use type intersection (not extension)
type C = A & B; // Creates type with prop: string & number (never)

class Base {
  private _value: number = 0;
  
  get value(): number {
    return this._value;
  }
  
  set value(v: number) {
    this._value = v;
  }
}

class Derived extends Base {
  // Override getter with compatible return type
  get value(): number {
    return super.value * 2; // OK - still returns number
  }
}

// ERROR example with property
class Base2 {
  value: number = 0;
}

class Derived2 extends Base2 {
  value: string = "test"; // ERROR - property type mismatch
}

// Instead of inheritance with type conflicts:
class Animal {
  name: string = "";
}

// class Dog extends Animal {
//   name: DogName; // ERROR if DogName not assignable to string
// }

// Use composition:
class Dog {
  private animal: Animal;
  name: DogName;
  
  constructor(name: DogName) {
    this.animal = new Animal();
    this.animal.name = name.toString(); // Convert if needed
    this.name = name;
  }
  
  getAnimalName(): string {
    return this.animal.name;
  }
}