How to fix Class 'X' incorrectly implements interface 'Y' in TypeScript

Class 'UserService' incorrectly implements interface 'IUserService'.
  Types of property 'getUser' are incompatible.
    Type '() => User | null' is not assignable to type '() => User'.
      Type 'null' is not assignable to type 'User'.

// Interface definition
interface IUserService {
  getUser(): User;           // Returns User (not nullable)
  email: string;             // string type
  age: number;               // number type
}

// Class implementation
class UserService implements IUserService {
  email: string = "";
  age: string = "25";        // ❌ WRONG: string should be number

  getUser(): User | null {   // ❌ WRONG: should return User, not User | null
    return null;
  }
}

// ❌ WRONG - type mismatch
interface IConfig {
  port: number;
  enabled: boolean;
}

class Config implements IConfig {
  port: string = "3000";      // ERROR: string is not number
  enabled: number = 1;        // ERROR: number is not boolean
}

// ✅ CORRECT - types match
class Config implements IConfig {
  port: number = 3000;
  enabled: boolean = true;
}

interface IUserService {
  getUser(): User | null;    // Now allows null
}

class UserService implements IUserService {
  getUser(): User | null {   // ✅ Now matches
    return null;
  }
}

// ❌ WRONG - return type mismatch
interface ILogger {
  log(message: string): void;
}

class Logger implements ILogger {
  log(message: string): boolean {  // ERROR: returns boolean, not void
    console.log(message);
    return true;
  }
}

// ✅ CORRECT - void return
class Logger implements ILogger {
  log(message: string): void {
    console.log(message);
  }
}

// ❌ WRONG - parameter type differs
interface ICalculator {
  add(a: number, b: number): number;
}

class Calculator implements ICalculator {
  add(a: string, b: string): number {  // ERROR: params should be number
    return parseInt(a) + parseInt(b);
  }
}

// ✅ CORRECT
class Calculator implements ICalculator {
  add(a: number, b: number): number {
    return a + b;
  }
}

// ❌ WRONG - private member on public interface property
interface IService {
  getData(): string;  // implicitly public
}

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

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

// ❌ WRONG
class Service implements IService {
  protected getData(): string {  // ERROR: can't be protected
    return "data";
  }
}

// ❌ WRONG - readonly mismatch
interface IConfig {
  readonly apiKey: string;
}

class Config implements IConfig {
  apiKey: string = "key123";  // ERROR: missing readonly
}

// ✅ CORRECT
class Config implements IConfig {
  readonly apiKey: string = "key123";
}

interface IConfig {
  apiKey: string;  // not readonly
}

class Config implements IConfig {
  apiKey: string = "key123";  // ✅ matches
}

// ❌ WRONG - optional mismatch
interface IUser {
  name: string;
  email?: string;  // optional
}

class User implements IUser {
  name: string = "";
  email: string = "";  // Not optional in class - this is actually OK
}

// This is fine because the class can be more specific than the interface

// ❌ WRONG - required property made optional
interface IUser {
  name: string;  // required
}

class User implements IUser {
  name?: string;  // ERROR: can't make it optional
}

// ✅ CORRECT
class User implements IUser {
  name: string = "";
}

// ❌ WRONG - incompatible generic types
interface IRepository<T> {
  save(item: T): void;
}

class UserRepository implements IRepository<User> {
  save(item: string): void {  // ERROR: expects User, got string
    // ...
  }
}

// ✅ CORRECT
class UserRepository implements IRepository<User> {
  save(item: User): void {
    // ...
  }
}

interface IProcessor<T extends object> {
  process(data: T): void;
}

// ❌ WRONG - string doesn't extend object
class StringProcessor implements IProcessor<string> {
  process(data: string): void { }
}

// ✅ CORRECT - User extends object
class UserProcessor implements IProcessor<User> {
  process(data: User): void { }
}