How to fix Class 'UserService' does not implement interface 'IUserService' in TypeScript

Class 'UserService' does not implement interface 'IUserService'.
  Property 'getName' is missing in type 'UserService' but required in type 'IUserService'.

interface IUserService {
  getName(): string;           // Method that returns string
  getUserId(): number;         // Method that returns number
  email: string;               // Property
  isActive?: boolean;          // Optional property
}

class UserService implements IUserService {
  email: string = "";

  constructor() {
    this.email = "[email protected]";
  }

  getName(): string {
    return "John Doe";
  }

  getUserId(): number {
    return 42;
  }

  // isActive is optional, so you don't have to implement it
}

// ❌ WRONG - wrong return type
interface IService {
  getValue(): string;
}

class Service implements IService {
  getValue(): number {  // ERROR: number is not string
    return 42;
  }
}

// ✅ CORRECT - matching signature
class Service implements IService {
  getValue(): string {
    return "42";
  }
}

// ❌ WRONG - missing parameter
interface ILogger {
  log(message: string, level: "info" | "error"): void;
}

class Logger implements ILogger {
  log(message: string): void {  // ERROR: missing level parameter
    console.log(message);
  }
}

// ✅ CORRECT
class Logger implements ILogger {
  log(message: string, level: "info" | "error"): void {
    console.log(`[${level}] ${message}`);
  }
}

// ❌ WRONG - interface member is public but class member is private
interface IService {
  getData(): string;  // implicitly public
}

class Service implements IService {
  private getData(): string {  // ERROR: private doesn't match public
    return "data";
  }
}

// ✅ CORRECT - both public
class Service implements IService {
  public getData(): string {  // or just: getData(): string
    return "data";
  }
}

interface IService {
  name: string;
  getValue(): number;
  cache?: Map<string, any>;  // Optional property
  reset?(): void;             // Optional method
}

class MinimalService implements IService {
  name = "Service";
  getValue() {
    return 42;
  }
  // cache and reset are optional, so they don't need to be implemented
}

interface IBase {
  id: number;
}

interface IExtended extends IBase {
  name: string;
}

// ❌ WRONG - missing id (from IBase)
class Model implements IExtended {
  name: string = "";
}

// ✅ CORRECT - implements all members from the chain
class Model implements IExtended {
  id: number = 0;
  name: string = "";
}

// ✅ Also correct
class Model implements IBase, IExtended {
  id: number = 0;
  name: string = "";
}