Rule: typedef

Requires type definitions to exist.

Notes:

Config

Several arguments may be optionally provided:

• "call-signature" checks return type of functions.
• "arrow-call-signature" checks return type of arrow functions.
• "parameter" checks type specifier of function parameters for non-arrow functions.
• "arrow-parameter" checks type specifier of function parameters for arrow functions.
• "property-declaration" checks return types of interface properties.
• "variable-declaration" checks non-binding variable declarations.
• "variable-declaration-ignore-function" ignore variable declarations for non-arrow and arrow functions.
• "member-variable-declaration" checks member variable declarations.
• "object-destructuring" checks object destructuring declarations.
• "array-destructuring" checks array destructuring declarations.

Config examples

"typedef": [true, "call-signature", "parameter", "member-variable-declaration"]

Schema

{
  "type": "array",
  "items": {
    "type": "string",
    "enum": [
      "call-signature",
      "arrow-call-signature",
      "parameter",
      "arrow-parameter",
      "property-declaration",
      "variable-declaration",
      "variable-declaration-ignore-function",
      "member-variable-declaration",
      "object-destructuring",
      "array-destructuring"
    ]
  },
  "minLength": 0,
  "maxLength": 10
}

Code examples:

"rules": { "typedef": [true, "call-signature"] }

function add(x, y): number {
    return x + y;
}

function add(x, y) {
    return x + y;
}

"rules": { "typedef": [true, "arrow-call-signature"] }

const add = (x, y): number => x + y;

const add = (x, y) => x + y;

"rules": { "typedef": [true, "parameter"] }

function add(x: number, y: number) {
    return x + y;
}

function add(x, y) {
    return x + y;
}

"rules": { "typedef": [true, "arrow-parameter"] }

const add = (x: number, y: number) => x + y;

const add = (x, y) => x + y;

"rules": { "typedef": [true, "property-declaration"] }

interface I {
    foo: number;
    bar: string;
}

interface I {
    foo;
    bar;
}

"rules": { "typedef": [true, "variable-declaration"] }

let x: number;

let x;

"rules": { "typedef": [true, "member-variable-declaration"] }

class MyClass {
    x: number;
}

class MyClass {
    x;
}

"rules": { "typedef": [true, "object-destructuring"] }

interface FooBar {
    foo: number;
    bar: string;
}
const foobar = { foo: 1, bar: '2' };
const { foo, bar }: FooBar = foobar;

interface FooBar {
    foo: number;
    bar: string;
}
const foobar = { foo: 1, bar: '2' };
const { foo, bar } = foobar;

"rules": { "typedef": [true, "array-destructuring"] }

const foobar = [1, '2'];
const [foo, bar]: Array<number | string> = foobar;

const foobar = [1, '2'];
const [foo, bar] = foobar;