How to fix Abstract property 'X' must be implemented in derived class in TypeScript

// Abstract base class
abstract class Animal {
  abstract name: string;    // Abstract property
  abstract age: number;     // Abstract property
  abstract makeSound(): void; // Abstract method
}

// WRONG - missing properties
class Dog extends Animal {
  makeSound() {
    console.log("Woof");
  }
  // ERROR: 'name' and 'age' not implemented
}

class Dog extends Animal {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  makeSound() {
    console.log("Woof");
  }
}

// Now this works
const dog = new Dog("Buddy", 3);

abstract class Vehicle {
  abstract brand: string;
  abstract wheels: number;

  abstract drive(): void;
}

class Car extends Vehicle {
  brand: string;
  wheels: number = 4; // Can set default

  constructor(brand: string) {
    super();
    this.brand = brand;
  }

  drive() {
    console.log(`${this.brand} car is driving`);
  }
}

const myCar = new Car("Toyota");
console.log(myCar.wheels); // 4

abstract class BaseClass {
  abstract readonly id: string;
  abstract status: "active" | "inactive";
}

class DerivedClass extends BaseClass {
  readonly id: string; // Must match: readonly and string type
  status: "active" | "inactive"; // Must match: same union type

  constructor(id: string) {
    this.id = id;
    this.status = "active";
  }
}

abstract class User {
  abstract name: string;
  abstract get email(): string;
  abstract set email(value: string);
}

class Customer extends User {
  name: string;
  private _email: string;

  constructor(name: string, email: string) {
    this.name = name;
    this._email = email;
  }

  get email(): string {
    return this._email;
  }

  set email(value: string) {
    this._email = value;
  }
}

// Test that the implementation works
const dog = new Dog("Max", 2);
console.log(dog.name);      // "Max"
console.log(dog.age);       // 2
console.log(dog.makeSound()); // "Woof"

// TypeScript now confirms all abstract properties are satisfied

abstract class Base {
  abstract id: string;
}

abstract class Middle extends Base {
  abstract name: string;
}

class Concrete extends Middle {
  id: string = "1";      // From Base
  name: string = "Test"; // From Middle
  // Now both are implemented
}