Repository: eslint-stylistic/eslint-stylistic
Pull request #876 (2025-07-09 02:05:17)

feat(multiline-comment-style): add support for exclamation comments
<!-- 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

This PR add the following changes to the `multiline-comment-style` rule:

#### 1. Add support for exclamation comments

_Exclamation comments_ are block comments which starts with an exclamation mark (`/*! ... */`).
   AS IS using `@stylistic/multiline-comment-style: ["error", "starred-block"]` rule with the    following code comment resulted in error: 
```js
Error: Expected a linebreak after '/*'

/*!
 * Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
 * Copyright (c) 2023-PRESENT ESLint Stylistic contributors
 *
 * Licensed under the MIT license. See LICENSE file in the project root for details.
 */
```
This PR addresses the issue so that the above code is valid. 

#### 2. Add new `checkExclamation` option for the `separate-lines` option.

Like `JSDoc` comment, by default, all exclamation comments are also ignored when `bare-block` and `separate-lines` option is used. This PR add a new `checkExclamation` option to the `separate-lines` option to toggle the exclamation comments exclusion from the `separate-lines` option. 

With `@stylistic/multiline-comment-style: ["error", "separate-lines", { checkExclamation: true }]` the following code would result in error: 
     
```js
Error: Expected multiple line comments instead of a block comment

/*!
  Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
  Copyright (c) 2023-PRESENT ESLint Stylistic contributors

  Licensed under the MIT license. See LICENSE file in the project root for details.
*/
```

### Linked Issues

### Additional context

<!-- e.g. is there anything you'd like reviewers to focus on? -->


9romise: Hi! Thanks for tackling these improvements!

Could you split the PR into separate ones?
1. exclamation comments support
2. autofix behavior changes

This helps us maintain a cleaner version history and safer releases.

Also, could you add a short explanation about exclamation comments in the docs?
IronGeek: > Hi! Thanks for tackling these improvements!
> 
> Could you split the PR into separate ones?
> 
> 1. exclamation comments support
> 2. autofix behavior changes
> 
> This helps us maintain a cleaner version history and safer releases.
> 
> Also, could you add a short explanation about exclamation comments in the docs?

OK, I'll what I can do...
IronGeek: > Also, could you add a short explanation about exclamation comments in the docs?

