diff --git a/packages/eslint-plugin/README.md b/packages/eslint-plugin/README.md
index eb78f4a0de5..7c55b54aca6 100644
--- a/packages/eslint-plugin/README.md
+++ b/packages/eslint-plugin/README.md
@@ -168,6 +168,7 @@ Pro Tip: For larger codebases you may want to consider splitting our linting int
 | [`@typescript-eslint/require-array-sort-compare`](./docs/rules/require-array-sort-compare.md)                         | Requires `Array#sort` calls to always provide a `compareFunction`                                                       |                    |          | :thought_balloon: |
 | [`@typescript-eslint/restrict-plus-operands`](./docs/rules/restrict-plus-operands.md)                                 | When adding two variables, operands must both be of type number or of type string                                       | :heavy_check_mark: |          | :thought_balloon: |
 | [`@typescript-eslint/restrict-template-expressions`](./docs/rules/restrict-template-expressions.md)                   | Enforce template literal expressions to be of string type                                                               | :heavy_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/sort-type-union-intersection-members`](./docs/rules/sort-type-union-intersection-members.md)     | Enforces that members of a type union/intersection are sorted alphabetically                                            |                    | :wrench: |                   |
 | [`@typescript-eslint/strict-boolean-expressions`](./docs/rules/strict-boolean-expressions.md)                         | Restricts the types allowed in boolean expressions                                                                      |                    |          | :thought_balloon: |
 | [`@typescript-eslint/switch-exhaustiveness-check`](./docs/rules/switch-exhaustiveness-check.md)                       | Exhaustiveness checking in switch with union type                                                                       |                    |          | :thought_balloon: |
 | [`@typescript-eslint/triple-slash-reference`](./docs/rules/triple-slash-reference.md)                                 | Sets preference level for triple slash directives versus ES6-style import declarations                                  | :heavy_check_mark: |          |                   |
diff --git a/packages/eslint-plugin/docs/rules/sort-type-union-intersection-members.md b/packages/eslint-plugin/docs/rules/sort-type-union-intersection-members.md
new file mode 100644
index 00000000000..ecc6fcb13c7
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/sort-type-union-intersection-members.md
@@ -0,0 +1,144 @@
+# Enforces that members of a type union/intersection are sorted alphabetically (`sort-type-union-intersection-members`)
+
+Sorting union (`|`) and intersection (`&`) types can help:
+
+- keep your codebase standardized
+- find repeated types
+- reduce diff churn
+
+## Rule Details
+
+Sorting within each group is done using the following code:
+
+```ts
+const collator = new Intl.Collator('en', {
+  sensitivity: 'base',
+  numeric: true,
+});
+
+function compare(a, b) {
+  return collator.compare(a, b) || (a < b ? -1 : a > b ? 1 : 0);
+}
+```
+
+In other words, the types are sorted alphabetically, case-insensitively and treating numbers like a human would, falling back to character code sorting in case of ties.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+type T1 = B | A;
+
+type T2 = { b: string } & { a: string };
+
+type T3 = [1, 2, 4] & [1, 2, 3];
+
+type T4 =
+  | [1, 2, 4]
+  | [1, 2, 3]
+  | { b: string }
+  | { a: string }
+  | (() => void)
+  | (() => string)
+  | 'b'
+  | 'a'
+  | 'b'
+  | 'a'
+  | readonly string[]
+  | readonly number[]
+  | string[]
+  | number[]
+  | B
+  | A
+  | string
+  | any;
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+type T1 = A | B;
+
+type T2 = { a: string } & { b: string };
+
+type T3 = [1, 2, 3] & [1, 2, 4];
+
+type T4 =
+  | any
+  | string
+  | A
+  | B
+  | number[]
+  | string[]
+  | readonly number[]
+  | readonly string[]
+  | 'a'
+  | 'b'
+  | 'a'
+  | 'b'
+  | (() => string)
+  | (() => void)
+  | { a: string }
+  | { b: string }
+  | [1, 2, 3]
+  | [1, 2, 4];
+```
+
+## Options
+
+```ts
+type Options = {
+  // true to check intersection types, false otherwise
+  checkIntersections?: boolean;
+  // true to check union types, false otherwise
+  checkUnions?: boolean;
+  // the ordering of the groups
+  groupOrder?: (
+    | 'conditional'
+    | 'function'
+    | 'import'
+    | 'intersection'
+    | 'keyword'
+    | 'literal'
+    | 'named'
+    | 'object'
+    | 'operator'
+    | 'tuple'
+    | 'union'
+  )[];
+};
+
+const defaultOptions: Options = {
+  checkIntersections: true,
+  checkUnions: true,
+  groupOrder: [
+    'named',
+    'keyword',
+    'operator',
+    'literal',
+    'function',
+    'import',
+    'conditional',
+    'object',
+    'tuple',
+    'intersection',
+    'union',
+  ],
+};
+```
+
+### `groupOrder`
+
+Each member of the type is placed into a group, and then the rule sorts alphabetically within each group.
+The ordering of groups is determined by this option.
+
+- `conditional` - Conditional types (`A extends B ? C : D`)
+- `function` - Function and constructor types (`() => void`, `new () => type`)
+- `import` - Import types (`import('path')`)
+- `intersection` - Intersection types (`A & B`)
+- `keyword` - Keyword types (`any`, `string`, etc)
+- `literal` - Literal types (`1`, `'b'`, `true`, etc)
+- `named` - Named types (`A`, `A['prop']`, `B[]`, `Array<C>`)
+- `object` - Object types (`{ a: string }`, `{ [key: string]: number }`)
+- `operator` - Operator types (`keyof A`, `typeof B`, `readonly C[]`)
+- `tuple` - Tuple types (`[A, B, C]`)
+- `union` - Union types (`A | B`)
diff --git a/packages/eslint-plugin/src/configs/all.ts b/packages/eslint-plugin/src/configs/all.ts
index df0b704146c..36cd690afa0 100644
--- a/packages/eslint-plugin/src/configs/all.ts
+++ b/packages/eslint-plugin/src/configs/all.ts
@@ -140,6 +140,7 @@ export = {
     '@typescript-eslint/return-await': 'error',
     semi: 'off',
     '@typescript-eslint/semi': 'error',
+    '@typescript-eslint/sort-type-union-intersection-members': 'error',
     'space-before-function-paren': 'off',
     '@typescript-eslint/space-before-function-paren': 'error',
     'space-infix-ops': 'off',
diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts
index 66f820a0dcb..1be014e46c5 100644
--- a/packages/eslint-plugin/src/rules/index.ts
+++ b/packages/eslint-plugin/src/rules/index.ts
@@ -102,6 +102,7 @@ import restrictPlusOperands from './restrict-plus-operands';
 import restrictTemplateExpressions from './restrict-template-expressions';
 import returnAwait from './return-await';
 import semi from './semi';
+import sortTypeUnionIntersectionMembers from './sort-type-union-intersection-members';
 import spaceBeforeFunctionParen from './space-before-function-paren';
 import spaceInfixOps from './space-infix-ops';
 import strictBooleanExpressions from './strict-boolean-expressions';
@@ -217,6 +218,7 @@ export default {
   'restrict-template-expressions': restrictTemplateExpressions,
   'return-await': returnAwait,
   semi: semi,
+  'sort-type-union-intersection-members': sortTypeUnionIntersectionMembers,
   'space-before-function-paren': spaceBeforeFunctionParen,
   'space-infix-ops': spaceInfixOps,
   'strict-boolean-expressions': strictBooleanExpressions,
diff --git a/packages/eslint-plugin/src/rules/sort-type-union-intersection-members.ts b/packages/eslint-plugin/src/rules/sort-type-union-intersection-members.ts
new file mode 100644
index 00000000000..5014fd33c24
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/sort-type-union-intersection-members.ts
@@ -0,0 +1,251 @@
+import {
+  AST_NODE_TYPES,
+  TSESLint,
+  TSESTree,
+} from '@typescript-eslint/experimental-utils';
+import * as util from '../util';
+import { getEnumNames } from '../util';
+
+enum Group {
+  conditional = 'conditional',
+  function = 'function',
+  import = 'import',
+  intersection = 'intersection',
+  keyword = 'keyword',
+  literal = 'literal',
+  named = 'named',
+  object = 'object',
+  operator = 'operator',
+  tuple = 'tuple',
+  union = 'union',
+}
+
+function getGroup(node: TSESTree.TypeNode): Group {
+  switch (node.type) {
+    case AST_NODE_TYPES.TSParenthesizedType:
+      return getGroup(node.typeAnnotation);
+
+    case AST_NODE_TYPES.TSConditionalType:
+      return Group.conditional;
+
+    case AST_NODE_TYPES.TSConstructorType:
+    case AST_NODE_TYPES.TSFunctionType:
+      return Group.function;
+
+    case AST_NODE_TYPES.TSImportType:
+      return Group.import;
+
+    case AST_NODE_TYPES.TSIntersectionType:
+      return Group.intersection;
+
+    case AST_NODE_TYPES.TSAnyKeyword:
+    case AST_NODE_TYPES.TSBigIntKeyword:
+    case AST_NODE_TYPES.TSBooleanKeyword:
+    case AST_NODE_TYPES.TSNeverKeyword:
+    case AST_NODE_TYPES.TSNullKeyword:
+    case AST_NODE_TYPES.TSNumberKeyword:
+    case AST_NODE_TYPES.TSObjectKeyword:
+    case AST_NODE_TYPES.TSStringKeyword:
+    case AST_NODE_TYPES.TSSymbolKeyword:
+    case AST_NODE_TYPES.TSThisType:
+    case AST_NODE_TYPES.TSUndefinedKeyword:
+    case AST_NODE_TYPES.TSUnknownKeyword:
+    case AST_NODE_TYPES.TSVoidKeyword:
+      return Group.keyword;
+
+    case AST_NODE_TYPES.TSLiteralType:
+    case AST_NODE_TYPES.TSTemplateLiteralType:
+      return Group.literal;
+
+    case AST_NODE_TYPES.TSArrayType:
+    case AST_NODE_TYPES.TSIndexedAccessType:
+    case AST_NODE_TYPES.TSInferType:
+    case AST_NODE_TYPES.TSTypeReference:
+      return Group.named;
+
+    case AST_NODE_TYPES.TSMappedType:
+    case AST_NODE_TYPES.TSTypeLiteral:
+      return Group.object;
+
+    case AST_NODE_TYPES.TSTypeOperator:
+    case AST_NODE_TYPES.TSTypeQuery:
+      return Group.operator;
+
+    case AST_NODE_TYPES.TSTupleType:
+      return Group.tuple;
+
+    case AST_NODE_TYPES.TSUnionType:
+      return Group.union;
+
+    // These types should never occur as part of a union/intersection
+    case AST_NODE_TYPES.TSInterfaceHeritage:
+    case AST_NODE_TYPES.TSNamedTupleMember:
+    case AST_NODE_TYPES.TSOptionalType:
+    case AST_NODE_TYPES.TSRestType:
+    case AST_NODE_TYPES.TSTypePredicate:
+      /* istanbul ignore next */
+      throw new Error(`Unexpected Type ${node.type}`);
+  }
+}
+
+export type Options = [
+  {
+    checkIntersections?: boolean;
+    checkUnions?: boolean;
+    groupOrder?: string[];
+  },
+];
+export type MessageIds = 'notSorted' | 'notSortedNamed' | 'suggestFix';
+
+export default util.createRule<Options, MessageIds>({
+  name: 'sort-type-union-intersection-members',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforces that members of a type union/intersection are sorted alphabetically',
+      category: 'Stylistic Issues',
+      recommended: false,
+    },
+    fixable: 'code',
+    messages: {
+      notSorted: '{{type}} type members must be sorted.',
+      notSortedNamed: '{{type}} type {{name}} members must be sorted.',
+      suggestFix: 'Sort members of type (removes all comments).',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          checkIntersections: {
+            type: 'boolean',
+          },
+          checkUnions: {
+            type: 'boolean',
+          },
+          groupOrder: {
+            type: 'array',
+            items: {
+              type: 'string',
+              enum: getEnumNames(Group),
+            },
+          },
+        },
+      },
+    ],
+  },
+  defaultOptions: [
+    {
+      checkIntersections: true,
+      checkUnions: true,
+      groupOrder: [
+        Group.named,
+        Group.keyword,
+        Group.operator,
+        Group.literal,
+        Group.function,
+        Group.import,
+        Group.conditional,
+        Group.object,
+        Group.tuple,
+        Group.intersection,
+        Group.union,
+      ],
+    },
+  ],
+  create(context, [{ checkIntersections, checkUnions, groupOrder }]) {
+    const sourceCode = context.getSourceCode();
+
+    const collator = new Intl.Collator('en', {
+      sensitivity: 'base',
+      numeric: true,
+    });
+
+    function checkSorting(
+      node: TSESTree.TSIntersectionType | TSESTree.TSUnionType,
+    ): void {
+      const sourceOrder = node.types.map(type => {
+        const group = groupOrder?.indexOf(getGroup(type)) ?? -1;
+        return {
+          group: group === -1 ? Number.MAX_SAFE_INTEGER : group,
+          node: type,
+          text: sourceCode.getText(type),
+        };
+      });
+      const expectedOrder = [...sourceOrder].sort((a, b) => {
+        if (a.group !== b.group) {
+          return a.group - b.group;
+        }
+
+        return (
+          collator.compare(a.text, b.text) ||
+          (a.text < b.text ? -1 : a.text > b.text ? 1 : 0)
+        );
+      });
+
+      const hasComments = node.types.some(type => {
+        const count =
+          sourceCode.getCommentsBefore(type).length +
+          sourceCode.getCommentsAfter(type).length;
+        return count > 0;
+      });
+
+      for (let i = 0; i < expectedOrder.length; i += 1) {
+        if (expectedOrder[i].node !== sourceOrder[i].node) {
+          let messageId: MessageIds = 'notSorted';
+          const data = {
+            name: '',
+            type:
+              node.type === AST_NODE_TYPES.TSIntersectionType
+                ? 'Intersection'
+                : 'Union',
+          };
+          if (node.parent?.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {
+            messageId = 'notSortedNamed';
+            data.name = node.parent.id.name;
+          }
+
+          const fix: TSESLint.ReportFixFunction = fixer => {
+            const sorted = expectedOrder
+              .map(t => t.text)
+              .join(
+                node.type === AST_NODE_TYPES.TSIntersectionType ? ' & ' : ' | ',
+              );
+
+            return fixer.replaceText(node, sorted);
+          };
+          return context.report({
+            node,
+            messageId,
+            data,
+            // don't autofix if any of the types have leading/trailing comments
+            // the logic for preserving them correctly is a pain - we may implement this later
+            ...(hasComments
+              ? {
+                  suggest: [
+                    {
+                      messageId: 'suggestFix',
+                      fix,
+                    },
+                  ],
+                }
+              : { fix }),
+          });
+        }
+      }
+    }
+
+    return {
+      TSIntersectionType(node): void {
+        if (checkIntersections === true) {
+          checkSorting(node);
+        }
+      },
+      TSUnionType(node): void {
+        if (checkUnions === true) {
+          checkSorting(node);
+        }
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin/tests/rules/sort-type-union-intersection-members.test.ts b/packages/eslint-plugin/tests/rules/sort-type-union-intersection-members.test.ts
new file mode 100644
index 00000000000..469becaf000
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/sort-type-union-intersection-members.test.ts
@@ -0,0 +1,304 @@
+import { TSESLint } from '@typescript-eslint/experimental-utils';
+import rule, {
+  MessageIds,
+  Options,
+} from '../../src/rules/sort-type-union-intersection-members';
+import { noFormat, RuleTester } from '../RuleTester';
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+});
+
+const valid = (operator: '|' | '&'): TSESLint.ValidTestCase<Options>[] => [
+  {
+    code: `type T = A ${operator} B;`,
+  },
+  {
+    code: `type T = A ${operator} /* comment */ B;`,
+  },
+  {
+    code: `type T = 'A' ${operator} 'B';`,
+  },
+  {
+    code: `type T = 1 ${operator} 2;`,
+  },
+  {
+    code: noFormat`type T = (A) ${operator} (B);`,
+  },
+  {
+    code: `type T = { a: string } ${operator} { b: string };`,
+  },
+  {
+    code: `type T = [1, 2, 3] ${operator} [1, 2, 4];`,
+  },
+  {
+    code: `type T = (() => string) ${operator} (() => void);`,
+  },
+  {
+    code: `type T = () => string ${operator} void;`,
+  },
+  {
+    // testing the default ordering
+    code: noFormat`
+type T =
+  ${operator} A
+  ${operator} B
+  ${operator} number[]
+  ${operator} string[]
+  ${operator} any
+  ${operator} string
+  ${operator} readonly number[]
+  ${operator} readonly string[]
+  ${operator} 'a'
+  ${operator} 'b'
+  ${operator} "a"
+  ${operator} "b"
+  ${operator} (() => string)
+  ${operator} (() => void)
+  ${operator} (new () => string)
+  ${operator} (new () => void)
+  ${operator} import('bar')
+  ${operator} import('foo')
+  ${operator} (number extends string ? unknown : never)
+  ${operator} (string extends string ? unknown : never)
+  ${operator} { [a in string]: string }
+  ${operator} { [a: string]: string }
+  ${operator} { [b in string]: string }
+  ${operator} { [b: string]: string }
+  ${operator} { a: string }
+  ${operator} { b: string }
+  ${operator} [1, 2, 3]
+  ${operator} [1, 2, 4]
+  ${operator} (A & B)
+  ${operator} (B & C)
+  ${operator} (A | B)
+  ${operator} (B | C)
+    `,
+  },
+];
+const invalid = (
+  operator: '|' | '&',
+): TSESLint.InvalidTestCase<MessageIds, Options>[] => {
+  const type = operator === '|' ? 'Union' : 'Intersection';
+  return [
+    {
+      code: `type T = B ${operator} A;`,
+      output: `type T = A ${operator} B;`,
+      errors: [
+        {
+          messageId: 'notSortedNamed',
+          data: {
+            type,
+            name: 'T',
+          },
+        },
+      ],
+    },
+    {
+      code: `type T = 'B' ${operator} 'A';`,
+      output: `type T = 'A' ${operator} 'B';`,
+      errors: [
+        {
+          messageId: 'notSortedNamed',
+          data: {
+            type,
+            name: 'T',
+          },
+        },
+      ],
+    },
+    {
+      code: `type T = 2 ${operator} 1;`,
+      output: `type T = 1 ${operator} 2;`,
+      errors: [
+        {
+          messageId: 'notSortedNamed',
+          data: {
+            type,
+            name: 'T',
+          },
+        },
+      ],
+    },
+    {
+      code: noFormat`type T = (B) ${operator} (A);`,
+      output: noFormat`type T = (A) ${operator} (B);`,
+      errors: [
+        {
+          messageId: 'notSortedNamed',
+          data: {
+            type,
+            name: 'T',
+          },
+        },
+      ],
+    },
+    {
+      code: `type T = { b: string } ${operator} { a: string };`,
+      output: `type T = { a: string } ${operator} { b: string };`,
+      errors: [
+        {
+          messageId: 'notSortedNamed',
+          data: {
+            type,
+            name: 'T',
+          },
+        },
+      ],
+    },
+    {
+      code: `type T = [1, 2, 4] ${operator} [1, 2, 3];`,
+      output: `type T = [1, 2, 3] ${operator} [1, 2, 4];`,
+      errors: [
+        {
+          messageId: 'notSortedNamed',
+          data: {
+            type,
+            name: 'T',
+          },
+        },
+      ],
+    },
+    {
+      code: `type T = (() => void) ${operator} (() => string);`,
+      output: `type T = (() => string) ${operator} (() => void);`,
+      errors: [
+        {
+          messageId: 'notSortedNamed',
+          data: {
+            type,
+            name: 'T',
+          },
+        },
+      ],
+    },
+    {
+      code: `type T = () => void ${operator} string;`,
+      output: `type T = () => string ${operator} void;`,
+      errors: [
+        {
+          messageId: 'notSorted',
+          data: {
+            type,
+          },
+        },
+      ],
+    },
+    {
+      code: noFormat`
+type T =
+  ${operator} [1, 2, 4]
+  ${operator} [1, 2, 3]
+  ${operator} { b: string }
+  ${operator} { a: string }
+  ${operator} (() => void)
+  ${operator} (() => string)
+  ${operator} "b"
+  ${operator} "a"
+  ${operator} 'b'
+  ${operator} 'a'
+  ${operator} readonly string[]
+  ${operator} readonly number[]
+  ${operator} string[]
+  ${operator} number[]
+  ${operator} B
+  ${operator} A
+  ${operator} string
+  ${operator} any;
+      `,
+      output: noFormat`
+type T =
+  A ${operator} B ${operator} number[] ${operator} string[] ${operator} any ${operator} string ${operator} readonly number[] ${operator} readonly string[] ${operator} 'a' ${operator} 'b' ${operator} "a" ${operator} "b" ${operator} (() => string) ${operator} (() => void) ${operator} { a: string } ${operator} { b: string } ${operator} [1, 2, 3] ${operator} [1, 2, 4];
+      `,
+      errors: [
+        {
+          messageId: 'notSortedNamed',
+          data: {
+            type,
+            name: 'T',
+          },
+        },
+      ],
+    },
+    {
+      code: `type T = B ${operator} /* comment */ A;`,
+      output: null,
+      errors: [
+        {
+          messageId: 'notSortedNamed',
+          data: {
+            type,
+            name: 'T',
+          },
+          suggestions: [
+            {
+              messageId: 'suggestFix',
+              output: `type T = A ${operator} B;`,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `type T = (() => /* comment */ A) ${operator} B;`,
+      output: `type T = B ${operator} (() => /* comment */ A);`,
+      errors: [
+        {
+          messageId: 'notSortedNamed',
+          data: {
+            type,
+            name: 'T',
+          },
+          suggestions: null,
+        },
+      ],
+    },
+  ];
+};
+
+ruleTester.run('sort-type-union-intersection-members', rule, {
+  valid: [
+    ...valid('|'),
+    {
+      code: 'type T = B | A;',
+      options: [
+        {
+          checkUnions: false,
+        },
+      ],
+    },
+
+    ...valid('&'),
+    {
+      code: 'type T = B & A;',
+      options: [
+        {
+          checkIntersections: false,
+        },
+      ],
+    },
+
+    {
+      code: noFormat`
+type T = [1] | 'a' | 'b' | "b" | 1 | 2 | {};
+      `,
+      options: [
+        {
+          groupOrder: ['tuple', 'literal', 'object'],
+        },
+      ],
+    },
+    {
+      // if not specified - groups should be placed last
+      code: `
+type T = 1 | string | {} | A;
+      `,
+      options: [
+        {
+          groupOrder: ['literal', 'keyword'],
+        },
+      ],
+    },
+  ],
+  invalid: [...invalid('|'), ...invalid('&')],
+});