How to fix Abstract methods can only appear within an abstract class in TypeScript

// BEFORE: Error TS1244
class Animal {
  abstract makeSound(): void; // Error!
}

// AFTER: Add 'abstract' to the class
abstract class Animal {
  abstract makeSound(): void; // Now valid
}

abstract class Animal {
  name: string;

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

  // Abstract method - no implementation
  abstract makeSound(): void;

  // Concrete method - has implementation
  move(distance: number): void {
    console.log(`${this.name} moved ${distance} meters`);
  }
}

// Cannot instantiate abstract class
// const animal = new Animal("Generic"); // Error!

// Must create a concrete subclass
class Dog extends Animal {
  makeSound(): void {
    console.log("Woof! Woof!");
  }
}

const dog = new Dog("Buddy");
dog.makeSound(); // "Woof! Woof!"
dog.move(10); // "Buddy moved 10 meters"

// BEFORE: Abstract method in regular class
class Shape {
  abstract calculateArea(): number; // Error!
}

// OPTION 1: Make it concrete with default implementation
class Shape {
  calculateArea(): number {
    return 0; // Default implementation
  }
}

// OPTION 2: Make it concrete with actual logic
class Shape {
  width: number;
  height: number;

  constructor(width: number, height: number) {
    this.width = width;
    this.height = height;
  }

  calculateArea(): number {
    return this.width * this.height;
  }
}

// BEFORE: Abstract class with only abstract methods
abstract class Vehicle {
  abstract start(): void;
  abstract stop(): void;
}

// AFTER: Use interface for pure contracts
interface Vehicle {
  start(): void;
  stop(): void;
}

// Implement the interface
class Car implements Vehicle {
  start(): void {
    console.log("Car started");
  }

  stop(): void {
    console.log("Car stopped");
  }
}

// Can implement multiple interfaces
interface Driveable {
  drive(distance: number): void;
}

class Car implements Vehicle, Driveable {
  start(): void {
    console.log("Car started");
  }

  stop(): void {
    console.log("Car stopped");
  }

  drive(distance: number): void {
    console.log(`Driving ${distance}km`);
  }
}

abstract class Database {
  abstract connect(): Promise<void>;
  abstract disconnect(): Promise<void>;
  abstract query(sql: string): Promise<any>;

  // Concrete method shared by all databases
  log(message: string): void {
    console.log(`[DB] ${message}`);
  }
}

// Must implement ALL abstract methods
class PostgresDB extends Database {
  connect(): Promise<void> {
    this.log("Connecting to PostgreSQL...");
    return Promise.resolve();
  }

  disconnect(): Promise<void> {
    this.log("Disconnecting from PostgreSQL...");
    return Promise.resolve();
  }

  query(sql: string): Promise<any> {
    this.log(`Executing: ${sql}`);
    return Promise.resolve([]);
  }
}

// Valid instance
const db = new PostgresDB();
db.connect();