I'm sorry, I missed that. I've since added that explanation to the docs.
pkg-pr-new[bot]: 
[Open in StackBlitz](https://pkg.pr.new/template/39acba3e-4e55-4873-b6f6-400aa3f5359e)


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


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


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


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-comment-style/README.md b/packages/eslint-plugin/rules/multiline-comment-style/README.md
index b2a20be9..98d38682 100644
--- a/packages/eslint-plugin/rules/multiline-comment-style/README.md
+++ b/packages/eslint-plugin/rules/multiline-comment-style/README.md
@@ -11,16 +11,64 @@ Many style guides require a particular style for comments that span multiple lin
 
 This rule aims to enforce a particular style for multiline comments.
 
+Other than regular JavaScript comments, the following types of comments are recognized by this rule:
+
+1. **[JSDoc comments](https://jsdoc.app/)**
+
+   These are comments which start with a `/**` sequence. They are used to explain the functionality of functions, classes, methods, and other code elements, making the code self-documenting.
+
+   Example:
+
+   ```js
+   /**
+    * Represents a book.
+    * @constructor
+    * @param {string} title - The title of the book.
+    * @param {string} author - The author of the book.
+    */
+   ```
+
+2. **Exclamation comments**
+
+   These are comments which start with a `/*!` sequence. They are conventionally used in JavaScript to indicate a _preserved comment_ or _important comment_. An exclamation comment signals its consumer that the comment should be preserved during processing.
+
+   Exclamation comments are often used for including copyright information, attribution, or other important metadata that needs to remain in the code.
+
+   Example:
+
+   ```js
+   /*!
+    * My JavaScript Library
+    * Copyright (c) 2025 John Doe
+    *
+    * Licensed under the MIT license.
+    */
+   ```
+
+3. **Directive comments**
+
+   These are special comments that convey instructions or metadata to tools like linters, compilers (e.g., TypeScript), or build systems. They are not standard JavaScript comments meant for human readability, but rather specific syntax understood by particular tools to alter their behavior.
+
+   Example:
+
+   ```js
+   // @ts-ignore
+   or
+   /* eslint-disable */
+   ```
+
 ## Options
 
 This rule has a string option, which can have one of the following values:
 
 - `"starred-block"` (default): Disallows consecutive line comments in favor of block comments. Additionally, requires block comments to have an aligned `*` character before each line.
-- `"bare-block"`: Disallows consecutive line comments in favor of block comments, and disallows block comments from having a `"*"` character before each line. This option ignores JSDoc comments.
-- `"separate-lines"`: Disallows block comments in favor of consecutive line comments. By default, this option ignores JSDoc comments. To also apply this rule to JSDoc comments, set the `checkJSDoc` option to `true`.
+- `"bare-block"`: Disallows consecutive line comments in favor of block comments, and disallows block comments from having a `"*"` character before each line. This option ignores JSDoc and Exclamation comments.
+- `"separate-lines"`: Disallows block comments in favor of consecutive line comments. By default, this option ignores JSDoc and Exclamation comments. To also apply this rule to JSDoc comments and or Exclamation comments, set the `checkJSDoc` and or `checkExclamation` option to `true`.
 
 The rule always ignores directive comments such as `/* eslint-disable */`.
 
+## Examples
+
 Examples of **incorrect** code for this rule with the default `"starred-block"` option:
 
 ::: incorrect
@@ -179,6 +227,24 @@ foo();
 
 :::
 
+Examples of **incorrect** code for this rule with the `"separate-lines"` option and `checkExclamation` set to `true`:
+
+::: incorrect
+
+```js
+
+/* eslint @stylistic/multiline-comment-style: ["error", "separate-lines", { "checkExclamation": true }] */
+
+/*!
+ * I am an exclamation comment
+ * and I'm not allowed
+ */
+foo();
+
+```
+
+:::
+
 ## When Not To Use It
 
 If you don't want to enforce a particular style for multiline comments, you can disable the rule.
diff --git a/packages/eslint-plugin/rules/multiline-comment-style/multiline-comment-style.ts b/packages/eslint-plugin/rules/multiline-comment-style/multiline-comment-style.ts
index 2b03ad9e..5869e3b6 100644
--- a/packages/eslint-plugin/rules/multiline-comment-style/multiline-comment-style.ts
+++ b/packages/eslint-plugin/rules/multiline-comment-style/multiline-comment-style.ts
@@ -43,6 +43,9 @@ export default createRule<RuleOptions, MessageIds>({
                 checkJSDoc: {
                   type: 'boolean',
                 },
+                checkExclamation: {
+                  type: 'boolean',
+                },
               },
               additionalProperties: false,
             },
@@ -67,6 +70,7 @@ export default createRule<RuleOptions, MessageIds>({
     const option = context.options[0] || 'starred-block'
     const params = context.options[1] || {}
     const checkJSDoc = !!params.checkJSDoc
+    const checkExclamation = !!params.checkExclamation
 
     // ----------------------------------------------------------------------
     // Helpers
@@ -112,6 +116,22 @@ export default createRule<RuleOptions, MessageIds>({
         && isWhiteSpaces(lines.at(-1)!)
     }
 
+    /**
+     * Checks if a comment group is in exclamation form.
+     * @param firstComment A group of comments, containing either multiple line comments or a single block comment.
+     * @returns Whether or not the comment group is in exclamation form.
+     */
+    function isExclamationComment([firstComment]: Token[]): boolean {
+      if (firstComment.type !== 'Block')
+        return false
+
+      const lines = firstComment.value.split(LINEBREAK_MATCHER)
+
+      return /^!\s*$/u.test(lines[0])
+        && lines.slice(1, -1).every(line => /^\s* /u.test(line))
+        && isWhiteSpaces(lines.at(-1)!)
+    }
+
     /**
      * Processes a comment group that is currently in separate-line form, calculating the offset for each line.
      * @param commentGroup A group of comments containing multiple line comments.
@@ -275,8 +295,8 @@ export default createRule<RuleOptions, MessageIds>({
           const expectedLeadingWhitespace = getInitialOffset(firstComment)
           const expectedLinePrefix = `${expectedLeadingWhitespace} *`
 
-          if (!/^\*?\s*$/u.test(lines[0])) {
-            const start = firstComment.value.startsWith('*') ? firstComment.range[0] + 1 : firstComment.range[0]
+          if (!/^[*!]?\s*$/u.test(lines[0])) {
+            const start = /^[*!]/.test(firstComment.value) ? firstComment.range[0] + 1 : firstComment.range[0]
 
             context.report({
               loc: {
@@ -352,13 +372,14 @@ export default createRule<RuleOptions, MessageIds>({
         const [firstComment] = commentGroup
 
         const isJSDoc = isJSDocComment(commentGroup)
+        const isExclamation = isExclamationComment(commentGroup)
 
-        if (firstComment.type !== 'Block' || (!checkJSDoc && isJSDoc))
+        if (firstComment.type !== 'Block' || (!checkJSDoc && isJSDoc) || (!checkExclamation && isExclamation))
           return
 
         let commentLines = getCommentLines(commentGroup)
 
-        if (isJSDoc)
+        if (isJSDoc || isExclamation)
           commentLines = commentLines.slice(1, commentLines.length - 1)
 
         const tokenAfter = sourceCode.getTokenAfter(firstComment, { includeComments: true })
@@ -378,7 +399,7 @@ export default createRule<RuleOptions, MessageIds>({
         })
       },
       'bare-block': function (commentGroup: Token[]) {
-        if (isJSDocComment(commentGroup))
+        if (isJSDocComment(commentGroup) || isExclamationComment(commentGroup))
           return
 
         const [firstComment] = commentGroup
diff --git a/packages/eslint-plugin/rules/multiline-comment-style/types.d.ts b/packages/eslint-plugin/rules/multiline-comment-style/types.d.ts
index 00975c6f..a854b1ca 100644
--- a/packages/eslint-plugin/rules/multiline-comment-style/types.d.ts
+++ b/packages/eslint-plugin/rules/multiline-comment-style/types.d.ts
@@ -11,6 +11,7 @@ export type MultilineCommentStyleSchema0
       'separate-lines',
       {
         checkJSDoc?: boolean
+        checkExclamation?: boolean
       },
     ]
 
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/multiline-comment-style/multiline-comment-style.test.ts b/packages/eslint-plugin/rules/multiline-comment-style/multiline-comment-style.test.ts
index ac24fbb2..6a53f07c 100644
--- a/packages/eslint-plugin/rules/multiline-comment-style/multiline-comment-style.test.ts
+++ b/packages/eslint-plugin/rules/multiline-comment-style/multiline-comment-style.test.ts
@@ -22,6 +22,15 @@ run<RuleOptions, MessageIds>({
              * a JSDoc comment
              */
         `,
+    `
+            /*!
+             * this is
+             * an exclamation comment
+             */
+        `,
+    `
+            /*! this is a single line exclamation comment */
+        `,
     `
             /* eslint semi: [
               "error"
@@ -234,6 +243,33 @@ run<RuleOptions, MessageIds>({
             `,
       options: ['bare-block'],
     },
+    {
+      code: `
+                /*!
+                 * This is
+                 * an exclamation comment
+                 */
+            `,
+      options: ['separate-lines'],
+    },
+    {
+      code: `
+                /*!
+                 * This is
+                 * an exclamation comment
+                 */
+            `,
+      options: ['starred-block'],
+    },
+    {
+      code: `
+                /*!
+                 * This is
+                 * an exclamation comment
+                 */
+            `,
+      options: ['bare-block'],
+    },
     {
       code: `
                 /* This is
@@ -318,6 +354,39 @@ run<RuleOptions, MessageIds>({
             `,
       options: ['separate-lines'],
     },
+    {
+      code: `
+                /*!
+                 *    Exclamation blocks
+                 *  are
+                 *   ignored
+                 * !
+                 */
+            `,
+      options: ['bare-block'],
+    },
+    {
+      code: `
+                /*!
+                 *    Exclamation blocks
+                 *  are
+                 *   ignored
+                 * !
+                 */
+            `,
+      options: ['starred-block'],
+    },
+    {
+      code: `
+                /*!
+                 *    Exclamation blocks
+                 *  are
+                 *   ignored
+                 * !
+                 */
+            `,
+      options: ['separate-lines'],
+    },
     {
       code: `
                 /*
@@ -451,6 +520,34 @@ run<RuleOptions, MessageIds>({
             `,
       errors: [{ messageId: 'startNewline', line: 2 }],
     },
+    {
+      code: `
+                /*! this Exclamation comment
+                 * is missing a newline
+                 * at the start
+                 */
+            `,
+      output: `
+                /*!
+                 * this Exclamation comment
+                 * is missing a newline
+                 * at the start
+                 */
+            `,
+      errors: [{ messageId: 'startNewline', line: 2 }],
+    },
+    {
+      code: `
+                /*! this Exclamation comment is missing a newline at the start
+                 */
+            `,
+      output: `
+                /*!
+                 * this Exclamation comment is missing a newline at the start
+                 */
+            `,
+      errors: [{ messageId: 'startNewline', line: 2 }],
+    },
     {
       code: `
                 /*
@@ -632,6 +729,20 @@ run<RuleOptions, MessageIds>({
       options: ['separate-lines', { checkJSDoc: true }],
       errors: [{ messageId: 'expectedLines', line: 2 }],
     },
+    {
+      code: `
+                /*!
+                 * Exclamation
+                 * Comment
+                 */
+            `,
+      output: `
+                // Exclamation
+                // Comment
+            `,
+      options: ['separate-lines', { checkExclamation: true }],
+      errors: [{ messageId: 'expectedLines', line: 2 }],
+    },
     {
       code: `
                 /* foo
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>() {}