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

What this error means

When you use the `implements` keyword in TypeScript, you're telling the compiler that your class must satisfy the interface contract—meaning it must define all properties and methods that the interface specifies. If your class is missing any of these required members, or if a member has an incompatible type, TypeScript raises the error "Class does not implement interface". This is a compile-time safety feature that prevents mismatches between what code expects and what your class actually provides. This is one of the most common TypeScript errors because it's easy to forget to implement all interface members, especially in interfaces with many properties or when inheriting from interfaces that extend other interfaces.

Typical symptoms

• TypeScript compiler shows TS2420 error on class declaration
• Error message specifies which property or method is missing
• IDE highlights the class name with a red squiggle
• Build fails with compilation error before code runs
• Error appears immediately after adding `implements InterfaceName` to a class

Common causes

1. Class is missing one or more required properties defined in the interface (most common)
2. Property exists but has an incompatible type (e.g., string instead of number)
3. Method signature doesn't match interface (wrong parameters or return type)
4. Property is marked as optional in the class (?) but required in interface, or vice versa
5. Class doesn't implement all methods in a multi-interface inheritance chain
6. Method is declared as private in the class but public in the interface

How to fix "Class 'UserService' does not implement interface 'IUserService'"

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 = "user@example.com";
  }

  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 = "";
}

Advanced notes

const service = {
  getName: () => "John",
  getValue: () => 42,
} satisfies IService;

interface Duck {
  quack(): void;
  swim(): void;
}

const mallard = {
  quack() { console.log("quack!"); },
  swim() { console.log("swimming!"); },
};

// mallard satisfies Duck structurally, even without "implements"

// ❌ Large interface with many unrelated methods
interface IUserService {
  getUser(): User;
  updateUser(user: User): void;
  deleteUser(id: string): void;
  sendEmail(to: string, message: string): void;
  logActivity(action: string): void;
}

// ✅ Better: separate concerns
interface IUserRepository {
  getUser(): User;
  updateUser(user: User): void;
  deleteUser(id: string): void;
}

interface INotificationService {
  sendEmail(to: string, message: string): void;
}

interface IAuditService {
  logActivity(action: string): void;
}

class UserService implements IUserRepository, INotificationService, IAuditService {
  // Clearer what each method is responsible for
}

abstract class BaseService {
  abstract getData(): string;  // Must be implemented by subclass

  processData() {              // Can have default implementation
    const data = this.getData();
    return data.toUpperCase();
  }
}

class Service extends BaseService {
  getData() {
    return "hello";
  }
}

Frequently asked questions

What does "TS2420" mean?

When you use the implements keyword in TypeScript, you're telling the compiler that your class must satisfy the interface contract—meaning it must define all properties and methods that the interface specifies. If your class is missing any of these required members, or if a member has an incompatible type, TypeScript raises the error "Class does not implement interface". This is a compile-time safety feature that prevents mismatches between what code expects and what your class actually provides.

How do I fix "TS2420"?

This error occurs when a class declares that it implements an interface but is missing one or more required properties or methods. The fix involves adding all missing members or marking interface members as optional.

What causes "TS2420"?

Class is missing one or more required properties defined in the interface (most common) Property exists but has an incompatible type (e.g., string instead of number) Method signature doesn't match interface (wrong parameters or return type)

Is the "TS2420" error serious?

It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Related errors

• Class 'X' incorrectly implements interface 'Y'

  How to fix 'Class incorrectly implements interface' in TypeScript

  MEDIUM

• Class decorator must be used on a class declaration

  How to fix "Class decorator must be used on a class declaration" in TypeScript

  MEDIUM

• This comparison appears to be unintentional because the types have no overlap

  How to fix 'This comparison appears to be unintentional because the types have no overlap' error in TypeScript

  HIGH

• Cannot use 'X' as a value

  How to fix 'Cannot use type as a value' in TypeScript

  HIGH

• Cannot find name 'process'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.

  How to fix "Cannot find name 'process'" in TypeScript

  MEDIUM

• Module has no exported member 'X'

  How to fix 'Module has no exported member X' error in TypeScript

  MEDIUM

Official resources & further reading

• 📚TypeScript Official Documentation
• 📖
  TypeScript Handbook - Classes(Official Docs)
• 📖
  TypeScript Handbook - Interfaces(Official Docs)
• 📖
  TypeScript 4.9 - Satisfies Operator(Official Docs)
• How do I implement an interface in TypeScript? - Stack Overflow
• How to properly define a class in TypeScript - Stack Overflow