diff --git a/packages/eslint-plugin/docs/rules/key-spacing.md b/packages/eslint-plugin/docs/rules/key-spacing.md
new file mode 100644
index 00000000000..3bfcf5f389f
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/key-spacing.md
@@ -0,0 +1,12 @@
+---
+description: 'Enforce consistent spacing between property names and type annotations in types and interfaces.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/key-spacing** for documentation.
+
+## Examples
+
+This rule extends the base [`eslint/keyword-spacing`](https://eslint.org/docs/rules/key-spacing) rule.
+This version adds support for type annotations on interfaces, classes and type literals properties.
diff --git a/packages/eslint-plugin/package.json b/packages/eslint-plugin/package.json
index 5e2304c49e0..55992f5b727 100644
--- a/packages/eslint-plugin/package.json
+++ b/packages/eslint-plugin/package.json
@@ -50,6 +50,7 @@
     "debug": "^4.3.4",
     "grapheme-splitter": "^1.0.4",
     "ignore": "^5.2.0",
+    "grapheme-splitter": "^1.0.4",
     "natural-compare-lite": "^1.4.0",
     "regexpp": "^3.2.0",
     "semver": "^7.3.7",
diff --git a/packages/eslint-plugin/src/configs/all.ts b/packages/eslint-plugin/src/configs/all.ts
index 20ea892f581..452035c4ebf 100644
--- a/packages/eslint-plugin/src/configs/all.ts
+++ b/packages/eslint-plugin/src/configs/all.ts
@@ -37,6 +37,8 @@ export = {
     '@typescript-eslint/indent': 'error',
     'init-declarations': 'off',
     '@typescript-eslint/init-declarations': 'error',
+    'key-spacing': 'off',
+    '@typescript-eslint/key-spacing': 'error',
     'keyword-spacing': 'off',
     '@typescript-eslint/keyword-spacing': 'error',
     'lines-between-class-members': 'off',
diff --git a/packages/eslint-plugin/src/rules/ban-ts-comment.ts b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
index f0bfce93ff6..511a951280e 100644
--- a/packages/eslint-plugin/src/rules/ban-ts-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
@@ -1,22 +1,7 @@
 import { AST_TOKEN_TYPES } from '@typescript-eslint/utils';
-import GraphemeSplitter from 'grapheme-splitter';
 
 import * as util from '../util';
 
-let splitter: GraphemeSplitter;
-function isASCII(value: string): boolean {
-  return /^[\u0020-\u007f]*$/u.test(value);
-}
-function getStringLength(value: string): number {
-  if (isASCII(value)) {
-    return value.length;
-  }
-
-  splitter ??= new GraphemeSplitter();
-
-  return splitter.countGraphemes(value);
-}
-
 type DirectiveConfig =
   | boolean
   | 'allow-with-description'
@@ -163,7 +148,8 @@ export default util.createRule<[Options], MessageIds>({
             } = options;
             const format = descriptionFormats.get(fullDirective);
             if (
-              getStringLength(description.trim()) < minimumDescriptionLength
+              util.getStringLength(description.trim()) <
+              minimumDescriptionLength
             ) {
               context.report({
                 data: { directive, minimumDescriptionLength },
diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts
index 8a3c2bbf437..f7e51fdabd5 100644
--- a/packages/eslint-plugin/src/rules/index.ts
+++ b/packages/eslint-plugin/src/rules/index.ts
@@ -22,6 +22,7 @@ import explicitModuleBoundaryTypes from './explicit-module-boundary-types';
 import funcCallSpacing from './func-call-spacing';
 import indent from './indent';
 import initDeclarations from './init-declarations';
+import keySpacing from './key-spacing';
 import keywordSpacing from './keyword-spacing';
 import linesBetweenClassMembers from './lines-between-class-members';
 import memberDelimiterStyle from './member-delimiter-style';
@@ -153,6 +154,7 @@ export default {
   'func-call-spacing': funcCallSpacing,
   indent: indent,
   'init-declarations': initDeclarations,
+  'key-spacing': keySpacing,
   'keyword-spacing': keywordSpacing,
   'lines-between-class-members': linesBetweenClassMembers,
   'member-delimiter-style': memberDelimiterStyle,
diff --git a/packages/eslint-plugin/src/rules/key-spacing.ts b/packages/eslint-plugin/src/rules/key-spacing.ts
new file mode 100644
index 00000000000..587d2674f4f
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/key-spacing.ts
@@ -0,0 +1,421 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+import * as util from '../util';
+import { getESLintCoreRule } from '../util/getESLintCoreRule';
+
+const baseRule = getESLintCoreRule('key-spacing');
+
+export type Options = util.InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = util.InferMessageIdsTypeFromRule<typeof baseRule>;
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const baseSchema = Array.isArray(baseRule.meta.schema)
+  ? baseRule.meta.schema[0]
+  : baseRule.meta.schema;
+
+export default util.createRule<Options, MessageIds>({
+  name: 'key-spacing',
+  meta: {
+    type: 'layout',
+    docs: {
+      description:
+        'Enforce consistent spacing between property names and type annotations in types and interfaces',
+      recommended: false,
+      extendsBaseRule: true,
+    },
+    fixable: 'whitespace',
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    schema: [baseSchema],
+    messages: baseRule.meta.messages,
+  },
+  defaultOptions: [{}],
+
+  create(context, [options]) {
+    const sourceCode = context.getSourceCode();
+    const baseRules = baseRule.create(context);
+
+    /**
+     * @returns the column of the position after converting all unicode characters in the line to 1 char length
+     */
+    function adjustedColumn(position: TSESTree.Position): number {
+      const line = position.line - 1; // position.line is 1-indexed
+      return util.getStringLength(
+        sourceCode.lines[line].slice(0, position.column),
+      );
+    }
+
+    /**
+     * Starting from the given a node (a property.key node here) looks forward
+     * until it finds the last token before a colon punctuator and returns it.
+     */
+    function getLastTokenBeforeColon(node: TSESTree.Node): TSESTree.Token {
+      const colonToken = sourceCode.getTokenAfter(node, util.isColonToken)!;
+
+      return sourceCode.getTokenBefore(colonToken)!;
+    }
+
+    type KeyTypeNode =
+      | TSESTree.TSIndexSignature
+      | TSESTree.TSPropertySignature
+      | TSESTree.PropertyDefinition;
+
+    type KeyTypeNodeWithTypeAnnotation = KeyTypeNode & {
+      typeAnnotation: TSESTree.TSTypeAnnotation;
+    };
+
+    function isKeyTypeNode(
+      node: TSESTree.Node,
+    ): node is KeyTypeNodeWithTypeAnnotation {
+      return (
+        (node.type === AST_NODE_TYPES.TSPropertySignature ||
+          node.type === AST_NODE_TYPES.TSIndexSignature ||
+          node.type === AST_NODE_TYPES.PropertyDefinition) &&
+        !!node.typeAnnotation
+      );
+    }
+
+    /**
+     * To handle index signatures, to get the whole text for the parameters
+     */
+    function getKeyText(node: KeyTypeNodeWithTypeAnnotation): string {
+      if (node.type !== AST_NODE_TYPES.TSIndexSignature) {
+        return sourceCode.getText(node.key);
+      }
+
+      const code = sourceCode.getText(node);
+      return code.slice(
+        0,
+        sourceCode.getTokenAfter(
+          node.parameters.at(-1)!,
+          util.isClosingBracketToken,
+        )!.range[1] - node.range[0],
+      );
+    }
+
+    /**
+     * To handle index signatures, be able to get the end position of the parameters
+     */
+    function getKeyLocEnd(
+      node: KeyTypeNodeWithTypeAnnotation,
+    ): TSESTree.Position {
+      return getLastTokenBeforeColon(
+        node.type !== AST_NODE_TYPES.TSIndexSignature
+          ? node.key
+          : node.parameters.at(-1)!,
+      ).loc.end;
+    }
+
+    function checkBeforeColon(
+      node: KeyTypeNodeWithTypeAnnotation,
+      expectedWhitespaceBeforeColon: number,
+      mode: 'strict' | 'minimum',
+    ): void {
+      const { typeAnnotation } = node;
+      const colon = typeAnnotation.loc.start.column;
+      const keyEnd = getKeyLocEnd(node);
+      const difference = colon - keyEnd.column - expectedWhitespaceBeforeColon;
+      if (mode === 'strict' ? difference : difference < 0) {
+        context.report({
+          node,
+          messageId: difference > 0 ? 'extraKey' : 'missingKey',
+          fix: fixer => {
+            if (difference > 0) {
+              return fixer.removeRange([
+                typeAnnotation.range[0] - difference,
+                typeAnnotation.range[0],
+              ]);
+            } else {
+              return fixer.insertTextBefore(
+                typeAnnotation,
+                ' '.repeat(-difference),
+              );
+            }
+          },
+          data: {
+            computed: '',
+            key: getKeyText(node),
+          },
+        });
+      }
+    }
+
+    function checkAfterColon(
+      node: KeyTypeNodeWithTypeAnnotation,
+      expectedWhitespaceAfterColon: number,
+      mode: 'strict' | 'minimum',
+    ): void {
+      const { typeAnnotation } = node;
+      const colon = typeAnnotation.loc.start.column;
+      const typeStart = typeAnnotation.typeAnnotation.loc.start.column;
+      const difference = typeStart - colon - 1 - expectedWhitespaceAfterColon;
+      if (mode === 'strict' ? difference : difference < 0) {
+        context.report({
+          node,
+          messageId: difference > 0 ? 'extraValue' : 'missingValue',
+          fix: fixer => {
+            if (difference > 0) {
+              return fixer.removeRange([
+                typeAnnotation.typeAnnotation.range[0] - difference,
+                typeAnnotation.typeAnnotation.range[0],
+              ]);
+            } else {
+              return fixer.insertTextBefore(
+                typeAnnotation.typeAnnotation,
+                ' '.repeat(-difference),
+              );
+            }
+          },
+          data: {
+            computed: '',
+            key: getKeyText(node),
+          },
+        });
+      }
+    }
+
+    // adapted from  https://github.com/eslint/eslint/blob/ba74253e8bd63e9e163bbee0540031be77e39253/lib/rules/key-spacing.js#L356
+    function continuesAlignGroup(
+      lastMember: TSESTree.Node,
+      candidate: TSESTree.Node,
+    ): boolean {
+      const groupEndLine = lastMember.loc.start.line;
+      const candidateValueStartLine = (
+        isKeyTypeNode(candidate) ? candidate.typeAnnotation : candidate
+      ).loc.start.line;
+
+      if (candidateValueStartLine === groupEndLine) {
+        return false;
+      }
+
+      if (candidateValueStartLine - groupEndLine === 1) {
+        return true;
+      }
+
+      /*
+       * Check that the first comment is adjacent to the end of the group, the
+       * last comment is adjacent to the candidate property, and that successive
+       * comments are adjacent to each other.
+       */
+      const leadingComments = sourceCode.getCommentsBefore(candidate);
+
+      if (
+        leadingComments.length &&
+        leadingComments[0].loc.start.line - groupEndLine <= 1 &&
+        candidateValueStartLine - leadingComments.at(-1)!.loc.end.line <= 1
+      ) {
+        for (let i = 1; i < leadingComments.length; i++) {
+          if (
+            leadingComments[i].loc.start.line -
+              leadingComments[i - 1].loc.end.line >
+            1
+          ) {
+            return false;
+          }
+        }
+        return true;
+      }
+
+      return false;
+    }
+
+    function checkAlignGroup(group: TSESTree.Node[]): void {
+      let alignColumn = 0;
+      const align: 'value' | 'colon' =
+        (typeof options.align === 'object'
+          ? options.align.on
+          : typeof options.multiLine?.align === 'object'
+          ? options.multiLine.align.on
+          : options.multiLine?.align ?? options.align) ?? 'colon';
+      const beforeColon =
+        (typeof options.align === 'object'
+          ? options.align.beforeColon
+          : options.multiLine
+          ? typeof options.multiLine.align === 'object'
+            ? options.multiLine.align.beforeColon
+            : options.multiLine.beforeColon
+          : options.beforeColon) ?? false;
+      const expectedWhitespaceBeforeColon = beforeColon ? 1 : 0;
+      const afterColon =
+        (typeof options.align === 'object'
+          ? options.align.afterColon
+          : options.multiLine
+          ? typeof options.multiLine.align === 'object'
+            ? options.multiLine.align.afterColon
+            : options.multiLine.afterColon
+          : options.afterColon) ?? true;
+      const expectedWhitespaceAfterColon = afterColon ? 1 : 0;
+      const mode =
+        (typeof options.align === 'object'
+          ? options.align.mode
+          : options.multiLine
+          ? typeof options.multiLine.align === 'object'
+            ? // same behavior as in original rule
+              options.multiLine.align.mode ?? options.multiLine.mode
+            : options.multiLine.mode
+          : options.mode) ?? 'strict';
+
+      for (const node of group) {
+        if (isKeyTypeNode(node)) {
+          const keyEnd = adjustedColumn(getKeyLocEnd(node));
+          alignColumn = Math.max(
+            alignColumn,
+            align === 'colon'
+              ? keyEnd + expectedWhitespaceBeforeColon
+              : keyEnd +
+                  ':'.length +
+                  expectedWhitespaceAfterColon +
+                  expectedWhitespaceBeforeColon,
+          );
+        }
+      }
+
+      for (const node of group) {
+        if (!isKeyTypeNode(node)) {
+          continue;
+        }
+        const { typeAnnotation } = node;
+        const toCheck =
+          align === 'colon' ? typeAnnotation : typeAnnotation.typeAnnotation;
+        const difference = adjustedColumn(toCheck.loc.start) - alignColumn;
+
+        if (difference) {
+          context.report({
+            node,
+            messageId:
+              difference > 0
+                ? align === 'colon'
+                  ? 'extraKey'
+                  : 'extraValue'
+                : align === 'colon'
+                ? 'missingKey'
+                : 'missingValue',
+            fix: fixer => {
+              if (difference > 0) {
+                return fixer.removeRange([
+                  toCheck.range[0] - difference,
+                  toCheck.range[0],
+                ]);
+              } else {
+                return fixer.insertTextBefore(toCheck, ' '.repeat(-difference));
+              }
+            },
+            data: {
+              computed: '',
+              key: getKeyText(node),
+            },
+          });
+        }
+
+        if (align === 'colon') {
+          checkAfterColon(node, expectedWhitespaceAfterColon, mode);
+        } else {
+          checkBeforeColon(node, expectedWhitespaceBeforeColon, mode);
+        }
+      }
+    }
+
+    function checkIndividualNode(
+      node: TSESTree.Node,
+      { singleLine }: { singleLine: boolean },
+    ): void {
+      const beforeColon =
+        (singleLine
+          ? options.singleLine
+            ? options.singleLine.beforeColon
+            : options.beforeColon
+          : options.multiLine
+          ? options.multiLine.beforeColon
+          : options.beforeColon) ?? false;
+      const expectedWhitespaceBeforeColon = beforeColon ? 1 : 0;
+      const afterColon =
+        (singleLine
+          ? options.singleLine
+            ? options.singleLine.afterColon
+            : options.afterColon
+          : options.multiLine
+          ? options.multiLine.afterColon
+          : options.afterColon) ?? true;
+      const expectedWhitespaceAfterColon = afterColon ? 1 : 0;
+      const mode =
+        (singleLine
+          ? options.singleLine
+            ? options.singleLine.mode
+            : options.mode
+          : options.multiLine
+          ? options.multiLine.mode
+          : options.mode) ?? 'strict';
+
+      if (isKeyTypeNode(node)) {
+        checkBeforeColon(node, expectedWhitespaceBeforeColon, mode);
+        checkAfterColon(node, expectedWhitespaceAfterColon, mode);
+      }
+    }
+
+    function validateBody(
+      body:
+        | TSESTree.TSTypeLiteral
+        | TSESTree.TSInterfaceBody
+        | TSESTree.ClassBody,
+    ): void {
+      const isSingleLine = body.loc.start.line === body.loc.end.line;
+
+      const members =
+        body.type === AST_NODE_TYPES.TSTypeLiteral ? body.members : body.body;
+
+      let alignGroups: TSESTree.Node[][] = [];
+      let unalignedElements: TSESTree.Node[] = [];
+
+      if (options.align || options.multiLine?.align) {
+        let currentAlignGroup: TSESTree.Node[] = [];
+        alignGroups.push(currentAlignGroup);
+
+        let prevNode: TSESTree.Node | undefined = undefined;
+
+        for (const node of members) {
+          let prevAlignedNode = currentAlignGroup.at(-1);
+          if (prevAlignedNode !== prevNode) {
+            prevAlignedNode = undefined;
+          }
+
+          if (prevAlignedNode && continuesAlignGroup(prevAlignedNode, node)) {
+            currentAlignGroup.push(node);
+          } else if (prevNode?.loc.start.line === node.loc.start.line) {
+            if (prevAlignedNode) {
+              // Here, prevNode === prevAlignedNode === currentAlignGroup.at(-1)
+              unalignedElements.push(prevAlignedNode);
+              currentAlignGroup.pop();
+            }
+            unalignedElements.push(node);
+          } else {
+            currentAlignGroup = [node];
+            alignGroups.push(currentAlignGroup);
+          }
+
+          prevNode = node;
+        }
+
+        unalignedElements = unalignedElements.concat(
+          ...alignGroups.filter(group => group.length === 1),
+        );
+        alignGroups = alignGroups.filter(group => group.length >= 2);
+      } else {
+        unalignedElements = members;
+      }
+
+      for (const group of alignGroups) {
+        checkAlignGroup(group);
+      }
+
+      for (const node of unalignedElements) {
+        checkIndividualNode(node, { singleLine: isSingleLine });
+      }
+    }
+    return {
+      ...baseRules,
+      TSTypeLiteral: validateBody,
+      TSInterfaceBody: validateBody,
+      ClassBody: validateBody,
+    };
+  },
+});
diff --git a/packages/eslint-plugin/src/util/getESLintCoreRule.ts b/packages/eslint-plugin/src/util/getESLintCoreRule.ts
index 1678903acd3..80962a677b0 100644
--- a/packages/eslint-plugin/src/util/getESLintCoreRule.ts
+++ b/packages/eslint-plugin/src/util/getESLintCoreRule.ts
@@ -12,6 +12,7 @@ interface RuleMap {
   'dot-notation': typeof import('eslint/lib/rules/dot-notation');
   indent: typeof import('eslint/lib/rules/indent');
   'init-declarations': typeof import('eslint/lib/rules/init-declarations');
+  'key-spacing': typeof import('eslint/lib/rules/key-spacing');
   'keyword-spacing': typeof import('eslint/lib/rules/keyword-spacing');
   'lines-between-class-members': typeof import('eslint/lib/rules/lines-between-class-members');
   'no-dupe-args': typeof import('eslint/lib/rules/no-dupe-args');
diff --git a/packages/eslint-plugin/src/util/getStringLength.ts b/packages/eslint-plugin/src/util/getStringLength.ts
new file mode 100644
index 00000000000..65a22551949
--- /dev/null
+++ b/packages/eslint-plugin/src/util/getStringLength.ts
@@ -0,0 +1,17 @@
+import GraphemeSplitter from 'grapheme-splitter';
+
+let splitter: GraphemeSplitter;
+
+function isASCII(value: string): boolean {
+  return /^[\u0020-\u007f]*$/u.test(value);
+}
+
+export function getStringLength(value: string): number {
+  if (isASCII(value)) {
+    return value.length;
+  }
+
+  splitter ??= new GraphemeSplitter();
+
+  return splitter.countGraphemes(value);
+}
diff --git a/packages/eslint-plugin/src/util/index.ts b/packages/eslint-plugin/src/util/index.ts
index b2ad2927773..53a19a96d36 100644
--- a/packages/eslint-plugin/src/util/index.ts
+++ b/packages/eslint-plugin/src/util/index.ts
@@ -5,6 +5,7 @@ export * from './collectUnusedVariables';
 export * from './createRule';
 export * from './getFunctionHeadLoc';
 export * from './getOperatorPrecedence';
+export * from './getStringLength';
 export * from './getThisExpression';
 export * from './getWrappingFixer';
 export * from './isNodeEqual';
diff --git a/packages/eslint-plugin/tests/rules/key-spacing.test.ts b/packages/eslint-plugin/tests/rules/key-spacing.test.ts
new file mode 100644
index 00000000000..40206258671
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/key-spacing.test.ts
@@ -0,0 +1,1278 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests the new lines, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+import rule from '../../src/rules/key-spacing';
+import { RuleTester } from '../RuleTester';
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+});
+
+ruleTester.run('key-spacing', rule, {
+  valid: [
+    // align: value
+    {
+      code: `
+interface X {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+interface X {
+  "a:b": number;
+  abcde: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+let x: {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+let x: {
+  a:   number;
+  "𐌘": string;
+  [𐌘]: Date;
+  "🌷": "bar", // 2 code points
+  "🎁": "baz", // 2 code points
+  "🇮🇳": "qux", // 4 code points
+  "🏳️‍🌈": "xyz", // 6 code points
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+interface X {
+  a: number;
+  abc: string; c: number;
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+interface X {
+  a: number;
+  abc: string; c: number; de: boolean;
+  abcef: number;
+};
+      `,
+      options: [{ align: 'colon' }],
+    },
+    {
+      code: `
+interface X {
+  a    : number;
+  abc;
+  abcef: number;
+};
+      `,
+      options: [{ align: 'colon' }],
+    },
+    {
+      code: `
+interface X {
+  a?:  number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+interface X {
+  a:   number;
+  // Some comment
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+interface X {
+  a:   number;
+  // Some comment
+  // on multiple lines
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+interface X {
+  a:   number;
+  /**
+   * Some comment
+   * on multiple lines
+   */
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+interface X {
+  a:   number;
+  /**
+   * Doc comment
+  */
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+interface X {
+  a: number;
+
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+class X {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+class X {
+  a?:  number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+class X {
+  x:     number;
+  z = 1;
+  xbcef: number;
+  }
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+class X {
+  a: number;
+
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+type X = {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+type X = {
+  a: number;
+
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+type X = {
+  a :  number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value', mode: 'minimum' }],
+    },
+    {
+      code: `
+type X = {
+  a :  number;
+  abc: string
+};
+      `,
+      options: [
+        {
+          align: {
+            on: 'value',
+            mode: 'minimum',
+            beforeColon: false,
+            afterColon: true,
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a:    number;
+  prop: {
+    abc: number;
+    a:   number;
+  };
+  abc: string
+}
+      `,
+      options: [{ align: 'value' }],
+    },
+    {
+      code: `
+class X {
+  a:    number;
+  prop: {
+    abc: number;
+    a:   number;
+  };
+  abc: string
+  x = 1;
+  d:   number;
+  z:   number = 1;
+  ef:  string;
+}
+      `,
+      options: [{ align: 'value' }],
+    },
+    // align: colon
+    {
+      code: `
+interface X {
+  a  : number;
+  abc: string
+};
+      `,
+      options: [{ align: 'colon' }],
+    },
+    {
+      code: `
+interface X {
+  a  :number;
+  abc:string
+};
+      `,
+      options: [{ align: 'colon', afterColon: false }],
+    },
+    {
+      code: `
+interface X {
+  a  :   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'colon', mode: 'minimum' }],
+    },
+    // no align
+    {
+      code: `
+interface X {
+  a: number;
+  abc: string
+};
+      `,
+      options: [{}],
+    },
+    {
+      code: `
+interface X {
+  a : number;
+  abc : string
+};
+      `,
+      options: [{ beforeColon: true }],
+    },
+    // singleLine / multiLine
+    {
+      code: `
+interface X {
+  a : number;
+  abc : string
+};
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: { beforeColon: true, afterColon: true },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a :   number;
+  abc : string
+};
+      `,
+      options: [
+        {
+          align: { on: 'value', beforeColon: true, afterColon: true },
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: { beforeColon: false, afterColon: false },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a   : number;
+  abc : string
+};
+      `,
+      options: [
+        {
+          align: { beforeColon: true, afterColon: true }, // defaults to 'colon'
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: { beforeColon: false, afterColon: false },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a :   number;
+  abc : string
+};
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: { beforeColon: true, afterColon: true, align: 'value' },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a   : number;
+  abc : string
+};
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: {
+            beforeColon: true,
+            afterColon: true,
+            align: {
+              on: 'colon',
+              mode: 'strict',
+              afterColon: true,
+              beforeColon: true,
+            },
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a   : number;
+  abc : string
+};
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: {
+            beforeColon: true,
+            afterColon: true,
+            align: {
+              mode: 'strict',
+              afterColon: true,
+              beforeColon: true,
+            },
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a   : number;
+  abc : string
+};
+      `,
+      options: [
+        {
+          beforeColon: true,
+          afterColon: true,
+          align: {
+            on: 'colon',
+            mode: 'strict',
+            afterColon: true,
+            beforeColon: true,
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a   : number;
+  abc : string
+};
+      `,
+      options: [
+        {
+          beforeColon: true,
+          afterColon: true,
+          align: {
+            mode: 'strict',
+            afterColon: true,
+            beforeColon: true,
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a  : number;
+  abc: string
+
+  xadzd : number;
+};
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: {
+            beforeColon: true,
+            afterColon: true,
+            align: {
+              on: 'colon',
+              mode: 'strict',
+              afterColon: true,
+              beforeColon: false,
+            },
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a  : number;
+  abc: string
+
+  xadzd : number;
+};
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: {
+            beforeColon: true,
+            afterColon: true,
+            mode: 'strict',
+            align: {
+              on: 'colon',
+              afterColon: true,
+              beforeColon: false,
+            },
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a  :    number;
+  abc: string
+
+  xadzd :    number;
+};
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: {
+            beforeColon: true,
+            afterColon: true,
+            mode: 'minimum',
+            align: {
+              on: 'colon',
+              afterColon: true,
+              beforeColon: false,
+            },
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface X { a:number; abc:string; };
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: { beforeColon: true, afterColon: true },
+        },
+      ],
+    },
+  ],
+  invalid: [
+    // align: value
+    {
+      code: `
+interface X {
+  a: number;
+  abc: string
+};
+      `,
+      output: `
+interface X {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+interface X {
+  a: number;
+  "a:c": string
+};
+      `,
+      output: `
+interface X {
+  a:     number;
+  "a:c": string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+let x: {
+  a: number;
+  abc: string
+};
+      `,
+      output: `
+let x: {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+let x: {
+  a: number;
+  abc: string
+};
+      `,
+      output: `
+let x: {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: { on: 'value' } }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+let x: {
+  a: number;
+  "🌷": "bar", // 2 code points
+  "🎁": "baz", // 2 code points
+  "🇮🇳": "qux", // 4 code points
+  "🏳️‍🌈": "xyz", // 6 code points
+  [𐌘]: string
+  "𐌘": string
+};
+      `,
+      output: `
+let x: {
+  a:   number;
+  "🌷": "bar", // 2 code points
+  "🎁": "baz", // 2 code points
+  "🇮🇳": "qux", // 4 code points
+  "🏳️‍🌈": "xyz", // 6 code points
+  [𐌘]: string
+  "𐌘": string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+class X {
+  a: number;
+  abc: string
+};
+      `,
+      output: `
+class X {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+class X {
+  a: number;
+  abc: string
+};
+      `,
+      output: `
+class X {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value', mode: 'minimum' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+class X {
+  a: number;
+  b;
+  abc: string
+};
+      `,
+      output: `
+class X {
+  a:   number;
+  b;
+  abc: string
+};
+      `,
+      options: [{ align: 'value', mode: 'minimum' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+type X = {
+  a: number;
+  abc: string
+};
+      `,
+      output: `
+type X = {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+interface X {
+  a:   number;
+  abc:  string
+};
+      `,
+      output: `
+interface X {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'extraValue' }],
+    },
+    {
+      code: `
+class X {
+  a:   number;
+  abc:  string
+};
+      `,
+      output: `
+class X {
+  a:   number;
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'extraValue' }],
+    },
+    {
+      code: `
+class X {
+  x:   number;
+  z = 1;
+  xbcef: number;
+  }
+      `,
+      output: `
+class X {
+  x:     number;
+  z = 1;
+  xbcef: number;
+  }
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+interface X {
+  a:   number;
+
+  abc     : string
+};
+      `,
+      output: `
+interface X {
+  a: number;
+
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'extraValue' }, { messageId: 'extraKey' }],
+    },
+    {
+      code: `
+class X {
+  a:   number;
+
+  abc     : string
+};
+      `,
+      output: `
+class X {
+  a: number;
+
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'extraValue' }, { messageId: 'extraKey' }],
+    },
+    {
+      code: `
+interface X {
+  a:   number;
+  // Some comment
+
+  // interrupted in the middle
+  abc: string
+};
+      `,
+      output: `
+interface X {
+  a: number;
+  // Some comment
+
+  // interrupted in the middle
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'extraValue' }],
+    },
+    {
+      code: `
+interface X {
+  a:   number;
+  /**
+   * Multiline comment
+   */
+
+  /** interrupted in the middle */
+  abc: string
+};
+      `,
+      output: `
+interface X {
+  a: number;
+  /**
+   * Multiline comment
+   */
+
+  /** interrupted in the middle */
+  abc: string
+};
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'extraValue' }],
+    },
+    {
+      code: `
+interface X {
+  a:   number;
+  prop: {
+    abc: number;
+    a:   number;
+  },
+  abc: string
+}
+      `,
+      output: `
+interface X {
+  a:    number;
+  prop: {
+    abc: number;
+    a:   number;
+  },
+  abc: string
+}
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+interface X {
+  a:    number;
+  prop: {
+    abc: number;
+    a:  number;
+  },
+  abc: string
+}
+      `,
+      output: `
+interface X {
+  a:    number;
+  prop: {
+    abc: number;
+    a:   number;
+  },
+  abc: string
+}
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'missingValue' }],
+    },
+    {
+      code: `
+interface X {
+  a:    number;
+  prop: {
+    abc: number;
+    a:   number;
+  },
+  abc:  string
+}
+      `,
+      output: `
+interface X {
+  a:    number;
+  prop: {
+    abc: number;
+    a:   number;
+  },
+  abc: string
+}
+      `,
+      options: [{ align: 'value' }],
+      errors: [{ messageId: 'extraValue' }],
+    },
+    {
+      code: `
+class X {
+  a:      number;
+  prop: {
+    abc: number;
+    a?: number;
+  };
+  abc: string;
+  x = 1;
+  d: number;
+  z:  number = 1;
+  ef: string;
+}
+      `,
+      output: `
+class X {
+  a:    number;
+  prop: {
+    abc: number;
+    a?:  number;
+  };
+  abc: string;
+  x = 1;
+  d:   number;
+  z:   number = 1;
+  ef:  string;
+}
+      `,
+      options: [{ align: 'value' }],
+      errors: [
+        { messageId: 'extraValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+      ],
+    },
+    // align: colon
+    {
+      code: `
+interface X {
+  a   : number;
+  abc: string
+};
+      `,
+      output: `
+interface X {
+  a  : number;
+  abc: string
+};
+      `,
+      options: [{ align: 'colon' }],
+      errors: [{ messageId: 'extraKey' }],
+    },
+    {
+      code: `
+interface X {
+  a   : number;
+  abc: string
+};
+      `,
+      output: `
+interface X {
+  a  : number;
+  abc: string
+};
+      `,
+      options: [{ align: { on: 'colon' } }],
+      errors: [{ messageId: 'extraKey' }],
+    },
+    {
+      code: `
+interface X {
+  a   : number;
+  abc: string
+};
+      `,
+      output: `
+interface X {
+  a   : number;
+  abc : string
+};
+      `,
+      options: [{ align: 'colon', beforeColon: true, afterColon: true }],
+      errors: [{ messageId: 'missingKey' }],
+    },
+    // no align
+    {
+      code: `
+interface X {
+  [x: number]:  string;
+}
+      `,
+      output: `
+interface X {
+  [x: number]: string;
+}
+      `,
+      errors: [{ messageId: 'extraValue' }],
+    },
+    {
+      code: `
+interface X {
+  [x: number]:string;
+}
+      `,
+      output: `
+interface X {
+  [x: number]: string;
+}
+      `,
+      errors: [{ messageId: 'missingValue' }],
+    },
+    // singleLine / multiLine
+    {
+      code: `
+interface X {
+  a:number;
+  abc:string
+};
+      `,
+      output: `
+interface X {
+  a : number;
+  abc : string
+};
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: { beforeColon: true, afterColon: true },
+        },
+      ],
+      errors: [
+        { messageId: 'missingKey' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingKey' },
+        { messageId: 'missingValue' },
+      ],
+    },
+    {
+      code: `
+interface X { a : number; abc : string; };
+      `,
+      output: `
+interface X { a:number; abc:string; };
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: false },
+          multiLine: { beforeColon: true, afterColon: true },
+        },
+      ],
+      errors: [
+        { messageId: 'extraKey' },
+        { messageId: 'extraValue' },
+        { messageId: 'extraKey' },
+        { messageId: 'extraValue' },
+      ],
+    },
+    {
+      code: `
+interface X { a : number; abc : string; };
+      `,
+      output: `
+interface X { a: number; abc: string; };
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: false, afterColon: true },
+          multiLine: { beforeColon: true, afterColon: true },
+        },
+      ],
+      errors: [{ messageId: 'extraKey' }, { messageId: 'extraKey' }],
+    },
+    {
+      code: `
+interface X { a:number; abc:string; };
+      `,
+      output: `
+interface X { a : number; abc : string; };
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: true, afterColon: true, mode: 'strict' },
+          multiLine: { beforeColon: true, afterColon: true },
+        },
+      ],
+      errors: [
+        { messageId: 'missingKey' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingKey' },
+        { messageId: 'missingValue' },
+      ],
+    },
+    {
+      code: `
+interface X { a:number; abc:   string; };
+      `,
+      output: `
+interface X { a : number; abc :   string; };
+      `,
+      options: [
+        {
+          singleLine: { beforeColon: true, afterColon: true, mode: 'minimum' },
+          multiLine: { beforeColon: true, afterColon: true },
+        },
+      ],
+      errors: [
+        { messageId: 'missingKey' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingKey' },
+      ],
+    },
+    {
+      code: `
+interface X { a : number; abc : string; };
+      `,
+      output: `
+interface X { a:number; abc:string; };
+      `,
+      options: [
+        {
+          beforeColon: false,
+          afterColon: false,
+        },
+      ],
+      errors: [
+        { messageId: 'extraKey' },
+        { messageId: 'extraValue' },
+        { messageId: 'extraKey' },
+        { messageId: 'extraValue' },
+      ],
+    },
+    {
+      code: `
+interface X { a:number; abc:string; };
+      `,
+      output: `
+interface X { a : number; abc : string; };
+      `,
+      options: [
+        {
+          beforeColon: true,
+          afterColon: true,
+          mode: 'strict',
+        },
+      ],
+      errors: [
+        { messageId: 'missingKey' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingKey' },
+        { messageId: 'missingValue' },
+      ],
+    },
+    {
+      code: `
+type Wacky = {
+    a: number;
+    b: string;
+    agc: number;
+    middle: Date | {
+        inner: {
+            a: boolean;
+            bc: boolean;
+            "🌷": "rose";
+        }
+        [x: number]: string;
+        abc: boolean;
+    }
+} & {
+    a: "string";
+    abc: number;
+}
+      `,
+      output: `
+type Wacky = {
+    a:      number;
+    b:      string;
+    agc:    number;
+    middle: Date | {
+        inner: {
+            a:   boolean;
+            bc:  boolean;
+            "🌷": "rose";
+        }
+        [x: number]: string;
+        abc:         boolean;
+    }
+} & {
+    a:   "string";
+    abc: number;
+}
+      `,
+      options: [{ align: 'value' }],
+      errors: [
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+      ],
+    },
+    {
+      code: `
+class Wacky {
+    a: number;
+    b?: string;
+    public z: number;
+    abc = 10;
+    private override xy: number;
+    static x = "test";
+    static abcdef: number = 1;
+    get fn(): number { return 0; };
+    inter: number;
+    get fn2(): number {
+      return 1;
+    };
+    agc: number;
+    middle: Date | {
+        inner: {
+            a: boolean;
+            bc: boolean;
+            "🌷": "rose";
+        }
+        [x: number]: string;
+        abc: boolean;
+    }
+}
+      `,
+      output: `
+class Wacky {
+    a:                   number;
+    b?:                  string;
+    public z:            number;
+    abc = 10;
+    private override xy: number;
+    static x = "test";
+    static abcdef:       number = 1;
+    get fn(): number { return 0; };
+    inter:               number;
+    get fn2(): number {
+      return 1;
+    };
+    agc:    number;
+    middle: Date | {
+        inner: {
+            a:   boolean;
+            bc:  boolean;
+            "🌷": "rose";
+        }
+        [x: number]: string;
+        abc:         boolean;
+    }
+}
+      `,
+      options: [{ align: 'value' }],
+      errors: [
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+        { messageId: 'missingValue' },
+      ],
+    },
+  ],
+});
diff --git a/packages/eslint-plugin/typings/eslint-rules.d.ts b/packages/eslint-plugin/typings/eslint-rules.d.ts
index 09b54ae4a51..38682f60c5b 100644
--- a/packages/eslint-plugin/typings/eslint-rules.d.ts
+++ b/packages/eslint-plugin/typings/eslint-rules.d.ts
@@ -141,6 +141,58 @@ declare module 'eslint/lib/rules/indent' {
   export = rule;
 }
 
+declare module 'eslint/lib/rules/key-spacing' {
+  import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+  import type { RuleFunction } from '@typescript-eslint/utils/dist/ts-eslint';
+
+  type Options = [
+    {
+      beforeColon?: boolean;
+      afterColon?: boolean;
+      mode?: 'strict' | 'minimum';
+      align?:
+        | 'value'
+        | 'colon'
+        | {
+            on?: 'value' | 'colon';
+            beforeColon?: boolean;
+            afterColon?: boolean;
+            mode?: 'strict' | 'minimum';
+          };
+      singleLine?: {
+        beforeColon?: boolean;
+        afterColon?: boolean;
+        mode?: 'strict' | 'minimum';
+      };
+      multiLine?: {
+        beforeColon?: boolean;
+        afterColon?: boolean;
+        mode?: 'strict' | 'minimum';
+        align?:
+          | 'value'
+          | 'colon'
+          | {
+              on?: 'value' | 'colon';
+              beforeColon?: boolean;
+              afterColon?: boolean;
+              mode?: 'strict' | 'minimum';
+            };
+      };
+    },
+  ];
+  type MessageIds = 'extraKey' | 'extraValue' | 'missingKey' | 'missingValue';
+
+  const rule: TSESLint.RuleModule<
+    MessageIds,
+    Options,
+    {
+      ObjectExpression: RuleFunction<TSESTree.ObjectExpression>;
+      Property: RuleFunction<TSESTree.Property>;
+    }
+  >;
+  export = rule;
+}
+
 declare module 'eslint/lib/rules/keyword-spacing' {
   import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
   import type { RuleFunction } from '@typescript-eslint/utils/dist/ts-eslint';