Skip to main content

consistent-type-definitions

Enforce type definitions to consistently use either interface or type.

🎨

Extending "plugin:@typescript-eslint/stylistic" in an ESLint configuration enables this rule.

🔧

Some problems reported by this rule are automatically fixable by the --fix ESLint command line option.

TypeScript provides two common ways to define an object type: interface and type.

// type alias
type T1 = {
  a: string;
  b: number;
};

// interface keyword
interface T2 {
  a: string;
  b: number;
}

The two are generally very similar, and can often be used interchangeably. Using the same type declaration style consistently helps with code readability.

eslint.config.mjs
export default tseslint.config({
  rules: {
    "@typescript-eslint/consistent-type-definitions": "error"
  }
});

Try this rule in the playground ↗

Options​

This rule accepts the following options:

type Options = [
  /** Which type definition syntax to prefer. */
  | 'type'
  /** Which type definition syntax to prefer. */
  | 'interface',
];

const defaultOptions: Options = ['interface'];
  • 'interface' (default): enforce using interfaces for object type definitions.
  • 'type': enforce using types for object type definitions.

'interface'​

type T = { x: number };
Open in Playground

'type'​

interface T {
  x: number;
}
Open in Playground

When Not To Use It​

If you specifically want to use an interface or type literal for stylistic reasons, you can avoid this rule.

However, keep in mind that inconsistent style can harm readability in a project. We recommend picking a single option for this rule that works best for your project.

There are also subtle differences between Record and interface that can be difficult to catch statically. For example, if your project is a dependency of another project that relies on a specific type definition style, this rule may be counterproductive. You might consider using ESLint disable comments for those specific situations instead of completely disabling this rule.

Resources​