A consistent ordering of fields, methods and constructors can make interfaces, type literals, classes and class expressions easier to read, navigate and edit.

This rule aims to standardize the way class declarations, class expressions, interfaces and type literals are structured and ordered.

It allows to group members by their type (e.g. `public-static-field`, `protected-static-field`, `private-static-field`, `public-instance-field`, ...) and enforce a certain order for these groups. By default, their order is the same inside `classes`, `classExpressions`, `interfaces` and `typeLiterals` (note: not all member types apply to `interfaces` and `typeLiterals`). It is possible to define the order for any of those individually or to change the default order for all of them by setting the `default` option.

Besides grouping the members and sorting their groups, this rule also allows to sort the members themselves (e.g. `a`, `b`, `c`, ...). You have 2 options: Sort all of them while ignoring their type or sort them while respecting their types (e.g. sort all fields in an interface alphabetically).

These options allow to specify how to group the members and sort their groups.

- Sort groups, don't enforce member order: Use `memberTypes`

- Sort members, don't enforce group order: Use `order`

- Sort members within groups: Use `memberTypes` and `order`

type TypeOptions<T> =

| {

memberTypes: Array<T> | 'never',

order?: 'alphabetically' | 'as-written',

}

| {

order: 'alphabetically',

};

default?: TypeOptions<MemberTypes>,

classes?: TypeOptions<MemberTypes>,

classExpressions?: TypeOptions<MemberTypes>,

interfaces?: TypeOptions<'signature' | 'field' | 'method' | 'constructor'>,

typeLiterals?: TypeOptions<'signature' | 'field' | 'method' | 'constructor'>,

Note: There is a deprecated syntax to specify the member types as an array.

default: [

// Index signature

'signature',

// Fields

'public-static-field',

'protected-static-field',

'private-static-field',

'public-instance-field',

'protected-instance-field',

'private-instance-field',

'public-abstract-field',

'protected-abstract-field',

'private-abstract-field',

'public-field',

'protected-field',

'private-field',

'static-field',

'instance-field',

'abstract-field',

'field',

// Constructors

'public-constructor',

'protected-constructor',

'private-constructor',

'constructor',

// Methods

'public-static-method',

'protected-static-method',

'private-static-method',

'public-instance-method',

'protected-instance-method',

'private-instance-method',

'public-abstract-method',

'protected-abstract-method',

'private-abstract-method',

'public-method',

'protected-method',

'private-method',

'static-method',

'instance-method',

'abstract-method',

'method',

],

Note: By default, the members are not sorted. If you want to sort them alphabetically, you have to provide a custom configuration.

Note: Public static fields should come first, followed by static fields and instance fields.

public B(): void {} // -> public instance method

public static E: string; // -> public static field

It is possible to sort all members within a group alphabetically.

This will apply the default order (see above) and enforce an alphabetic order within each group.

interface Foo {

a: x;

b: x;

c: x;

new (): Bar;

(): Baz;

a(): void;

b(): void;

c(): void;

// Wrong group order, should be placed before all field definitions

[a: string]: number;

}

interface Foo {

[a: string]: number;

a: x;

b: x;

c: x;

new (): Bar;

(): Baz;

// Wrong alphabetic order within group

c(): void;

b(): void;

a(): void;

}

It is also possible to sort all members and ignore the member groups completely.

interface Foo {

b(): void;

a: b;

[a: string]: number; // Order doesn't matter (no sortable identifier)

new (): Bar; // Order doesn't matter (no sortable identifier)

(): Baz; // Order doesn't matter (no sortable identifier)

}

Note: Wrong alphabetic order `b(): void` should come after `a: b`.