newDefinitions

Reports misleading constructor and new definitions in interfaces and classes.

✅ This rule is included in the ts logical and logicalStrict presets.

In TypeScript, classes and interfaces have different ways of defining how instances are created. This rule flags misleading definitions that confuse interface construct signatures with class constructors.

There are two common mistakes this rule catches:

1. Interface new() returning the interface type: An interface with new(): InterfaceName is misleading because interfaces cannot be instantiated directly. If the interface describes a constructor function, the return type should typically be different from the interface name.

2. Interface with constructor method: Interfaces should use new() signatures to describe constructables, not constructor() methods. The constructor keyword is used in classes, not interfaces.

3. Class with new method returning the class type: A class method named new that returns the class type looks like a constructor definition, but classes use constructor instead.

Examples

❌ Incorrect

interface Container {
  new (): Container;
}

interface Handler {
  constructor(): void;
}

declare class Component {
  new(): Component;
}

✅ Correct

interface ContainerConstructor {
  new (): Container;
}

interface Container {
  value: string;
}

class Handler {
  constructor() {
    // initialization
  }
}

interface Callable {
  (): void;
}

interface Factory<T> {
  new (): T;
}

declare class Component {
  constructor();
}

When Not To Use It

This rule is useful for catching common mistakes when defining constructor-like signatures. If you have intentional advanced type patterns that this rule incorrectly flags, you may need to disable it.

Further Reading

• TypeScript Handbook: Interfaces
• TypeScript Handbook: Classes
• MDN: Constructor

Equivalents in Other Linters

• Biome: noMisleadingInstantiator
• Deno: no-misused-new
• ESLint: @typescript-eslint/no-misused-new
• Oxlint: typescript/no-misused-new