Repository: eslint-stylistic/eslint-stylistic
Pull request #883 (2025-07-14 13:42:26)

fix: disallow extra properties in rule options
<!-- DO NOT IGNORE THE TEMPLATE!

Thank you for contributing!

Before submitting the PR, please make sure you do the following:

- Read the [Contributing Guide](https://eslint.style/contribute/guide).
- Check that there isn't already a PR that solves the problem the same way to avoid creating a duplicate.
- Provide a description in this PR that addresses **what** the PR is solving, or reference the issue that it solves (e.g. `fixes #123`).
- Ideally, include relevant tests that fail without this PR but pass with it.

-->

### Description

Some rules, for example [jsx-curly-spacing](https://github.com/eslint-stylistic/eslint-stylistic/blob/4a5fe59f528021fa2e6e8f787d2f21a69739391b/packages/eslint-plugin/rules/jsx-curly-spacing/jsx-curly-spacing.ts#L45) allow extra properties to be passed in options object, which should not be allowed. This makes it easier for typos in rule options to go unnoticed.

This PR simply disallows extra properties in rules' schemas which currently allow them.

### Linked Issues

### Additional context

Touched rules:
- jsx-curly-spacing
- jsx-indent-props
- jsx-max-props-per-line
- multiline-ternary

<!-- e.g. is there anything you'd like reviewers to focus on? -->


pkg-pr-new[bot]: 
[Open in StackBlitz](https://pkg.pr.new/template/02569cfd-ee23-4879-a4d0-b8ea95c2d50a)


```
npm i https://pkg.pr.new/@stylistic/eslint-plugin@883
```


```
npm i https://pkg.pr.new/@eslint-stylistic/metadata@883
```


_commit: <a href="https://github.com/eslint-stylistic/eslint-stylistic/runs/45930914272"><code>cdfd093</code></a>_

codecov[bot]: ## [Bundle](https://app.codecov.io/gh/eslint-stylistic/eslint-stylistic/pull/883?dropdown=bundle) Report

Changes will increase total bundle size by 243 bytes (0.03%) :arrow_up:. This is within the [configured](https://docs.codecov.com/docs/javascript-bundle-analysis#main-features) threshold :white_check_mark:

<details><summary>Detailed changes</summary>

| Bundle name | Size | Change |
| ----------- | ---- | ------ |
| @stylistic/eslint-plugin-esm | 771.4kB | 243 bytes (0.03%) :arrow_up: |

</details>

### Affected Assets, Files, and Routes:

<details>
<summary>view changes for bundle: @stylistic/eslint-plugin-esm</summary>

#### **Assets Changed:**
| Asset Name | Size Change | Total Size | Change (%) |
| ---------- | ----------- | ---------- | ---------- |
| ```rules/jsx-curly-spacing.js``` | 142 bytes | 10.99kB | 1.31%  |
| ```rules/multiline-ternary.js``` | 33 bytes | 5.06kB | 0.66%  |
| ```rules/jsx-indent-props.js``` | 34 bytes | 4.06kB | 0.84%  |
| ```rules/jsx-max-props-per-line.js``` | 34 bytes | 3.45kB | 1.0%  |


**Files in** **```rules/jsx-curly-spacing.js```**:

- ```./rules/jsx-curly-spacing/jsx-curly-spacing.ts``` → Total Size: **10.86kB**



**Files in** **```rules/multiline-ternary.js```**:

- ```./rules/multiline-ternary/multiline-ternary.ts``` → Total Size: **4.92kB**



**Files in** **```rules/jsx-indent-props.js```**:

- ```./rules/jsx-indent-props/jsx-indent-props.ts``` → Total Size: **3.92kB**



**Files in** **```rules/jsx-max-props-per-line.js```**:

- ```./rules/jsx-max-props-per-line/jsx-max-props-per-line.ts``` → Total Size: **3.3kB**





</details>

9romise: Oops, looks like something is broken, I'll have a check later.

Patch:
diff --git a/packages/eslint-plugin/configs/customize.ts b/packages/eslint-plugin/configs/customize.ts
index 7cb547a0..ece76787 100644
--- a/packages/eslint-plugin/configs/customize.ts
+++ b/packages/eslint-plugin/configs/customize.ts
@@ -44,8 +44,8 @@ export function customize(options: StylisticCustomizeOptions = {}): Linter.Confi
       ArrayExpression: 1,
       CallExpression: { arguments: 1 },
       flatTernaryExpressions: false,
-      FunctionDeclaration: { body: 1, parameters: 1 },
-      FunctionExpression: { body: 1, parameters: 1 },
+      FunctionDeclaration: { body: 1, parameters: 1, returnType: 1 },
+      FunctionExpression: { body: 1, parameters: 1, returnType: 1 },
       ignoreComments: false,
       ignoredNodes: [
         'TSUnionType',
diff --git a/packages/eslint-plugin/rules/computed-property-spacing/computed-property-spacing.ts b/packages/eslint-plugin/rules/computed-property-spacing/computed-property-spacing.ts
index 8823b06f..4fe5cb16 100644
--- a/packages/eslint-plugin/rules/computed-property-spacing/computed-property-spacing.ts
+++ b/packages/eslint-plugin/rules/computed-property-spacing/computed-property-spacing.ts
@@ -177,6 +177,7 @@ export default createRule<RuleOptions, MessageIds>({
     type NodeType
       = | Tree.Property
         | Tree.PropertyDefinition
+        | Tree.AccessorProperty
         | Tree.MemberExpression
         | Tree.MethodDefinition
 
@@ -188,6 +189,7 @@ export default createRule<RuleOptions, MessageIds>({
     if (enforceForClassMembers) {
       listeners.MethodDefinition = checkSpacing<Tree.MethodDefinition>('key')
       listeners.PropertyDefinition = checkSpacing<Tree.PropertyDefinition>('key')
+      listeners.AccessorProperty = checkSpacing<Tree.AccessorProperty>('key')
     }
 
     return listeners
diff --git a/packages/eslint-plugin/rules/indent/README.md b/packages/eslint-plugin/rules/indent/README.md
index 958939b5..d6adef87 100644
--- a/packages/eslint-plugin/rules/indent/README.md
+++ b/packages/eslint-plugin/rules/indent/README.md
@@ -90,9 +90,11 @@ This rule has an object option:
 - `"FunctionDeclaration"` takes an object to define rules for function declarations.
   - `parameters` (default: 1) enforces indentation level for parameters in a function declaration. This can either be a number indicating indentation level, or the string `"first"` indicating that all parameters of the declaration must be aligned with the first parameter. This can also be set to `"off"` to disable checking for FunctionDeclaration parameters.
   - `body` (default: 1) enforces indentation level for the body of a function declaration.
+  - `returnType` (default: 1) enforces indentation level for the return type of a function declaration.
 - `"FunctionExpression"` takes an object to define rules for function expressions.
   - `parameters` (default: 1) enforces indentation level for parameters in a function expression. This can either be a number indicating indentation level, or the string `"first"` indicating that all parameters of the expression must be aligned with the first parameter. This can also be set to `"off"` to disable checking for FunctionExpression parameters.
   - `body` (default: 1) enforces indentation level for the body of a function expression.
+  - `returnType` (default: 1) enforces indentation level for the return type of a function expression.
 - `"StaticBlock"` takes an object to define rules for class static blocks.
   - `body` (default: 1) enforces indentation level for the body of a class static block.
 - `"CallExpression"` takes an object to define rules for function call expressions.
@@ -504,34 +506,44 @@ foo
 
 ### FunctionDeclaration
 
-Examples of **incorrect** code for this rule with the `2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }` option:
+Examples of **incorrect** code for this rule with the `2, { "FunctionDeclaration": {"body": 1, "parameters": 2, "returnType": 1} }` option:
 
 ::: incorrect
 
 ```js
-/* eslint @stylistic/indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }] */
+/* eslint @stylistic/indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2, "returnType": 1} }] */
 
 function foo(bar,
   baz,
   qux) {
     qux();
 }
+
+function foo(a: string)
+: a is 'a' {
+  return bar()
+}
 ```
 
 :::
 
-Examples of **correct** code for this rule with the `2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }` option:
+Examples of **correct** code for this rule with the `2, { "FunctionDeclaration": {"body": 1, "parameters": 2, "returnType": 1} }` option:
 
 ::: correct
 
 ```js
-/* eslint @stylistic/indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }] */
+/* eslint @stylistic/indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2, "returnType": 1} }] */
 
 function foo(bar,
     baz,
     qux) {
   qux();
 }
+
+function foo(a: string)
+  : a is 'a' {
+  return bar()
+}
 ```
 
 :::
@@ -568,34 +580,44 @@ function foo(bar, baz,
 
 ### FunctionExpression
 
-Examples of **incorrect** code for this rule with the `2, { "FunctionExpression": {"body": 1, "parameters": 2} }` option:
+Examples of **incorrect** code for this rule with the `2, { "FunctionExpression": {"body": 1, "parameters": 2, "returnType": 1} }` option:
 
 ::: incorrect
 
 ```js
-/* eslint @stylistic/indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }] */
+/* eslint @stylistic/indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2, "returnType": 1} }] */
 
 var foo = function(bar,
   baz,
   qux) {
     qux();
 }
+
+const foo = function(a: string)
+: a is 'a' {
+  return bar()
+}
 ```
 
 :::
 
-Examples of **correct** code for this rule with the `2, { "FunctionExpression": {"body": 1, "parameters": 2} }` option:
+Examples of **correct** code for this rule with the `2, { "FunctionExpression": {"body": 1, "parameters": 2, "returnType": 1} }` option:
 
 ::: correct
 
 ```js
-/* eslint @stylistic/indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }] */
+/* eslint @stylistic/indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2, "returnType": 1} }] */
 
 var foo = function(bar,
     baz,
     qux) {
   qux();
 }
+
+const foo = function(a: string)
+  : a is 'a' {
+  return bar()
+}
 ```
 
 :::
diff --git a/packages/eslint-plugin/rules/indent/indent.ts b/packages/eslint-plugin/rules/indent/indent.ts
index 3c027113..32a7b474 100644
--- a/packages/eslint-plugin/rules/indent/indent.ts
+++ b/packages/eslint-plugin/rules/indent/indent.ts
@@ -51,6 +51,7 @@ const KNOWN_NODES = new Set([
   'Program',
   'Property',
   'PropertyDefinition',
+  AST_NODE_TYPES.AccessorProperty,
   'RestElement',
   'ReturnStatement',
   'SequenceExpression',
@@ -617,6 +618,10 @@ export default createRule<RuleOptions, MessageIds>({
                 type: 'integer',
                 minimum: 0,
               },
+              returnType: {
+                type: 'integer',
+                minimum: 0,
+              },
             },
             additionalProperties: false,
           },
@@ -628,6 +633,10 @@ export default createRule<RuleOptions, MessageIds>({
                 type: 'integer',
                 minimum: 0,
               },
+              returnType: {
+                type: 'integer',
+                minimum: 0,
+              },
             },
             additionalProperties: false,
           },
@@ -704,6 +713,7 @@ export default createRule<RuleOptions, MessageIds>({
     const DEFAULT_VARIABLE_INDENT = 1
     const DEFAULT_PARAMETER_INDENT = 1
     const DEFAULT_FUNCTION_BODY_INDENT = 1
+    const DEFAULT_FUNCTION_RETURN_TYPE_INDENT = 1
 
     let indentType = 'space'
     let indentSize = 4
@@ -719,10 +729,12 @@ export default createRule<RuleOptions, MessageIds>({
       FunctionDeclaration: {
         parameters: DEFAULT_PARAMETER_INDENT,
         body: DEFAULT_FUNCTION_BODY_INDENT,
+        returnType: DEFAULT_FUNCTION_RETURN_TYPE_INDENT,
       },
       FunctionExpression: {
         parameters: DEFAULT_PARAMETER_INDENT,
         body: DEFAULT_FUNCTION_BODY_INDENT,
+        returnType: DEFAULT_FUNCTION_RETURN_TYPE_INDENT,
       },
       StaticBlock: {
         body: DEFAULT_FUNCTION_BODY_INDENT,
@@ -1513,22 +1525,22 @@ export default createRule<RuleOptions, MessageIds>({
         const paramsClosingParen = sourceCode.getTokenBefore(
           node.returnType ?? node.body,
           { filter: isClosingParenToken },
-        )
-        if (!paramsClosingParen)
-          throw new Error('Expected to find a closing parenthesis for function parameters.')
+        )!
 
         const paramsOpeningParen = sourceCode.getTokenBefore(
           node.params.length
             ? (node.params[0].decorators?.[0] ?? node.params[0])
             : paramsClosingParen,
           { filter: isOpeningParenToken },
-        )
-        if (!paramsOpeningParen)
-          throw new Error('Expected to find an opening parenthesis for function parameters.')
+        )!
 
         parameterParens.add(paramsOpeningParen)
         parameterParens.add(paramsClosingParen)
         addElementListIndent(node.params, paramsOpeningParen, paramsClosingParen, options[node.type].parameters)
+
+        if (node.returnType) {
+          offsets.setDesiredOffsets(node.returnType.range, paramsClosingParen, options[node.type].returnType)
+        }
       },
 
       IfStatement(node) {
diff --git a/packages/eslint-plugin/rules/indent/types.d.ts b/packages/eslint-plugin/rules/indent/types.d.ts
index f00e155a..0fb3d99a 100644
--- a/packages/eslint-plugin/rules/indent/types.d.ts
+++ b/packages/eslint-plugin/rules/indent/types.d.ts
@@ -1,6 +1,6 @@
 /* GENERATED, DO NOT EDIT DIRECTLY */
 
-/* @checksum: OXKn3_mfEuRvCVJ6qv5__ZiBZDQpamanEmwuqMCGavo */
+/* @checksum: QbJKtgTG8LGJ01CuOk9fHSorj_SGJMdNlfWA7zJbTew */
 
 export type IndentSchema0 = 'tab' | number
 
@@ -19,10 +19,12 @@ export interface IndentSchema1 {
   FunctionDeclaration?: {
     parameters?: number | ('first' | 'off')
     body?: number
+    returnType?: number
   }
   FunctionExpression?: {
     parameters?: number | ('first' | 'off')
     body?: number
+    returnType?: number
   }
   StaticBlock?: {
     body?: number
diff --git a/packages/eslint-plugin/rules/jsx-curly-spacing/jsx-curly-spacing.ts b/packages/eslint-plugin/rules/jsx-curly-spacing/jsx-curly-spacing.ts
index 6bfd22f2..0121dd5b 100644
--- a/packages/eslint-plugin/rules/jsx-curly-spacing/jsx-curly-spacing.ts
+++ b/packages/eslint-plugin/rules/jsx-curly-spacing/jsx-curly-spacing.ts
@@ -9,8 +9,8 @@
  * @author Erik Wendel
  */
 
-import type { ASTNode, RuleFixer, Token } from '#types'
-import type { BasicConfig, MessageIds, RuleOptions } from './types'
+import type { ASTNode, JSONSchema, RuleFixer, Token } from '#types'
+import type { MessageIds, RuleOptions } from './types'
 import { isTokenOnSameLine } from '#utils/ast'
 import { createRule } from '#utils/create-rule'
 
@@ -29,6 +29,45 @@ const messages = {
   spaceNeededBefore: 'A space is required before \'{{token}}\'',
 }
 
+const BASIC_CONFIG_SCHEMA = {
+  type: 'object',
+  properties: {
+    when: {
+      type: 'string',
+      enum: SPACING_VALUES,
+    },
+    allowMultiline: {
+      type: 'boolean',
+    },
+    spacing: {
+      type: 'object',
+      properties: {
+        objectLiterals: {
+          type: 'string',
+          enum: SPACING_VALUES,
+        },
+      },
+      additionalProperties: false,
+    },
+  },
+  additionalProperties: false,
+} satisfies JSONSchema.JSONSchema4ObjectSchema
+
+const BASIC_CONFIG_OR_BOOLEAN_SCHEMA = {
+  anyOf: [
+    BASIC_CONFIG_SCHEMA,
+    {
+      type: 'boolean',
+    },
+  ],
+} satisfies JSONSchema.JSONSchema4AnyOfSchema
+
+type BasicConfig = Pick<Extract<RuleOptions[0], { when?: any }>, keyof typeof BASIC_CONFIG_SCHEMA['properties']>
+
+interface NormalizedConfig extends BasicConfig {
+  objectLiteralSpaces?: 'always' | 'never'
+}
+
 export default createRule<RuleOptions, MessageIds>({
   name: 'jsx-curly-spacing',
   meta: {
@@ -41,56 +80,23 @@ export default createRule<RuleOptions, MessageIds>({
     messages,
 
     schema: {
-      definitions: {
-        basicConfig: {
-          type: 'object',
-          properties: {
-            when: {
-              type: 'string',
-              enum: SPACING_VALUES,
-            },
-            allowMultiline: {
-              type: 'boolean',
-            },
-            spacing: {
-              type: 'object',
-              properties: {
-                objectLiterals: {
-                  type: 'string',
-                  enum: SPACING_VALUES,
-                },
-              },
-            },
-          },
-        },
-        basicConfigOrBoolean: {
-          anyOf: [{
-            $ref: '#/definitions/basicConfig',
-          }, {
-            type: 'boolean',
-          }],
-        },
-      },
       type: 'array',
       items: [{
-        anyOf: [{
-          allOf: [{
-            $ref: '#/definitions/basicConfig',
-          }, {
+        anyOf: [
+          {
             type: 'object',
+            additionalProperties: false,
             properties: {
-              attributes: {
-                $ref: '#/definitions/basicConfigOrBoolean',
-              },
-              children: {
-                $ref: '#/definitions/basicConfigOrBoolean',
-              },
+              ...BASIC_CONFIG_SCHEMA.properties,
+              attributes: BASIC_CONFIG_OR_BOOLEAN_SCHEMA,
+              children: BASIC_CONFIG_OR_BOOLEAN_SCHEMA,
             },
-          }],
-        }, {
-          type: 'string',
-          enum: SPACING_VALUES,
-        }],
+          },
+          {
+            type: 'string',
+            enum: SPACING_VALUES,
+          },
+        ],
       }, {
         type: 'object',
         properties: {
@@ -105,6 +111,7 @@ export default createRule<RuleOptions, MessageIds>({
                 enum: SPACING_VALUES,
               },
             },
+            additionalProperties: false,
           },
         },
         additionalProperties: false,
@@ -113,11 +120,11 @@ export default createRule<RuleOptions, MessageIds>({
   },
 
   create(context) {
-    function normalizeConfig(configOrTrue: RuleOptions[0] | true, defaults: BasicConfig, lastPass: boolean = false) {
+    function normalizeConfig(configOrTrue: RuleOptions[0] | true, defaults: NormalizedConfig, lastPass: boolean = false): NormalizedConfig {
       const config = configOrTrue === true ? {} : configOrTrue as NonStringConfig
-      const when = (config as BasicConfig).when || defaults.when
+      const when = config.when || defaults.when
       const allowMultiline = 'allowMultiline' in config ? config.allowMultiline : defaults.allowMultiline
-      const spacing = (config as BasicConfig).spacing || {}
+      const spacing = config.spacing || {}
       let objectLiteralSpaces = spacing.objectLiterals || defaults.objectLiteralSpaces
       if (lastPass) {
         // On the final pass assign the values that should be derived from others if they are still undefined
diff --git a/packages/eslint-plugin/rules/jsx-curly-spacing/types.d.ts b/packages/eslint-plugin/rules/jsx-curly-spacing/types.d.ts
index 9682bf95..44942a4a 100644
--- a/packages/eslint-plugin/rules/jsx-curly-spacing/types.d.ts
+++ b/packages/eslint-plugin/rules/jsx-curly-spacing/types.d.ts
@@ -1,45 +1,73 @@
 /* GENERATED, DO NOT EDIT DIRECTLY */
 
-/* @checksum: 6np7FJPRpiFgbrMsnDL-PC4zMTYMNJoW_bCYp5XgxUg */
+/* @checksum: _pSba4lVI8bSVjFb0Xmp0h46hFdDbMk9iLr41NY4nwY */
 
 export type JsxCurlySpacingSchema0
   = | []
     | [
-      | (BasicConfig & {
-        attributes?: BasicConfigOrBoolean
-        children?: BasicConfigOrBoolean
-        [k: string]: unknown
-      })
+      | {
+        when?: 'always' | 'never'
+        allowMultiline?: boolean
+        spacing?: {
+          objectLiterals?: 'always' | 'never'
+        }
+        attributes?:
+          | {
+            when?: 'always' | 'never'
+            allowMultiline?: boolean
+            spacing?: {
+              objectLiterals?: 'always' | 'never'
+            }
+          }
+          | boolean
+        children?:
+          | {
+            when?: 'always' | 'never'
+            allowMultiline?: boolean
+            spacing?: {
+              objectLiterals?: 'always' | 'never'
+            }
+          }
+          | boolean
+      }
       | ('always' | 'never'),
     ]
     | [
       (
-        | (BasicConfig & {
-          attributes?: BasicConfigOrBoolean
-          children?: BasicConfigOrBoolean
-          [k: string]: unknown
-        })
+        | {
+          when?: 'always' | 'never'
+          allowMultiline?: boolean
+          spacing?: {
+            objectLiterals?: 'always' | 'never'
+          }
+          attributes?:
+            | {
+              when?: 'always' | 'never'
+              allowMultiline?: boolean
+              spacing?: {
+                objectLiterals?: 'always' | 'never'
+              }
+            }
+            | boolean
+          children?:
+            | {
+              when?: 'always' | 'never'
+              allowMultiline?: boolean
+              spacing?: {
+                objectLiterals?: 'always' | 'never'
+              }
+            }
+            | boolean
+        }
         | ('always' | 'never')
       ),
       {
         allowMultiline?: boolean
         spacing?: {
           objectLiterals?: 'always' | 'never'
-          [k: string]: unknown
         }
       },
     ]
-export type BasicConfigOrBoolean = BasicConfig | boolean
-
-export interface BasicConfig {
-  when?: 'always' | 'never'
-  allowMultiline?: boolean
-  spacing?: {
-    objectLiterals?: 'always' | 'never'
-    [k: string]: unknown
-  }
-  [k: string]: unknown
-}
 
 export type JsxCurlySpacingRuleOptions
   = JsxCurlySpacingSchema0
diff --git a/packages/eslint-plugin/rules/jsx-indent-props/jsx-indent-props.ts b/packages/eslint-plugin/rules/jsx-indent-props/jsx-indent-props.ts
index 3131d542..b89304f7 100644
--- a/packages/eslint-plugin/rules/jsx-indent-props/jsx-indent-props.ts
+++ b/packages/eslint-plugin/rules/jsx-indent-props/jsx-indent-props.ts
@@ -78,6 +78,7 @@ export default createRule<RuleOptions, MessageIds>({
               type: 'boolean',
             },
           },
+          additionalProperties: false,
         },
       ],
     }],
diff --git a/packages/eslint-plugin/rules/jsx-indent-props/types.d.ts b/packages/eslint-plugin/rules/jsx-indent-props/types.d.ts
index e874d818..553f24e8 100644
--- a/packages/eslint-plugin/rules/jsx-indent-props/types.d.ts
+++ b/packages/eslint-plugin/rules/jsx-indent-props/types.d.ts
@@ -1,6 +1,6 @@
 /* GENERATED, DO NOT EDIT DIRECTLY */
 
-/* @checksum: yoq47ZFhtyO96ComOIYTmw3_4sqKrrg0Nv2kSf7dBYo */
+/* @checksum: 30G_ZrWyAGlBb_DWlLb43wDD7IXoSKVHzxArM3d3ta0 */
 
 export type JsxIndentPropsSchema0
   = | ('tab' | 'first')
@@ -8,7 +8,6 @@ export type JsxIndentPropsSchema0
     | {
       indentMode?: ('tab' | 'first') | number
       ignoreTernaryOperator?: boolean
-      [k: string]: unknown
     }
 
 export type JsxIndentPropsRuleOptions = [
diff --git a/packages/eslint-plugin/rules/jsx-max-props-per-line/jsx-max-props-per-line.ts b/packages/eslint-plugin/rules/jsx-max-props-per-line/jsx-max-props-per-line.ts
index b600c14f..669a6cd3 100644
--- a/packages/eslint-plugin/rules/jsx-max-props-per-line/jsx-max-props-per-line.ts
+++ b/packages/eslint-plugin/rules/jsx-max-props-per-line/jsx-max-props-per-line.ts
@@ -46,6 +46,7 @@ export default createRule<RuleOptions, MessageIds>({
                 minimum: 1,
               },
             },
+            additionalProperties: false,
           },
         },
         additionalProperties: false,
diff --git a/packages/eslint-plugin/rules/jsx-max-props-per-line/types.d.ts b/packages/eslint-plugin/rules/jsx-max-props-per-line/types.d.ts
index 9828f9b2..b1b110a3 100644
--- a/packages/eslint-plugin/rules/jsx-max-props-per-line/types.d.ts
+++ b/packages/eslint-plugin/rules/jsx-max-props-per-line/types.d.ts
@@ -1,13 +1,12 @@
 /* GENERATED, DO NOT EDIT DIRECTLY */
 
-/* @checksum: KOe_wU0r0lsPla5JCuUUOQFmBSnDNOIm5DXIMsRs3g4 */
+/* @checksum: Cw90UTKsHhPLRv0dTeRqkUFq1z8xJdtpn3CUONfizj4 */
 
 export type JsxMaxPropsPerLineSchema0
   = | {
     maximum?: {
       single?: number
       multi?: number
-      [k: string]: unknown
     }
   }
   | {
diff --git a/packages/eslint-plugin/rules/keyword-spacing/README.md b/packages/eslint-plugin/rules/keyword-spacing/README.md
index f719a776..ea5a52d5 100644
--- a/packages/eslint-plugin/rules/keyword-spacing/README.md
+++ b/packages/eslint-plugin/rules/keyword-spacing/README.md
@@ -29,7 +29,7 @@ However, if you want to enforce the style of following spacing cases, please ref
 
 ## Rule Details
 
-This rule enforces consistent spacing around keywords and keyword-like tokens: `as` (in module declarations), `async` (of async functions), `await` (of await expressions), `break`, `case`, `catch`, `class`, `const`, `continue`, `debugger`, `default`, `delete`, `do`, `else`, `export`, `extends`, `finally`, `for`, `from` (in module declarations), `function`, `get` (of getters), `if`, `import`, `in` (in for-in statements), `let`, `new`, `of` (in for-of statements), `return`, `set` (of setters), `static`, `super`, `switch`, `this`, `throw`, `try`, `typeof`, `using`, `var`, `void`, `while`, `with`, and `yield`. This rule is designed carefully not to conflict with other spacing rules: it does not apply to spacing where other rules report problems.
+This rule enforces consistent spacing around keywords and keyword-like tokens: `accessor` (of accessor property), `as` (in module declarations), `async` (of async functions), `await` (of await expressions), `break`, `case`, `catch`, `class`, `const`, `continue`, `debugger`, `default`, `delete`, `do`, `else`, `export`, `extends`, `finally`, `for`, `from` (in module declarations), `function`, `get` (of getters), `if`, `import`, `in` (in for-in statements), `let`, `new`, `of` (in for-of statements), `return`, `set` (of setters), `static`, `super`, `switch`, `this`, `throw`, `try`, `typeof`, `using`, `var`, `void`, `while`, `with`, and `yield`. This rule is designed carefully not to conflict with other spacing rules: it does not apply to spacing where other rules report problems.
 
 ## Options
 
diff --git a/packages/eslint-plugin/rules/keyword-spacing/keyword-spacing.ts b/packages/eslint-plugin/rules/keyword-spacing/keyword-spacing.ts
index 22fb8a9d..5709076c 100644
--- a/packages/eslint-plugin/rules/keyword-spacing/keyword-spacing.ts
+++ b/packages/eslint-plugin/rules/keyword-spacing/keyword-spacing.ts
@@ -11,7 +11,7 @@ const NEXT_TOKEN_M = /^[{*]$/u
 const TEMPLATE_OPEN_PAREN = /\$\{$/u
 const TEMPLATE_CLOSE_PAREN = /^\}/u
 const CHECK_TYPE = /^(?:JSXElement|RegularExpression|String|Template|PrivateIdentifier)$/u
-const KEYS = KEYWORDS_JS.concat(['as', 'async', 'await', 'from', 'get', 'let', 'of', 'satisfies', 'set', 'using', 'yield', 'type'])
+const KEYS = KEYWORDS_JS.concat(['accessor', 'as', 'async', 'await', 'from', 'get', 'let', 'of', 'satisfies', 'set', 'using', 'yield', 'type'])
 
 export default createRule<RuleOptions, MessageIds>({
   name: 'keyword-spacing',
@@ -354,7 +354,7 @@ export default createRule<RuleOptions, MessageIds>({
     }
 
     /**
-     * Reports `import`, `export`, `as`, and `from` keywords of a given node if
+     * Reports `import`, `export`, `as`, `from` and `with` keywords of a given node if
      * usage of spacing around those keywords is invalid.
      *
      * This rule handles the `*` token in module declarations.
@@ -390,6 +390,13 @@ export default createRule<RuleOptions, MessageIds>({
 
         checkSpacingBefore(fromToken, PREV_TOKEN_M)
         checkSpacingAfter(fromToken, NEXT_TOKEN_M)
+
+        // ImportAttribute must be after source
+        if (node.attributes) {
+          const withToken = sourceCode.getTokenAfter(node.source)
+          if (isKeywordToken(withToken))
+            checkSpacingAround(withToken)
+        }
       }
 
       // ExportDefaultDeclaration never have a `type` keyword
@@ -436,12 +443,12 @@ export default createRule<RuleOptions, MessageIds>({
     }
 
     /**
-     * Reports `static`, `get`, and `set` keywords of a given node if usage of
+     * Reports `accessor`, `static`, `get`, and `set` keywords of a given node if usage of
      * spacing around those keywords is invalid.
      * @param node A node to report.
      * @throws {Error} If unable to find token get, set, or async beside method name.
      */
-    function checkSpacingForProperty(node: Tree.MethodDefinition | Tree.PropertyDefinition | Tree.Property) {
+    function checkSpacingForProperty(node: Tree.MethodDefinition | Tree.PropertyDefinition | Tree.AccessorProperty | Tree.Property) {
       if ('static' in node && node.static)
         checkSpacingAroundFirstToken(node)
 
@@ -451,6 +458,7 @@ export default createRule<RuleOptions, MessageIds>({
           (('method' in node && node.method) || node.type === 'MethodDefinition')
           && 'async' in node.value && node.value.async
         )
+        || node.type === AST_NODE_TYPES.AccessorProperty
       ) {
         const token = sourceCode.getTokenBefore(
           node.key,
@@ -459,6 +467,7 @@ export default createRule<RuleOptions, MessageIds>({
               case 'get':
               case 'set':
               case 'async':
+              case 'accessor':
                 return true
               default:
                 return false
@@ -595,6 +604,7 @@ export default createRule<RuleOptions, MessageIds>({
       },
       MethodDefinition: checkSpacingForProperty,
       PropertyDefinition: checkSpacingForProperty,
+      AccessorProperty: checkSpacingForProperty,
       StaticBlock: checkSpacingAroundFirstToken,
       Property: checkSpacingForProperty,
 
diff --git a/packages/eslint-plugin/rules/multiline-ternary/multiline-ternary.ts b/packages/eslint-plugin/rules/multiline-ternary/multiline-ternary.ts
index 36140f22..ec8cbe5c 100644
--- a/packages/eslint-plugin/rules/multiline-ternary/multiline-ternary.ts
+++ b/packages/eslint-plugin/rules/multiline-ternary/multiline-ternary.ts
@@ -29,6 +29,7 @@ export default createRule<RuleOptions, MessageIds>({
             default: false,
           },
         },
+        additionalProperties: false,
       },
     ],
 
diff --git a/packages/eslint-plugin/rules/multiline-ternary/types.d.ts b/packages/eslint-plugin/rules/multiline-ternary/types.d.ts
index 8acd740f..bf931cfc 100644
--- a/packages/eslint-plugin/rules/multiline-ternary/types.d.ts
+++ b/packages/eslint-plugin/rules/multiline-ternary/types.d.ts
@@ -1,6 +1,6 @@
 /* GENERATED, DO NOT EDIT DIRECTLY */
 
-/* @checksum: F-2EEbab-hKzmU-DEbejw9951edJ-x4z3ngYponoEZI */
+/* @checksum: B9Xuzw8xZiK_fneqs8jInWdZlTCYrLuG3DJ0naQrxnY */
 
 export type MultilineTernarySchema0
   = | 'always'
@@ -9,7 +9,6 @@ export type MultilineTernarySchema0
 
 export interface MultilineTernarySchema1 {
   ignoreJSX?: boolean
-  [k: string]: unknown
 }
 
 export type MultilineTernaryRuleOptions = [
diff --git a/packages/eslint-plugin/rules/no-extra-parens/no-extra-parens.ts b/packages/eslint-plugin/rules/no-extra-parens/no-extra-parens.ts
index 1b4e9888..0defd51e 100644
--- a/packages/eslint-plugin/rules/no-extra-parens/no-extra-parens.ts
+++ b/packages/eslint-plugin/rules/no-extra-parens/no-extra-parens.ts
@@ -908,6 +908,14 @@ export default createRule<RuleOptions, MessageIds>({
       return checkArgumentWithPrecedence(node)
     }
 
+    function checkClassProperty(node: Tree.PropertyDefinition | Tree.AccessorProperty) {
+      if (node.computed && hasExcessParensWithPrecedence(node.key, PRECEDENCE_OF_ASSIGNMENT_EXPR))
+        report(node.key)
+
+      if (node.value && hasExcessParensWithPrecedence(node.value, PRECEDENCE_OF_ASSIGNMENT_EXPR))
+        report(node.value)
+    }
+
     return {
       ArrayExpression(node) {
         node.elements
@@ -1339,13 +1347,8 @@ export default createRule<RuleOptions, MessageIds>({
             report(key)
         }
       },
-      PropertyDefinition(node) {
-        if (node.computed && hasExcessParensWithPrecedence(node.key, PRECEDENCE_OF_ASSIGNMENT_EXPR))
-          report(node.key)
-
-        if (node.value && hasExcessParensWithPrecedence(node.value, PRECEDENCE_OF_ASSIGNMENT_EXPR))
-          report(node.value)
-      },
+      'PropertyDefinition': checkClassProperty,
+      'AccessorProperty': checkClassProperty,
       RestElement(node) {
         const argument = node.argument
 
diff --git a/packages/eslint-plugin/rules/no-extra-semi/no-extra-semi.ts b/packages/eslint-plugin/rules/no-extra-semi/no-extra-semi.ts
index 3695e458..330eb5ee 100644
--- a/packages/eslint-plugin/rules/no-extra-semi/no-extra-semi.ts
+++ b/packages/eslint-plugin/rules/no-extra-semi/no-extra-semi.ts
@@ -114,6 +114,9 @@ export default createRule<RuleOptions, MessageIds>({
       PropertyDefinition(node) {
         checkForPartOfClassBody(sourceCode.getTokenAfter(node)!)
       },
+      AccessorProperty(node) {
+        checkForPartOfClassBody(sourceCode.getTokenAfter(node)!)
+      },
       StaticBlock(node) {
         checkForPartOfClassBody(sourceCode.getTokenAfter(node)!)
       },
diff --git a/packages/eslint-plugin/rules/object-curly-spacing/object-curly-spacing.ts b/packages/eslint-plugin/rules/object-curly-spacing/object-curly-spacing.ts
index ed0957f8..dbd5251f 100644
--- a/packages/eslint-plugin/rules/object-curly-spacing/object-curly-spacing.ts
+++ b/packages/eslint-plugin/rules/object-curly-spacing/object-curly-spacing.ts
@@ -6,6 +6,7 @@ import {
   isClosingBraceToken,
   isClosingBracketToken,
   isNotCommaToken,
+  isOpeningBraceToken,
   isTokenOnSameLine,
 } from '#utils/ast'
 import { createRule } from '#utils/create-rule'
@@ -254,7 +255,7 @@ export default createRule<RuleOptions, MessageIds>({
 
       const closeToken = sourceCode.getTokenAfter(properties.at(-1)!, isClosingBraceToken)!
 
-      const openingToken = sourceCode.getFirstToken(node)!
+      const openingToken = sourceCode.getTokenBefore(properties[0], isOpeningBraceToken)!
 
       validateBraceSpacing(node, openingToken, closeToken)
     }
@@ -308,9 +309,23 @@ export default createRule<RuleOptions, MessageIds>({
         checkForObjectLike(node, node.properties)
       },
       // import {y} from 'x';
-      ImportDeclaration: checkForImport,
+      ImportDeclaration(node) {
+        checkForImport(node)
+
+        if (node.attributes)
+          checkForObjectLike(node, node.attributes)
+      },
       // export {name} from 'yo';
-      ExportNamedDeclaration: checkForExport,
+      ExportNamedDeclaration(node) {
+        checkForExport(node)
+
+        if (node.attributes)
+          checkForObjectLike(node, node.attributes)
+      },
+      ExportAllDeclaration(node) {
+        if (node.attributes)
+          checkForObjectLike(node, node.attributes)
+      },
       TSMappedType(node) {
         const openingToken = sourceCode.getFirstToken(node)!
         const closeToken = sourceCode.getLastToken(node)!
diff --git a/packages/eslint-plugin/rules/operator-linebreak/README.md b/packages/eslint-plugin/rules/operator-linebreak/README.md
index 90ac3f53..71b37b28 100644
--- a/packages/eslint-plugin/rules/operator-linebreak/README.md
+++ b/packages/eslint-plugin/rules/operator-linebreak/README.md
@@ -36,6 +36,7 @@ String option:
 - `"after"` requires linebreaks to be placed after the operator
 - `"before"` requires linebreaks to be placed before the operator
 - `"none"` disallows linebreaks on either side of the operator
+- `"ignore"` ignores linebreaks on either side of the operator (only in `overrides`)
 
 Object option:
 
diff --git a/packages/eslint-plugin/rules/operator-linebreak/operator-linebreak.ts b/packages/eslint-plugin/rules/operator-linebreak/operator-linebreak.ts
index dc81a577..77a0305d 100644
--- a/packages/eslint-plugin/rules/operator-linebreak/operator-linebreak.ts
+++ b/packages/eslint-plugin/rules/operator-linebreak/operator-linebreak.ts
@@ -220,6 +220,10 @@ export default createRule<RuleOptions, MessageIds>({
         if (node.value)
           validateNode(node, node.value, '=')
       },
+      AccessorProperty(node) {
+        if (node.value)
+          validateNode(node, node.value, '=')
+      },
       ConditionalExpression(node) {
         validateNode(node, node.consequent, '?')
         validateNode(node, node.alternate, ':')
diff --git a/packages/eslint-plugin/rules/quotes/quotes.ts b/packages/eslint-plugin/rules/quotes/quotes.ts
index 774942df..2f885c3d 100644
--- a/packages/eslint-plugin/rules/quotes/quotes.ts
+++ b/packages/eslint-plugin/rules/quotes/quotes.ts
@@ -278,6 +278,7 @@ export default createRule<RuleOptions, MessageIds>({
 
         case AST_NODE_TYPES.TSAbstractPropertyDefinition:
         case AST_NODE_TYPES.PropertyDefinition:
+        case AST_NODE_TYPES.AccessorProperty:
           return parent.key === node && !parent.computed
 
         case AST_NODE_TYPES.TSLiteralType:
diff --git a/packages/eslint-plugin/rules/semi-spacing/semi-spacing.ts b/packages/eslint-plugin/rules/semi-spacing/semi-spacing.ts
index 58d0edd6..64a6acca 100644
--- a/packages/eslint-plugin/rules/semi-spacing/semi-spacing.ts
+++ b/packages/eslint-plugin/rules/semi-spacing/semi-spacing.ts
@@ -227,6 +227,7 @@ export default createRule<RuleOptions, MessageIds>({
           checkSemicolonSpacing(sourceCode.getTokenAfter(node.test)!, node)
       },
       PropertyDefinition: checkNode,
+      AccessorProperty: checkNode,
       TSDeclareFunction: checkNode,
       TSTypeAliasDeclaration: checkNode,
       TSTypeAnnotation(node) {
diff --git a/packages/eslint-plugin/rules/semi-style/semi-style.ts b/packages/eslint-plugin/rules/semi-style/semi-style.ts
index 4cc732b4..b4a57e1e 100644
--- a/packages/eslint-plugin/rules/semi-style/semi-style.ts
+++ b/packages/eslint-plugin/rules/semi-style/semi-style.ts
@@ -3,12 +3,12 @@
  * @author Toru Nagashima
  */
 
-import type { ASTNode, Token } from '#types'
+import type { ASTNode, NodeTypes, Token } from '#types'
 import type { MessageIds, RuleOptions } from './types'
 import { isSemicolonToken, isTokenOnSameLine } from '#utils/ast'
 import { createRule } from '#utils/create-rule'
 
-const SELECTOR = [
+const SELECTOR = ([
   'BreakStatement',
   'ContinueStatement',
   'DebuggerStatement',
@@ -22,7 +22,8 @@ const SELECTOR = [
   'ThrowStatement',
   'VariableDeclaration',
   'PropertyDefinition',
-].join(',')
+  'AccessorProperty',
+] satisfies NodeTypes[]).join(',')
 
 /**
  * Get the child node list of a given node.
diff --git a/packages/eslint-plugin/rules/semi/semi.ts b/packages/eslint-plugin/rules/semi/semi.ts
index 3210aaf2..e96b2ae5 100644
--- a/packages/eslint-plugin/rules/semi/semi.ts
+++ b/packages/eslint-plugin/rules/semi/semi.ts
@@ -420,6 +420,7 @@ export default createRule<RuleOptions, MessageIds>({
           checkForSemicolon(node)
       },
       PropertyDefinition: checkForSemicolon,
+      AccessorProperty: checkForSemicolon,
       TSAbstractPropertyDefinition: checkForSemicolon,
       TSDeclareFunction: checkForSemicolon,
       TSExportAssignment: checkForSemicolon,
diff --git a/packages/eslint-plugin/rules/space-infix-ops/space-infix-ops.ts b/packages/eslint-plugin/rules/space-infix-ops/space-infix-ops.ts
index 1d0c87fd..36686c7d 100644
--- a/packages/eslint-plugin/rules/space-infix-ops/space-infix-ops.ts
+++ b/packages/eslint-plugin/rules/space-infix-ops/space-infix-ops.ts
@@ -192,7 +192,7 @@ export default createRule<RuleOptions, MessageIds>({
      * @param node The node to report
      */
     function checkForPropertyDefinitionAssignmentSpace(
-      node: Tree.PropertyDefinition,
+      node: Tree.PropertyDefinition | Tree.AccessorProperty,
     ): void {
       const leftNode
         = node.optional && !node.typeAnnotation
@@ -263,6 +263,7 @@ export default createRule<RuleOptions, MessageIds>({
       VariableDeclarator: checkVar,
       TSEnumMember: checkForEnumAssignmentSpace,
       PropertyDefinition: checkForPropertyDefinitionAssignmentSpace,
+      AccessorProperty: checkForPropertyDefinitionAssignmentSpace,
       TSTypeAliasDeclaration: checkForTypeAliasAssignment,
       TSUnionType: checkForTypeAnnotationSpace,
       TSIntersectionType: checkForTypeAnnotationSpace,


Test patch:
diff --git a/packages/eslint-plugin/rules/computed-property-spacing/computed-property-spacing.test.ts b/packages/eslint-plugin/rules/computed-property-spacing/computed-property-spacing.test.ts
index 66f34ac1..2aed0dd5 100644
--- a/packages/eslint-plugin/rules/computed-property-spacing/computed-property-spacing.test.ts
+++ b/packages/eslint-plugin/rules/computed-property-spacing/computed-property-spacing.test.ts
@@ -10,9 +10,7 @@ import rule from './computed-property-spacing'
 run<RuleOptions, MessageIds>({
   name: 'computed-property-spacing',
   rule,
-
   valid: [
-
     // default - never
     'obj[foo]',
     'obj[\'foo\']',
@@ -72,106 +70,106 @@ run<RuleOptions, MessageIds>({
 
     // explicitly disabled option
     {
-      code: 'class A { [ a ](){} }',
+      code: 'class A { [ a ](){} accessor [ b ] }',
       options: ['never', { enforceForClassMembers: false }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'A = class { [ a ](){} get [ b ](){} set [ c ](foo){} static [ d ](){} static get [ e ](){} static set [ f ](bar){} }',
+      code: 'A = class { [ a ](){} get [ b ](){} set [ c ](foo){} static [ d ](){} static get [ e ](){} static set [ f ](bar){} accessor [ g ] }',
       options: ['never', { enforceForClassMembers: false }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'A = class { [a](){} }',
+      code: 'A = class { [a](){} accessor [b] = 1 }',
       options: ['always', { enforceForClassMembers: false }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'class A { [a](){} get [b](){} set [b](foo){} static [c](){} static get [d](){} static set [d](bar){} }',
+      code: 'class A { [a](){} get [b](){} set [b](foo){} static [c](){} static get [d](){} static set [d](bar){} accessor [e] = 1 }',
       options: ['always', { enforceForClassMembers: false }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'class A { [ a ]; }',
+      code: 'class A { [ a ]; accessor [ b ]; }',
       options: ['never', { enforceForClassMembers: false }],
       parserOptions: { ecmaVersion: 2022 },
     },
     {
-      code: 'class A { [a]; }',
+      code: 'class A { [a]; accessor [b]; }',
       options: ['always', { enforceForClassMembers: false }],
       parserOptions: { ecmaVersion: 2022 },
     },
 
     // valid spacing
     {
-      code: 'A = class { [a](){} }',
+      code: 'A = class { [a](){} accessor [b] = 1 }',
       options: ['never', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'class A { [a] ( ) { } }',
+      code: 'class A { [a] ( ) { } accessor [b] = 1 }',
       options: ['never', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'A = class { [ \n a \n ](){} }',
+      code: 'A = class { [ \n a \n ](){} accessor [ \n b \n ] = 1 }',
       options: ['never', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'class A { [a](){} get [b](){} set [b](foo){} static [c](){} static get [d](){} static set [d](bar){} }',
+      code: 'class A { [a](){} get [b](){} set [b](foo){} static [c](){} static get [d](){} static set [d](bar){} accessor [e] = 1 }',
       options: ['never', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'class A { [ a ](){} }',
+      code: 'class A { [ a ](){} accessor [ b ] = 1 }',
       options: ['always', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'class A { [ a ](){}[ b ](){} }',
+      code: 'class A { [ a ](){}[ b ](){}\naccessor [ c ] = 1 }',
       options: ['always', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'A = class { [\na\n](){} }',
+      code: 'A = class { [\na\n](){} accessor [ b ] = 1 }',
       options: ['always', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'A = class { [ a ](){} get [ b ](){} set [ c ](foo){} static [ d ](){} static get [ e ](){} static set [ f ](bar){} }',
+      code: 'A = class { [ a ](){} get [ b ](){} set [ c ](foo){} static [ d ](){} static get [ e ](){} static set [ f ](bar){} accessor [ g ] = 1 }',
       options: ['always', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'A = class { [a]; static [a]; [a] = 0; static [a] = 0; }',
+      code: 'A = class { [a]; static [a]; [a] = 0; static [a] = 0; accessor [b] = 1 }',
       options: ['never', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 2022 },
     },
     {
-      code: 'A = class { [ a ]; static [ a ]; [ a ] = 0; static [ a ] = 0; }',
+      code: 'A = class { [ a ]; static [ a ]; [ a ] = 0; static [ a ] = 0; accessor [ b ] = 1 }',
       options: ['always', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 2022 },
     },
 
     // non-computed
     {
-      code: 'class A { a ( ) { } get b(){} set b ( foo ){} static c (){} static get d() {} static set d( bar ) {} }',
+      code: 'class A { a ( ) { } get b(){} set b ( foo ){} static c (){} static get d() {} static set d( bar ) {} accessor e = 1 }',
       options: ['never', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'A = class {a(){}get b(){}set b(foo){}static c(){}static get d(){}static set d(bar){}}',
+      code: 'A = class {a(){}get b(){}set b(foo){}static c(){}static get d(){}static set d(bar){} accessor e = 1}',
       options: ['always', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 6 },
     },
     {
-      code: 'A = class { foo; #a; static #b; #c = 0; static #d = 0; }',
+      code: 'A = class { foo; #a; static #b; #c = 0; static #d = 0; accessor e = 1; }',
       options: ['never', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 2022 },
     },
     {
-      code: 'A = class { foo; #a; static #b; #c = 0; static #d = 0; }',
+      code: 'A = class { foo; #a; static #b; #c = 0; static #d = 0; accessor e = 1; }',
       options: ['always', { enforceForClassMembers: true }],
       parserOptions: { ecmaVersion: 2022 },
     },
@@ -1450,6 +1448,15 @@ run<RuleOptions, MessageIds>({
         },
       ],
     },
+    {
+      code: 'class A { accessor [ a ] = 0 }',
+      output: 'class A { accessor [a] = 0 }',
+      options: ['never', { enforceForClassMembers: true }],
+      errors: [
+        { messageId: 'unexpectedSpaceAfter', column: 21, endColumn: 22 },
+        { messageId: 'unexpectedSpaceBefore', column: 23, endColumn: 24 },
+      ],
+    },
 
     // always - classes
     {
@@ -1694,6 +1701,15 @@ run<RuleOptions, MessageIds>({
         },
       ],
     },
+    {
+      code: 'class A { accessor [a] = 0 }',
+      output: 'class A { accessor [ a ] = 0 }',
+      options: ['always', { enforceForClassMembers: true }],
+      errors: [
+        { messageId: 'missingSpaceAfter', column: 20, endColumn: 21 },
+        { messageId: 'missingSpaceBefore', column: 22, endColumn: 23 },
+      ],
+    },
 
     // handling of parens and comments
     {
diff --git a/packages/eslint-plugin/rules/indent/indent._ts_.test.ts b/packages/eslint-plugin/rules/indent/indent._ts_.test.ts
index bd73d799..dfcf3fdb 100644
--- a/packages/eslint-plugin/rules/indent/indent._ts_.test.ts
+++ b/packages/eslint-plugin/rules/indent/indent._ts_.test.ts
@@ -767,6 +767,15 @@ run<RuleOptions, MessageIds>({
           type Bar = boolean
       }
     `,
+    {
+      code: $`
+        class Foo {
+          accessor [bar]: string
+          accessor baz: number
+        }
+      `,
+      options: [2],
+    },
     {
       code: $`
         using a = foo(),
@@ -843,6 +852,13 @@ run<RuleOptions, MessageIds>({
       `,
       options: [2],
     },
+    // https://github.com/eslint-stylistic/eslint-stylistic/issues/875
+    $`
+      export function isAuthenticated(authResult: AuthenticationResult | null | undefined)
+          : authResult is SuccessAuthenticationResult {
+          return !! authResult && authResult.isAuthenticated();
+      }
+    `,
   ],
   invalid: [
     ...individualNodeTests.invalid!,
@@ -2053,6 +2069,25 @@ declare function h(x: number): number;
         },
       ],
     },
+    {
+      code: $`
+        class Foo {
+        accessor [bar]: string
+            accessor baz: number
+        }
+      `,
+      output: $`
+        class Foo {
+          accessor [bar]: string
+          accessor baz: number
+        }
+      `,
+      options: [2],
+      errors: [
+        { messageId: 'wrongIndentation', data: { expected: '2 spaces', actual: 0 } },
+        { messageId: 'wrongIndentation', data: { expected: '2 spaces', actual: 4 } },
+      ],
+    },
     {
       code: $`
          type A = number
@@ -2112,5 +2147,40 @@ declare function h(x: number): number;
         { messageId: 'wrongIndentation', data: { expected: '2 spaces', actual: 12 } },
       ],
     },
+    // https://github.com/eslint-stylistic/eslint-stylistic/issues/875
+    {
+      code: $`
+        export function isAuthenticated(authResult: AuthenticationResult | null | undefined)
+        : authResult is SuccessAuthenticationResult {
+          return !! authResult && authResult.isAuthenticated();
+        }
+      `,
+      output: $`
+        export function isAuthenticated(authResult: AuthenticationResult | null | undefined)
+            : authResult is SuccessAuthenticationResult {
+          return !! authResult && authResult.isAuthenticated();
+        }
+      `,
+      options: [2, { FunctionDeclaration: { returnType: 2 } }],
+      errors: [
+        { messageId: 'wrongIndentation', data: { expected: '4 spaces', actual: 0 } },
+      ],
+    },
+    {
+      code: $`
+        const foo = function(a: string)
+          : a is 'a' {
+        }
+      `,
+      output: $`
+        const foo = function(a: string)
+        : a is 'a' {
+        }
+      `,
+      options: [2, { FunctionExpression: { returnType: 0 } }],
+      errors: [
+        { messageId: 'wrongIndentation', data: { expected: '0 spaces', actual: 2 } },
+      ],
+    },
   ],
 })
diff --git a/packages/eslint-plugin/rules/keyword-spacing/keyword-spacing._ts_.test.ts b/packages/eslint-plugin/rules/keyword-spacing/keyword-spacing._ts_.test.ts
index c29ed25c..472e6848 100644
--- a/packages/eslint-plugin/rules/keyword-spacing/keyword-spacing._ts_.test.ts
+++ b/packages/eslint-plugin/rules/keyword-spacing/keyword-spacing._ts_.test.ts
@@ -195,11 +195,30 @@ run<RuleOptions, MessageIds>({
       options: [BOTH],
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
     },
+    // ----------------------------------------------------------------------
+    // import attributes
+    // ----------------------------------------------------------------------
+    {
+      code: `import pkgJson from 'package.json' with { type: 'json' }`,
+      options: [BOTH],
+    },
+    {
+      code: `export{ name }from'package.json'with{ type: 'json' }`,
+      options: [NEITHER],
+    },
+    {
+      code: `export * from 'package.json'with{ type: 'json' }`,
+      options: [override('with', NEITHER)],
+    },
     {
       code: 'class A { delete() {} }',
       options: [BOTH],
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
     },
+    {
+      code: 'class C { @readonly accessor foo = 1 }',
+      options: [NEITHER],
+    },
     {
       code: 'export type { foo } from "foo";',
       options: [BOTH],
@@ -371,6 +390,12 @@ run<RuleOptions, MessageIds>({
       options: [{ overrides: { satisfies: {} } }],
       errors: expectedAfter('satisfies'),
     },
+    {
+      code: 'class C { @readonly() accessor foo = 1 }',
+      output: 'class C { @readonly()accessor foo = 1 }',
+      options: [NEITHER],
+      errors: unexpectedBefore('accessor'),
+    },
     {
       code: 'import type{ foo } from "foo";',
       output: 'import type { foo } from "foo";',
@@ -507,6 +532,36 @@ run<RuleOptions, MessageIds>({
         { messageId: 'unexpectedAfter', data: { value: 'from' } },
       ],
     },
+    // ----------------------------------------------------------------------
+    // import attributes
+    // ----------------------------------------------------------------------
+    {
+      code: `import pkgJson from'package.json' with { type: 'json' }`,
+      output: `import pkgJson from'package.json'with{ type: 'json' }`,
+      options: [NEITHER],
+      errors: [
+        { messageId: 'unexpectedBefore', data: { value: 'with' } },
+        { messageId: 'unexpectedAfter', data: { value: 'with' } },
+      ],
+    },
+    {
+      code: `export { name } from 'package.json'with{ type: 'json' }`,
+      output: `export { name } from 'package.json' with { type: 'json' }`,
+      options: [BOTH],
+      errors: [
+        { messageId: 'expectedBefore', data: { value: 'with' } },
+        { messageId: 'expectedAfter', data: { value: 'with' } },
+      ],
+    },
+    {
+      code: `export*from'package.json'with{ type: 'json' }`,
+      output: `export*from'package.json' with { type: 'json' }`,
+      options: [override('with', BOTH)],
+      errors: [
+        { messageId: 'expectedBefore', data: { value: 'with' } },
+        { messageId: 'expectedAfter', data: { value: 'with' } },
+      ],
+    },
 
     // ----------------------------------------------------------------------
     // using
diff --git a/packages/eslint-plugin/rules/no-extra-parens/no-extra-parens._ts_.test.ts b/packages/eslint-plugin/rules/no-extra-parens/no-extra-parens._ts_.test.ts
index b46f0f44..5a53bacf 100644
--- a/packages/eslint-plugin/rules/no-extra-parens/no-extra-parens._ts_.test.ts
+++ b/packages/eslint-plugin/rules/no-extra-parens/no-extra-parens._ts_.test.ts
@@ -479,5 +479,10 @@ run<RuleOptions, MessageIds>({
         },
       ],
     },
+    {
+      code: 'class A{ accessor [((foo))] = 1 }',
+      output: 'class A{ accessor [(foo)] = 1 }',
+      errors: [{ messageId: 'unexpected' }],
+    },
   ],
 })
diff --git a/packages/eslint-plugin/rules/no-extra-semi/no-extra-semi._ts_.test.ts b/packages/eslint-plugin/rules/no-extra-semi/no-extra-semi._ts_.test.ts
index 66ae60a9..ab1d26ad 100644
--- a/packages/eslint-plugin/rules/no-extra-semi/no-extra-semi._ts_.test.ts
+++ b/packages/eslint-plugin/rules/no-extra-semi/no-extra-semi._ts_.test.ts
@@ -16,6 +16,8 @@ run<RuleOptions, MessageIds>({
       code: $`
         export class Foo {
           public foo: number = 0;
+          accessor bar: number = 1;
+          accessor [baz]: number = 2;
         }
       `,
     },
@@ -23,6 +25,7 @@ run<RuleOptions, MessageIds>({
       code: $`
         export class Foo {
           public foo: number = 0; public bar: number = 1;
+          accessor bar: number = 1; accessor [baz]: number = 2;
         }
       `,
     },
@@ -82,6 +85,27 @@ run<RuleOptions, MessageIds>({
       ],
     },
 
+    // accessor property
+    {
+      code: $`
+        class Foo {
+          accessor foo: number;; accessor [bar]: number;;
+          accessor baz: number;;
+        }
+      `,
+      output: $`
+        class Foo {
+          accessor foo: number; accessor [bar]: number;
+          accessor baz: number;
+        }
+      `,
+      errors: [
+        'unexpected',
+        'unexpected',
+        'unexpected',
+      ],
+    },
+
     // abstract prop/method
     {
       code: $`
diff --git a/packages/eslint-plugin/rules/object-curly-spacing/object-curly-spacing._ts_.test.ts b/packages/eslint-plugin/rules/object-curly-spacing/object-curly-spacing._ts_.test.ts
index bcc6ad92..8b6704be 100644
--- a/packages/eslint-plugin/rules/object-curly-spacing/object-curly-spacing._ts_.test.ts
+++ b/packages/eslint-plugin/rules/object-curly-spacing/object-curly-spacing._ts_.test.ts
@@ -315,6 +315,17 @@ run<RuleOptions, MessageIds>({
       code: 'enum Foo {ONE, TWO,}',
       options: ['never'],
     },
+    {
+      code: `import pkgJson from 'package.json' with {type: 'json'}`,
+    },
+    {
+      code: `export { name } from 'package.json' with { type: 'json' }`,
+      options: ['always'],
+    },
+    {
+      code: `export * from 'package.json' with {type: 'json'}`,
+      options: ['never'],
+    },
   ],
 
   invalid: [
@@ -467,5 +478,31 @@ run<RuleOptions, MessageIds>({
         { messageId: 'requireSpaceBefore' },
       ],
     },
+    {
+      code: `import pkgJson from 'package.json' with { type: 'json' }`,
+      output: `import pkgJson from 'package.json' with {type: 'json'}`,
+      errors: [
+        { messageId: 'unexpectedSpaceAfter' },
+        { messageId: 'unexpectedSpaceBefore' },
+      ],
+    },
+    {
+      code: `export { name } from 'package.json' with {type: 'json'}`,
+      output: `export { name } from 'package.json' with { type: 'json' }`,
+      options: ['always'],
+      errors: [
+        { messageId: 'requireSpaceAfter' },
+        { messageId: 'requireSpaceBefore' },
+      ],
+    },
+    {
+      code: `export * from 'package.json' with { type: 'json' }`,
+      output: `export * from 'package.json' with {type: 'json'}`,
+      options: ['never'],
+      errors: [
+        { messageId: 'unexpectedSpaceAfter' },
+        { messageId: 'unexpectedSpaceBefore' },
+      ],
+    },
   ],
 })
diff --git a/packages/eslint-plugin/rules/operator-linebreak/operator-linebreak.test.ts b/packages/eslint-plugin/rules/operator-linebreak/operator-linebreak.test.ts
index 45adf2be..3c4575b5 100644
--- a/packages/eslint-plugin/rules/operator-linebreak/operator-linebreak.test.ts
+++ b/packages/eslint-plugin/rules/operator-linebreak/operator-linebreak.test.ts
@@ -138,6 +138,41 @@ run<RuleOptions, MessageIds>({
       options: ['none', { overrides: { '=': 'ignore' } }],
       parserOptions: { ecmaVersion: 2022 },
     },
+    {
+      code: 'class C { accessor foo =\n0 }',
+    },
+    {
+      code: 'class C { accessor foo\n= 0 }',
+      options: ['before'],
+    },
+    {
+      code: 'class C { accessor [foo\n]= 0 }',
+      options: ['before'],
+    },
+    {
+      code: 'class C { accessor [foo]\n= 0 }',
+      options: ['before'],
+    },
+    {
+      code: 'class C { accessor [foo\n]\n= 0 }',
+      options: ['before'],
+    },
+    {
+      code: 'class C { accessor [foo\n]= 0 }',
+      options: ['after'],
+    },
+    {
+      code: 'class C { accessor [foo\n]=\n0 }',
+      options: ['after'],
+    },
+    {
+      code: 'class C { accessor [foo\n]= 0 }',
+      options: ['none'],
+    },
+    {
+      code: 'class C { accessor foo\n=\n0 }',
+      options: ['none', { overrides: { '=': 'ignore' } }],
+    },
     // TSImportEqualsDeclaration
     {
       code: $`
@@ -1097,6 +1132,90 @@ run<RuleOptions, MessageIds>({
         endColumn: 3,
       }],
     },
+    {
+      code: 'class C { accessor a\n= 0; }',
+      output: 'class C { accessor a =\n0; }',
+      options: ['after'],
+      errors: [{
+        messageId: 'operatorAtEnd',
+        data: { operator: '=' },
+        type: 'AccessorProperty',
+        line: 2,
+        column: 1,
+        endLine: 2,
+        endColumn: 2,
+      }],
+    },
+    {
+      code: 'class C { accessor a =\n0; }',
+      output: 'class C { accessor a\n= 0; }',
+      options: ['before'],
+      errors: [{
+        messageId: 'operatorAtBeginning',
+        data: { operator: '=' },
+        type: 'AccessorProperty',
+        line: 1,
+        column: 22,
+        endLine: 1,
+        endColumn: 23,
+      }],
+    },
+    {
+      code: 'class C { accessor a =\n0; }',
+      output: 'class C { accessor a =0; }',
+      options: ['none'],
+      errors: [{
+        messageId: 'noLinebreak',
+        data: { operator: '=' },
+        type: 'AccessorProperty',
+        line: 1,
+        column: 22,
+        endLine: 1,
+        endColumn: 23,
+      }],
+    },
+    {
+      code: 'class C { accessor [a]\n= 0; }',
+      output: 'class C { accessor [a] =\n0; }',
+      options: ['after'],
+      errors: [{
+        messageId: 'operatorAtEnd',
+        data: { operator: '=' },
+        type: 'AccessorProperty',
+        line: 2,
+        column: 1,
+        endLine: 2,
+        endColumn: 2,
+      }],
+    },
+    {
+      code: 'class C { accessor [a] =\n0; }',
+      output: 'class C { accessor [a]\n= 0; }',
+      options: ['before'],
+      errors: [{
+        messageId: 'operatorAtBeginning',
+        data: { operator: '=' },
+        type: 'AccessorProperty',
+        line: 1,
+        column: 24,
+        endLine: 1,
+        endColumn: 25,
+      }],
+    },
+    {
+      code: 'class C { accessor [a]\n =0; }',
+      output: 'class C { accessor [a] =0; }',
+      options: ['none'],
+      errors: [{
+        messageId: 'noLinebreak',
+        data: { operator: '=' },
+        type: 'AccessorProperty',
+        line: 2,
+        column: 2,
+        endLine: 2,
+        endColumn: 3,
+      }],
+    },
     // TSImportEqualsDeclaration
     {
       code: $`
diff --git a/packages/eslint-plugin/rules/quotes/quotes._ts_.test.ts b/packages/eslint-plugin/rules/quotes/quotes._ts_.test.ts
index 0348ca7d..4fe679ec 100644
--- a/packages/eslint-plugin/rules/quotes/quotes._ts_.test.ts
+++ b/packages/eslint-plugin/rules/quotes/quotes._ts_.test.ts
@@ -184,6 +184,34 @@ run<RuleOptions, MessageIds>({
       options: ['backtick'],
     },
 
+    // AccessorProperty
+    {
+      code: $`
+        class Foo {
+          accessor a = "";
+          accessor "a-b" = "";
+        }
+      `,
+    },
+    {
+      code: $`
+        class Foo {
+          accessor a = '';
+          accessor 'a-b' = '';
+        }
+      `,
+      options: ['single'],
+    },
+    {
+      code: $`
+        class Foo {
+          accessor a = \`\`;
+          accessor 'a-b' = \`\`;
+        }
+      `,
+      options: ['backtick'],
+    },
+
     // TSAbstractPropertyDefinition
     {
       code: $`
@@ -528,6 +556,98 @@ run<RuleOptions, MessageIds>({
       options: ['backtick'],
     },
 
+    // AccessorProperty
+    {
+      code: $`
+        class Foo {
+          accessor a = '';
+          accessor 'a-b' = '';
+        }
+      `,
+      output: $`
+        class Foo {
+          accessor a = "";
+          accessor "a-b" = "";
+        }
+      `,
+      errors: [
+        {
+          ...useDoubleQuote,
+          line: 2,
+          column: 16,
+        },
+        {
+          ...useDoubleQuote,
+          line: 3,
+          column: 12,
+        },
+        {
+          ...useDoubleQuote,
+          line: 3,
+          column: 20,
+        },
+      ],
+    },
+    {
+      code: $`
+        class Foo {
+          accessor a = "";
+          accessor "a-b" = "";
+        }
+      `,
+      output: $`
+        class Foo {
+          accessor a = '';
+          accessor 'a-b' = '';
+        }
+      `,
+      errors: [
+        {
+          ...useSingleQuote,
+          line: 2,
+          column: 16,
+        },
+        {
+          ...useSingleQuote,
+          line: 3,
+          column: 12,
+        },
+        {
+          ...useSingleQuote,
+          line: 3,
+          column: 20,
+        },
+      ],
+      options: ['single'],
+    },
+    {
+      code: $`
+        class Foo {
+          accessor a = "";
+          accessor "a-b" = "";
+        }
+      `,
+      output: $`
+        class Foo {
+          accessor a = \`\`;
+          accessor "a-b" = \`\`;
+        }
+      `,
+      errors: [
+        {
+          ...useBacktick,
+          line: 2,
+          column: 16,
+        },
+        {
+          ...useBacktick,
+          line: 3,
+          column: 20,
+        },
+      ],
+      options: ['backtick'],
+    },
+
     // TSAbstractPropertyDefinition
     {
       code: $`
diff --git a/packages/eslint-plugin/rules/semi-spacing/semi-spacing._js_.test.ts b/packages/eslint-plugin/rules/semi-spacing/semi-spacing._js_.test.ts
index d18897cd..f859085b 100644
--- a/packages/eslint-plugin/rules/semi-spacing/semi-spacing._js_.test.ts
+++ b/packages/eslint-plugin/rules/semi-spacing/semi-spacing._js_.test.ts
@@ -59,6 +59,8 @@ run<RuleOptions, MessageIds>({
       code: 'class C { foo }',
       parserOptions: { ecmaVersion: 2022 },
     },
+    'class C { accessor foo; accessor [bar]; }',
+    'class C { accessor foo }',
 
     // Empty are ignored (`no-extra-semi` rule will remove those)
     'foo; ;;;;;;;;;',
@@ -485,5 +487,24 @@ run<RuleOptions, MessageIds>({
         endColumn: 15,
       }],
     },
+    {
+      code: 'class C { accessor foo ;accessor [bar] ;}',
+      output: 'class C { accessor foo; accessor [bar];}',
+      errors: [
+        { messageId: 'unexpectedWhitespaceBefore' },
+        { messageId: 'missingWhitespaceAfter' },
+        { messageId: 'unexpectedWhitespaceBefore' },
+      ],
+    },
+    {
+      code: 'class C { accessor foo; accessor [bar]; }',
+      output: 'class C { accessor foo ;accessor [bar] ; }',
+      options: [{ before: true, after: false }],
+      errors: [
+        { messageId: 'missingWhitespaceBefore' },
+        { messageId: 'unexpectedWhitespaceAfter' },
+        { messageId: 'missingWhitespaceBefore' },
+      ],
+    },
   ],
 })
diff --git a/packages/eslint-plugin/rules/semi-style/semi-style.test.ts b/packages/eslint-plugin/rules/semi-style/semi-style.test.ts
index fa519086..065d90fe 100644
--- a/packages/eslint-plugin/rules/semi-style/semi-style.test.ts
+++ b/packages/eslint-plugin/rules/semi-style/semi-style.test.ts
@@ -120,6 +120,25 @@ run<RuleOptions, MessageIds>({
       options: ['last'],
     },
 
+    {
+      code: $`
+        class C {
+          ;foo
+          ;accessor bar
+        }
+      `,
+      options: ['first'],
+    },
+    {
+      code: $`
+        class C {
+          foo;
+          accessor bar;
+        }
+      `,
+      options: ['last'],
+    },
+
     // Class static blocks
     {
       code: $`
@@ -602,6 +621,44 @@ run<RuleOptions, MessageIds>({
         },
       }],
     },
+    {
+      code: $`
+        class C {
+          ;accessor foo
+          ;accessor bar
+        }
+      `,
+      output: $`
+        class C {
+          ;accessor foo;
+        accessor bar
+        }
+      `,
+      options: ['last'],
+      errors: [{
+        messageId: 'expectedSemiColon',
+        data: { pos: 'the end of the previous line' },
+      }],
+    },
+    {
+      code: $`
+        class C {
+          accessor foo;
+          accessor bar
+        }
+      `,
+      output: $`
+        class C {
+          accessor foo
+        ;accessor bar
+        }
+      `,
+      options: ['first'],
+      errors: [{
+        messageId: 'expectedSemiColon',
+        data: { pos: 'the beginning of the next line' },
+      }],
+    },
 
     // Class static blocks
     {
diff --git a/packages/eslint-plugin/rules/semi/semi._js_.test.ts b/packages/eslint-plugin/rules/semi/semi._js_.test.ts
index f4fced85..dafce65f 100644
--- a/packages/eslint-plugin/rules/semi/semi._js_.test.ts
+++ b/packages/eslint-plugin/rules/semi/semi._js_.test.ts
@@ -67,7 +67,6 @@ run<RuleOptions, MessageIds>({
     {
       code: 'class C { static { foo();\n (a) } }',
       options: ['never', { beforeStatementContinuationChars: 'never' }],
-
     },
     {
       code: 'class C { static { do ; while (foo)\n (a)} }',
@@ -241,27 +240,22 @@ run<RuleOptions, MessageIds>({
     {
       code: 'class C {\nfoo;}',
       options: ['always', { omitLastInOneLineClassBody: true }],
-
     },
     {
       code: 'class C {foo;\n}',
       options: ['always', { omitLastInOneLineClassBody: true }],
-
     },
     {
       code: 'class C {foo;\nbar;}',
       options: ['always', { omitLastInOneLineClassBody: true }],
-
     },
     {
       code: '{ foo; }',
       options: ['always', { omitLastInOneLineClassBody: true }],
-
     },
     {
       code: 'class C\n{ foo }',
       options: ['always', { omitLastInOneLineClassBody: true }],
-
     },
 
     // method definitions and static blocks don't have a semicolon.
@@ -447,112 +441,90 @@ run<RuleOptions, MessageIds>({
     // Class fields
     {
       code: 'class C { foo; }',
-
     },
     {
       code: 'class C { foo; }',
       options: ['always'],
-
     },
     {
       code: 'class C { foo }',
       options: ['never'],
-
     },
     {
       code: 'class C { foo = obj\n;[bar] }',
       options: ['never'],
-
     },
     {
       code: 'class C { foo;\n[bar]; }',
       options: ['always'],
-
     },
     {
       code: 'class C { foo\n;[bar] }',
       options: ['never'],
-
     },
     {
       code: 'class C { foo\n[bar] }',
       options: ['never'],
-
     },
     {
       code: 'class C { foo\n;[bar] }',
       options: ['never', { beforeStatementContinuationChars: 'always' }],
-
     },
     {
       code: 'class C { foo\n[bar] }',
       options: ['never', { beforeStatementContinuationChars: 'never' }],
-
     },
     {
       code: 'class C { foo = () => {}\n;[bar] }',
       options: ['never'],
-
     },
     {
       code: 'class C { foo = () => {}\n[bar] }',
       options: ['never'],
-
     },
     {
       code: 'class C { foo = () => {}\n;[bar] }',
       options: ['never', { beforeStatementContinuationChars: 'always' }],
-
     },
     {
       code: 'class C { foo = () => {}\n[bar] }',
       options: ['never', { beforeStatementContinuationChars: 'never' }],
-
     },
     {
       code: 'class C { foo() {} }',
       options: ['always'],
-
     },
     {
       code: 'class C { foo() {}; }', // no-extra-semi reports it
       options: ['never'],
-
     },
     {
       code: 'class C { static {}; }', // no-extra-semi reports it
       options: ['never'],
-
     },
     {
       code: 'class C { a=b;\n*foo() {} }',
       options: ['never'],
-
     },
     {
       code: 'class C { get;\nfoo() {} }',
       options: ['never'],
-
     },
     {
       code: 'class C { set;\nfoo() {} }',
       options: ['never'],
-
     },
     {
       code: 'class C { static;\nfoo() {} }',
       options: ['never'],
-
     },
     {
       code: 'class C { a=b;\nin }',
       options: ['never'],
-
     },
     {
       code: 'class C { a=b;\ninstanceof }',
       options: ['never'],
-
     },
     {
       code: `
@@ -568,7 +540,6 @@ run<RuleOptions, MessageIds>({
                 }
             `,
       options: ['never', { beforeStatementContinuationChars: 'never' }],
-
     },
     {
       code: `
@@ -584,72 +555,58 @@ run<RuleOptions, MessageIds>({
                 }
             `,
       options: ['never', { beforeStatementContinuationChars: 'always' }],
-
     },
     {
       code: 'class C { foo\n[bar] }',
       options: ['never', { beforeStatementContinuationChars: 'always' }],
-
     },
     {
       code: 'class C { foo = () => {}\n[bar] }',
       options: ['never', { beforeStatementContinuationChars: 'always' }],
-
     },
     {
       code: 'class C { foo\n;[bar] }',
       options: ['never', { beforeStatementContinuationChars: 'never' }],
-
     },
     {
       code: 'class C { foo = () => {}\n;[bar] }',
       options: ['never', { beforeStatementContinuationChars: 'never' }],
-
     },
     {
       code: 'class C { [foo] = bar;\nin }',
       options: ['never'],
-
     },
     {
       code: 'class C { #foo = bar;\nin }',
       options: ['never'],
-
     },
     {
       code: 'class C { static static = bar;\nin }',
       options: ['never'],
-
     },
     {
       code: 'class C { [foo];\nin }',
       options: ['never'],
-
     },
     {
       code: 'class C { [get];\nin }',
       options: ['never'],
-
     },
     {
       code: 'class C { [get] = 5;\nin }',
       options: ['never'],
-
     },
     {
       code: 'class C { #get;\nin }',
       options: ['never'],
-
     },
     {
       code: 'class C { #set = 5;\nin }',
       options: ['never'],
-
     },
     {
       code: 'class C { static static;\nin }',
       options: ['never'],
-
     },
   ],
   invalid: [
@@ -1174,7 +1131,6 @@ run<RuleOptions, MessageIds>({
     {
       code: 'class C { static { foo() } }',
       output: 'class C { static { foo(); } }',
-
       errors: [{
         messageId: 'missingSemi',
         type: 'ExpressionStatement',
@@ -1188,7 +1144,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { static { foo() } }',
       output: 'class C { static { foo(); } }',
       options: ['always'],
-
       errors: [{
         messageId: 'missingSemi',
         type: 'ExpressionStatement',
@@ -1201,7 +1156,6 @@ run<RuleOptions, MessageIds>({
     {
       code: 'class C { static { foo(); bar() } }',
       output: 'class C { static { foo(); bar(); } }',
-
       errors: [{
         messageId: 'missingSemi',
         type: 'ExpressionStatement',
@@ -1214,7 +1168,6 @@ run<RuleOptions, MessageIds>({
     {
       code: 'class C { static { foo()\nbar(); } }',
       output: 'class C { static { foo();\nbar(); } }',
-
       errors: [{
         messageId: 'missingSemi',
         type: 'ExpressionStatement',
@@ -1227,7 +1180,6 @@ run<RuleOptions, MessageIds>({
     {
       code: 'class C { static { foo(); bar()\nbaz(); } }',
       output: 'class C { static { foo(); bar();\nbaz(); } }',
-
       errors: [{
         messageId: 'missingSemi',
         type: 'ExpressionStatement',
@@ -1241,7 +1193,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { static { foo(); } }',
       output: 'class C { static { foo() } }',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         type: 'ExpressionStatement',
@@ -1255,7 +1206,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { static { foo();\nbar() } }',
       output: 'class C { static { foo()\nbar() } }',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         type: 'ExpressionStatement',
@@ -1269,7 +1219,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { static { foo()\nbar(); } }',
       output: 'class C { static { foo()\nbar() } }',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         type: 'ExpressionStatement',
@@ -1283,7 +1232,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { static { foo()\nbar();\nbaz() } }',
       output: 'class C { static { foo()\nbar()\nbaz() } }',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         type: 'ExpressionStatement',
@@ -1297,7 +1245,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { static { do ; while (foo)\n (a)} }',
       output: 'class C { static { do ; while (foo);\n (a)} }',
       options: ['never', { beforeStatementContinuationChars: 'always' }],
-
       errors: [{
         messageId: 'missingSemi',
         type: 'DoWhileStatement',
@@ -1311,7 +1258,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { static { do ; while (foo)\n ;(a)} }',
       output: 'class C { static { do ; while (foo)\n (a)} }',
       options: ['never', { beforeStatementContinuationChars: 'never' }],
-
       errors: [{
         messageId: 'extraSemi',
         type: 'DoWhileStatement',
@@ -2096,7 +2042,6 @@ run<RuleOptions, MessageIds>({
     {
       code: 'class C { foo }',
       output: 'class C { foo; }',
-
       errors: [{
         messageId: 'missingSemi',
         line: 1,
@@ -2109,7 +2054,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { foo }',
       output: 'class C { foo; }',
       options: ['always'],
-
       errors: [{
         messageId: 'missingSemi',
         line: 1,
@@ -2122,7 +2066,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { foo; }',
       output: 'class C { foo }',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         line: 1,
@@ -2135,7 +2078,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { foo\n[bar]; }',
       output: 'class C { foo;\n[bar]; }',
       options: ['always'],
-
       errors: [{
         messageId: 'missingSemi',
         line: 1,
@@ -2150,7 +2092,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { [get];\nfoo\n}',
       output: 'class C { [get]\nfoo\n}',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         line: 1,
@@ -2163,7 +2104,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { [set];\nfoo\n}',
       output: 'class C { [set]\nfoo\n}',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         line: 1,
@@ -2176,7 +2116,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { #get;\nfoo\n}',
       output: 'class C { #get\nfoo\n}',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         line: 1,
@@ -2189,7 +2128,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { #set;\nfoo\n}',
       output: 'class C { #set\nfoo\n}',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         line: 1,
@@ -2202,7 +2140,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { #static;\nfoo\n}',
       output: 'class C { #static\nfoo\n}',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         line: 1,
@@ -2215,7 +2152,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { get=1;\nfoo\n}',
       output: 'class C { get=1\nfoo\n}',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         line: 1,
@@ -2228,7 +2164,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { static static;\nfoo\n}',
       output: 'class C { static static\nfoo\n}',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         line: 1,
@@ -2241,7 +2176,6 @@ run<RuleOptions, MessageIds>({
       code: 'class C { static;\n}',
       output: 'class C { static\n}',
       options: ['never'],
-
       errors: [{
         messageId: 'extraSemi',
         line: 1,
diff --git a/packages/eslint-plugin/rules/semi/semi._ts_.test.ts b/packages/eslint-plugin/rules/semi/semi._ts_.test.ts
index 5ca4a5bf..cca8a382 100644
--- a/packages/eslint-plugin/rules/semi/semi._ts_.test.ts
+++ b/packages/eslint-plugin/rules/semi/semi._ts_.test.ts
@@ -15,6 +15,8 @@ run<RuleOptions, MessageIds>({
       'export = Foo;',
       'import f = require("f");',
       'type Foo = {};',
+      'class C { accessor foo; } ',
+      'class C { accessor [foo]; } ',
       // https://github.com/typescript-eslint/typescript-eslint/issues/409
       $`
         class Class {
@@ -209,6 +211,24 @@ run<RuleOptions, MessageIds>({
           },
         ],
       },
+      {
+        code: $`
+          class C {
+            accessor foo;
+            accessor [bar];
+          }
+        `,
+        errors: [{ line: 2 }, { line: 3 }],
+      },
+      {
+        code: $`
+          class C {
+            accessor foo;
+            accessor [bar];
+          }
+        `,
+        errors: [{ line: 2 }, { line: 3 }],
+      },
     ].reduce<InvalidTestCase<RuleOptions, MessageIds>[]>((acc, test) => {
       acc.push({
         code: test.code.replace(/;/g, ''),
diff --git a/packages/eslint-plugin/rules/space-infix-ops/space-infix-ops._ts_.test.ts b/packages/eslint-plugin/rules/space-infix-ops/space-infix-ops._ts_.test.ts
index 557e0d83..2af69501 100644
--- a/packages/eslint-plugin/rules/space-infix-ops/space-infix-ops._ts_.test.ts
+++ b/packages/eslint-plugin/rules/space-infix-ops/space-infix-ops._ts_.test.ts
@@ -2011,6 +2011,20 @@ run<RuleOptions, MessageIds>({
         },
       ],
     },
+    // AccessorProperty
+    {
+      code: `
+        class Test {
+          accessor optional?= false;
+        }
+      `,
+      output: `
+        class Test {
+          accessor optional? = false;
+        }
+      `,
+      errors: [{ messageId: 'missingSpace', column: 29, line: 3 }],
+    },
     {
       code: `
         function foo<T extends string &number>() {}