@typescript-eslint/eslint-plugin 8.0.0-alpha.3 → 8.0.0-alpha.30

package/docs/rules/no-unnecessary-boolean-literal-compare.mdx

@@ -114,11 +114,11 @@ if (someNullCondition !== false) {
 
 ```ts option='{ "allowComparingNullableBooleansToFalse": false }'
 declare const someUndefinedCondition: boolean | undefined;
-if (someUndefinedCondition ?? true) {
+if (!(someUndefinedCondition ?? true)) {
 }
 
 declare const someNullCondition: boolean | null;
-if (!(someNullCondition ?? true)) {
+if (someNullCondition ?? true) {
 }
 ```
 
@@ -127,16 +127,16 @@ if (!(someNullCondition ?? true)) {
 
 ## Fixer
 
-|            Comparison             | Fixer Output                    | Notes                                                                               |
-| :-------------------------------: | ------------------------------- | ----------------------------------------------------------------------------------- |
-|       `booleanVar === true`       | `booleanVar`                    |                                                                                     |
-|       `booleanVar !== true`       | `!booleanVar`                   |                                                                                     |
-|      `booleanVar === false`       | `!booleanVar`                   |                                                                                     |
-|      `booleanVar !== false`       | `booleanVar`                    |                                                                                     |
-|   `nullableBooleanVar === true`   | `nullableBooleanVar`            | Only checked/fixed if the `allowComparingNullableBooleansToTrue` option is `false`  |
-|   `nullableBooleanVar !== true`   | `!nullableBooleanVar`           | Only checked/fixed if the `allowComparingNullableBooleansToTrue` option is `false`  |
-| `!(nullableBooleanVar === false)` | `nullableBooleanVar ?? true`    | Only checked/fixed if the `allowComparingNullableBooleansToFalse` option is `false` |
-| `!(nullableBooleanVar !== false)` | `!(nullableBooleanVar ?? true)` | Only checked/fixed if the `allowComparingNullableBooleansToFalse` option is `false` |
+|           Comparison           | Fixer Output                    | Notes                                                                               |
+| :----------------------------: | ------------------------------- | ----------------------------------------------------------------------------------- |
+|     `booleanVar === true`      | `booleanVar`                    |                                                                                     |
+|     `booleanVar !== true`      | `!booleanVar`                   |                                                                                     |
+|     `booleanVar === false`     | `!booleanVar`                   |                                                                                     |
+|     `booleanVar !== false`     | `booleanVar`                    |                                                                                     |
+| `nullableBooleanVar === true`  | `nullableBooleanVar`            | Only checked/fixed if the `allowComparingNullableBooleansToTrue` option is `false`  |
+| `nullableBooleanVar !== true`  | `!nullableBooleanVar`           | Only checked/fixed if the `allowComparingNullableBooleansToTrue` option is `false`  |
+| `nullableBooleanVar === false` | `!(nullableBooleanVar ?? true)` | Only checked/fixed if the `allowComparingNullableBooleansToFalse` option is `false` |
+| `nullableBooleanVar !== false` | `nullableBooleanVar ?? true`    | Only checked/fixed if the `allowComparingNullableBooleansToFalse` option is `false` |
 
 ## When Not To Use It
 

package/docs/rules/no-unnecessary-template-expression.mdx

@@ -0,0 +1,85 @@
+---
+description: 'Disallow unnecessary template expressions.'
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-unnecessary-template-expression** for documentation.
+
+This rule reports template literals that contain substitution expressions (also variously referred to as embedded expressions or string interpolations) that are unnecessary and can be simplified.
+
+:::info[Migration from `no-useless-template-literals`]
+
+This rule was formerly known as [`no-useless-template-literals`](./no-useless-template-literals.mdx).
+The new name is a drop-in replacement with identical functionality.
+
+:::
+
+## Examples
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts
+// Static values can be incorporated into the surrounding template.
+
+const ab1 = `${'a'}${'b'}`;
+const ab2 = `a${'b'}`;
+
+const stringWithNumber = `${'1 + 1 = '}${2}`;
+
+const stringWithBoolean = `${'true is '}${true}`;
+
+// Some simple expressions that are already strings
+// can be rewritten without a template at all.
+
+const text = 'a';
+const wrappedText = `${text}`;
+
+declare const intersectionWithString: string & { _brand: 'test-brand' };
+const wrappedIntersection = `${intersectionWithString}`;
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts
+// Static values can be incorporated into the surrounding template.
+
+const ab1 = `ab`;
+const ab2 = `ab`;
+
+const stringWithNumber = `1 + 1 = 2`;
+
+const stringWithBoolean = `true is true`;
+
+// Some simple expressions that are already strings
+// can be rewritten without a template at all.
+
+const text = 'a';
+const wrappedText = text;
+
+declare const intersectionWithString: string & { _brand: 'test-brand' };
+const wrappedIntersection = intersectionWithString;
+```
+
+</TabItem>
+</Tabs>
+
+:::info
+This rule does not aim to flag template literals without substitution expressions that could have been written as an ordinary string.
+That is to say, this rule will not help you turn `` `this` `` into `"this"`.
+If you are looking for such a rule, you can configure the [`@stylistic/ts/quotes`](https://eslint.style/rules/ts/quotes) rule to do this.
+:::
+
+## When Not To Use It
+
+When you want to allow string expressions inside template literals.
+
+## Related To
+
+- [`restrict-template-expressions`](./restrict-template-expressions.mdx)
+- [`@stylistic/ts/quotes`](https://eslint.style/rules/ts/quotes)

package/docs/rules/no-unused-expressions.mdx

@@ -10,4 +10,44 @@ import TabItem from '@theme/TabItem';
 > See **https://typescript-eslint.io/rules/no-unused-expressions** for documentation.
 
 This rule extends the base [`eslint/no-unused-expressions`](https://eslint.org/docs/rules/no-unused-expressions) rule.
-It adds support for optional call expressions `x?.()`, and directive in module declarations.
+It supports TypeScript-specific expressions:
+
+- Marks directives in modules declarations (`"use strict"`, etc.) as not unused
+- Marks the following expressions as unused if their wrapped value expressions are unused:
+  - Assertion expressions: `x as number;`, `x!;`, `<number>x;`
+  - Instantiation expressions: `Set<number>;`
+
+Although the type expressions never have runtime side effects (that is, `x!;` is the same as `x;`), they can be used to assert types for testing purposes.
+
+## Examples
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts
+Set<number>;
+1 as number;
+window!;
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts
+function getSet() {
+  return Set;
+}
+
+// Funtion calls are allowed, so type expressions that wrap function calls are allowed
+getSet()<number>;
+getSet() as Set<unknown>;
+getSet()!;
+
+// Namespaces can have directives
+namespace A {
+  'use strict';
+}
+```
+
+</TabItem>
+</Tabs>

package/docs/rules/no-unused-vars.mdx

@@ -47,3 +47,8 @@ We generally recommend using `@typescript-eslint/no-unused-vars` to flag unused
 :::tip
 Editors such as VS Code will still generally "grey out" unused variables even if `noUnusedLocals` and `noUnusedParameters` are not enabled in a project.
 :::
+
+Also see similar rules provided by ESLint:
+
+- [`no-unused-private-class-members`](https://eslint.org/docs/latest/rules/no-unused-private-class-members)
+- [`no-unused-labels`](https://eslint.org/docs/latest/rules/no-unused-labels)

package/docs/rules/no-useless-template-literals.mdx

@@ -1,61 +1,5 @@
----
-description: 'Disallow unnecessary template literals.'
----
+:::danger Deprecated
 
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
+This rule has been renamed to [`no-unnecessary-template-expression`](./no-unnecessary-template-expression.mdx). See [#8544](https://github.com/typescript-eslint/typescript-eslint/issues/8544) for more information.
 
-> 🛑 This file is source code, not the primary documentation location! 🛑
->
-> See **https://typescript-eslint.io/rules/no-useless-template-literals** for documentation.
-
-This rule reports template literals that can be simplified to a normal string literal.
-
-## Examples
-
-<Tabs>
-<TabItem value="❌ Incorrect">
-
-```ts
-const ab1 = `${'a'}${'b'}`;
-const ab2 = `a${'b'}`;
-
-const stringWithNumber = `${'1 + 1 = '}${2}`;
-
-const stringWithBoolean = `${'true is '}${true}`;
-
-const text = 'a';
-const wrappedText = `${text}`;
-
-declare const intersectionWithString: string & { _brand: 'test-brand' };
-const wrappedIntersection = `${intersectionWithString}`;
-```
-
-</TabItem>
-<TabItem value="✅ Correct">
-
-```ts
-const ab1 = 'ab';
-const ab2 = 'ab';
-
-const stringWithNumber = `1 + 1 = 2`;
-
-const stringWithBoolean = `true is true`;
-
-const text = 'a';
-const wrappedText = text;
-
-declare const intersectionWithString: string & { _brand: 'test-brand' };
-const wrappedIntersection = intersectionWithString;
-```
-
-</TabItem>
-</Tabs>
-
-## When Not To Use It
-
-When you want to allow string expressions inside template literals.
-
-## Related To
-
-- [`restrict-template-expressions`](./restrict-template-expressions.mdx)
+:::

package/docs/rules/no-var-requires.mdx

@@ -9,6 +9,12 @@ import TabItem from '@theme/TabItem';
 >
 > See **https://typescript-eslint.io/rules/no-var-requires** for documentation.
 
+:::danger Deprecated
+
+This rule has been deprecated in favour of the [`@typescript-eslint/no-require-imports`](./no-require-imports.mdx) rule.
+
+:::
+
 In other words, the use of forms such as `var foo = require("foo")` are banned. Instead use ES6 style imports or `import foo = require("foo")` imports.
 
 ## Examples

package/docs/rules/only-throw-error.mdx

@@ -14,6 +14,13 @@ The fundamental benefit of `Error` objects is that they automatically keep track
 
 This rule restricts what can be thrown as an exception.
 
+:::info[Migration from `no-throw-literal`]
+
+This rule was formerly known as `no-throw-literal`.
+The new name is a drop-in replacement with identical functionality.
+
+:::
+
 ## Examples
 
 This rule is aimed at maintaining consistency when throwing exception by disallowing to throw literals and other expressions which cannot possibly be an `Error` object.

package/docs/rules/prefer-readonly-parameter-types.mdx

@@ -142,11 +142,12 @@ interface Foo {
 
 Some complex types cannot easily be made readonly, for example the `HTMLElement` type or the `JQueryStatic` type from `@types/jquery`. This option allows you to globally disable reporting of such types.
 
-Each item must be one of:
+This option takes an array of type specifiers to ignore.
+Each item in the array must have one of the following forms:
 
-- A type defined in a file (`{from: "file", name: "Foo", path: "src/foo-file.ts"}` with `path` being an optional path relative to the project root directory)
-- A type from the default library (`{from: "lib", name: "Foo"}`)
-- A type from a package (`{from: "package", name: "Foo", package: "foo-lib"}`, this also works for types defined in a typings package).
+- A type defined in a file (`{ from: "file", name: "Foo", path: "src/foo-file.ts" }` with `path` being an optional path relative to the project root directory)
+- A type from the default library (`{ from: "lib", name: "Foo" }`)
+- A type from a package (`{ from: "package", name: "Foo", package: "foo-lib" }`, this also works for types defined in a typings package).
 
 Additionally, a type may be defined just as a simple string, which then matches the type independently of its origin.
 
@@ -401,3 +402,8 @@ function foo(arg: MyType) {}
 ## When Not To Use It
 
 If your project does not attempt to enforce strong immutability guarantees of parameters, you can avoid this rule.
+
+This rule is very strict on what it considers mutable.
+Many types that describe themselves as readonly are considered mutable because they have mutable properties such as arrays or tuples.
+To work around these limitations, you might need to use the rule's options.
+In particular, the [`allow` option](#allow) can explicitly mark a type as readonly.

package/docs/rules/prefer-ts-expect-error.mdx

@@ -9,6 +9,16 @@ import TabItem from '@theme/TabItem';
 >
 > See **https://typescript-eslint.io/rules/prefer-ts-expect-error** for documentation.
 
+:::danger Deprecated
+
+This rule has been deprecated in favor of [`@typescript-eslint/ban-ts-comment`](./ban-ts-comment.mdx).
+This rule (`@typescript-eslint/prefer-ts-expect-error`) will be removed in a future major version of typescript-eslint.
+
+When it was first created, `@typescript-eslint/ban-ts-comment` rule was only responsible for suggesting to remove `@ts-ignore` directive.
+It was later updated to suggest replacing `@ts-ignore` with `@ts-expect-error` directive, so that it replaces `@typescript-eslint/prefer-ts-expect-error` entirely.
+
+:::
+
 TypeScript allows you to suppress all errors on a line by placing a comment starting with `@ts-ignore` or `@ts-expect-error` immediately before the erroring line.
 The two directives work the same, except `@ts-expect-error` causes a type error if placed before a line that's not erroring in the first place.
 

package/docs/rules/require-await.mdx

@@ -1,5 +1,5 @@
 ---
-description: 'Disallow async functions which have no `await` expression.'
+description: 'Disallow async functions which do not return promises and have no `await` expression.'
 ---
 
 import Tabs from '@theme/Tabs';
@@ -10,7 +10,7 @@ import TabItem from '@theme/TabItem';
 > See **https://typescript-eslint.io/rules/require-await** for documentation.
 
 This rule extends the base [`eslint/require-await`](https://eslint.org/docs/rules/require-await) rule.
-It uses type information to add support for `async` functions that return a `Promise`.
+It uses type information to allow promise-returning functions to be marked as `async` without containing an `await` expression.
 
 ## Examples
 

package/docs/rules/restrict-template-expressions.mdx

@@ -10,7 +10,7 @@ import TabItem from '@theme/TabItem';
 > See **https://typescript-eslint.io/rules/restrict-template-expressions** for documentation.
 
 JavaScript automatically [converts an object to a string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#string_coercion) in a string context, such as when concatenating it with a string using `+` or embedding it in a template literal using `${}`.
-The default `toString()` method of objects returns `"[object Object]"`, which is often not what was intended.
+The default `toString()` method of objects uses the format `"[object Object]"`, which is often not what was intended.
 This rule reports on values used in a template literal string that aren't strings, optionally allowing other data types that provide useful stringification results.
 
 :::note

package/docs/rules/return-await.mdx

@@ -26,13 +26,15 @@ const defaultOptions: Options = 'in-try-catch';
 
 ### `in-try-catch`
 
-Requires that a returned promise must be `await`ed in `try-catch-finally` blocks, and disallows it elsewhere.
-Specifically:
+In cases where returning an unawaited promise would cause unexpected error-handling control flow, the rule enforces that `await` must be used.
+Otherwise, the rule enforces that `await` must _not_ be used.
 
-- if you `return` a promise within a `try`, then it must be `await`ed.
-- if you `return` a promise within a `catch`, and there **_is no_** `finally`, then it **_must not_** be `await`ed.
-- if you `return` a promise within a `catch`, and there **_is a_** `finally`, then it **_must_** be `await`ed.
-- if you `return` a promise within a `finally`, then it **_must not_** be `await`ed.
+Listing the error-handling cases exhaustively:
+
+- if you `return` a promise within a `try`, then it must be `await`ed, since it will always be followed by a `catch` or `finally`.
+- if you `return` a promise within a `catch`, and there is _no_ `finally`, then it must _not_ be `await`ed.
+- if you `return` a promise within a `catch`, and there _is_ a `finally`, then it _must_ be `await`ed.
+- if you `return` a promise within a `finally`, then it must not be `await`ed.
 
 Examples of code with `in-try-catch`:
 
@@ -42,23 +44,34 @@ Examples of code with `in-try-catch`:
 ```ts option='"in-try-catch"'
 async function invalidInTryCatch1() {
   try {
-    return Promise.resolve('try');
-  } catch (e) {}
+    return Promise.reject('try');
+  } catch (e) {
+    // Doesn't execute due to missing await.
+  }
 }
 
 async function invalidInTryCatch2() {
   try {
     throw new Error('error');
   } catch (e) {
-    return await Promise.resolve('catch');
+    // Unnecessary await; rejections here don't impact control flow.
+    return await Promise.reject('catch');
   }
 }
 
+// Prints 'starting async work', 'cleanup', 'async work done'.
 async function invalidInTryCatch3() {
+  async function doAsyncWork(): Promise<void> {
+    console.log('starting async work');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    console.log('async work done');
+  }
+
   try {
     throw new Error('error');
   } catch (e) {
-    return Promise.resolve('catch');
+    // Missing await.
+    return doAsyncWork();
   } finally {
     console.log('cleanup');
   }
@@ -70,7 +83,8 @@ async function invalidInTryCatch4() {
   } catch (e) {
     throw new Error('error2');
   } finally {
-    return await Promise.resolve('finally');
+    // Unnecessary await; rejections here don't impact control flow.
+    return await Promise.reject('finally');
   }
 }
 
@@ -89,23 +103,32 @@ async function invalidInTryCatch6() {
 ```ts option='"in-try-catch"'
 async function validInTryCatch1() {
   try {
-    return await Promise.resolve('try');
-  } catch (e) {}
+    return await Promise.reject('try');
+  } catch (e) {
+    // Executes as expected.
+  }
 }
 
 async function validInTryCatch2() {
   try {
     throw new Error('error');
   } catch (e) {
-    return Promise.resolve('catch');
+    return Promise.reject('catch');
   }
 }
 
+// Prints 'starting async work', 'async work done', 'cleanup'.
 async function validInTryCatch3() {
+  async function doAsyncWork(): Promise<void> {
+    console.log('starting async work');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    console.log('async work done');
+  }
+
   try {
     throw new Error('error');
   } catch (e) {
-    return await Promise.resolve('catch');
+    return await doAsyncWork();
   } finally {
     console.log('cleanup');
   }
@@ -117,7 +140,7 @@ async function validInTryCatch4() {
   } catch (e) {
     throw new Error('error2');
   } finally {
-    return Promise.resolve('finally');
+    return Promise.reject('finally');
   }
 }
 

package/docs/rules/sort-type-constituents.mdx

@@ -9,6 +9,12 @@ import TabItem from '@theme/TabItem';
 >
 > See **https://typescript-eslint.io/rules/sort-type-constituents** for documentation.
 
+:::danger Deprecated
+This rule has been deprecated in favor of the [`perfectionist/sort-intersection-types`](https://eslint-plugin-perfectionist.azat.io/rules/sort-intersection-types) and [`perfectionist/sort-union-types`](https://eslint-plugin-perfectionist.azat.io/rules/sort-union-types) rules.
+
+See [Docs: Deprecate sort-type-constituents in favor of eslint-plugin-perfectionist](https://github.com/typescript-eslint/typescript-eslint/issues/8915) and [eslint-plugin: Feature freeze naming and sorting stylistic rules](https://github.com/typescript-eslint/typescript-eslint/issues/8792) for more information.
+:::
+
 Sorting union (`|`) and intersection (`&`) types can help:
 
 - keep your codebase standardized
@@ -19,15 +25,6 @@ This rule reports on any types that aren't sorted alphabetically.
 
 > Types are sorted case-insensitively and treating numbers like a human would, falling back to character code sorting in case of ties.
 
-:::note
-This rule is _feature frozen_: it will no longer receive new features such as new options.
-It still will accept bug and documentation fixes for its existing area of features.
-
-Stylistic rules that enforce naming and/or sorting conventions tend to grow incomprehensibly complex as increasingly obscure features are requested.
-This rule has reached the limit of what is reasonable for the typescript-eslint project to maintain.
-See [eslint-plugin: Feature freeze naming and sorting stylistic rules](https://github.com/typescript-eslint/typescript-eslint/issues/8792) for more information.
-:::
-
 ## Examples
 
 <Tabs>
@@ -97,6 +94,29 @@ type T4 =
 
 ## Options
 
+### `caseSensitive`
+
+Whether to sort using case sensitive string comparisons.
+
+Examples of code with `{ "caseSensitive": true }`:
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts option='{ "caseSensitive": true }'
+type T = 'DeletedAt' | 'DeleteForever';
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts option='{ "caseSensitive": true }'
+type T = 'DeleteForever' | 'DeletedAt';
+```
+
+</TabItem>
+</Tabs>
+
 ### `checkIntersections`
 
 Whether to check intersection types (`&`).

package/docs/rules/sort-type-union-intersection-members.mdx

@@ -0,0 +1,12 @@
+:::danger Deprecated
+
+This rule has been renamed to [`sort-type-constituents`](https://typescript-eslint.io/rules/sort-type-constituents).
+
+:::
+
+<!--
+This doc file has been left on purpose to help direct people to the replacement rule.
+
+Note that there is no actual way to get to this page in the normal navigation,
+so end-users will only be able to get to this page from the search bar.
+-->

package/docs/rules/unbound-method.mdx

@@ -16,7 +16,7 @@ Otherwise, passing class methods around as values can remove type safety by fail
 This rule reports when a class method is referenced in an unbound manner.
 
 :::note Tip
-If you're working with `jest`, you can use [`eslint-plugin-jest`'s version of this rule](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/unbound-method.mdx) to lint your test files, which knows when it's ok to pass an unbound method to `expect` calls.
+If you're working with `jest`, you can use [`eslint-plugin-jest`'s version of this rule](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/unbound-method.md) to lint your test files, which knows when it's ok to pass an unbound method to `expect` calls.
 :::
 
 ## Examples
@@ -105,7 +105,8 @@ log();
 ## When Not To Use It
 
 If your project dynamically changes `this` scopes around in a way TypeScript has difficulties modeling, this rule may not be viable to use.
-One likely difficult pattern is if your code intentionally waits to bind methods after use, such as by passing a `scope: this` along with the method.
+For example, some functions have an additional parameter for specifying the `this` context, such as `Reflect.apply`, and array methods like `Array.prototype.map`.
+This semantic is not easily expressed by TypeScript.
 You might consider using [ESLint disable comments](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) for those specific situations instead of completely disabling this rule.
 
 If you're wanting to use `toBeCalled` and similar matches in `jest` tests, you can disable this rule for your test files in favor of [`eslint-plugin-jest`'s version of this rule](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/unbound-method.mdx).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.0.0-alpha.3",
+  "version": "8.0.0-alpha.30",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -53,39 +53,36 @@
     "clean": "tsc -b tsconfig.build.json --clean",
     "postclean": "rimraf dist && rimraf coverage",
     "format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
-    "generate:breaking-changes": "yarn tsx tools/generate-breaking-changes.mts",
+    "generate:breaking-changes": "tsx tools/generate-breaking-changes.mts",
     "generate:configs": "npx nx run repo-tools:generate-configs",
     "lint": "npx nx lint",
     "test": "cross-env NODE_OPTIONS=\"--experimental-vm-modules\" jest --coverage --logHeapUsage",
     "test-single": "cross-env NODE_OPTIONS=\"--experimental-vm-modules\" jest --no-coverage",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.0.0-alpha.3",
-    "@typescript-eslint/type-utils": "8.0.0-alpha.3",
-    "@typescript-eslint/utils": "8.0.0-alpha.3",
-    "@typescript-eslint/visitor-keys": "8.0.0-alpha.3",
-    "debug": "^4.3.4",
+    "@typescript-eslint/scope-manager": "8.0.0-alpha.30",
+    "@typescript-eslint/type-utils": "8.0.0-alpha.30",
+    "@typescript-eslint/utils": "8.0.0-alpha.30",
+    "@typescript-eslint/visitor-keys": "8.0.0-alpha.30",
     "graphemer": "^1.4.0",
     "ignore": "^5.3.1",
     "natural-compare": "^1.4.0",
-    "semver": "^7.6.0",
     "ts-api-utils": "^1.3.0"
   },
   "devDependencies": {
-    "@types/debug": "*",
-    "@types/marked": "*",
+    "@jest/types": "29.6.3",
+    "@types/marked": "^5.0.2",
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.0.0-alpha.3",
-    "@typescript-eslint/rule-tester": "8.0.0-alpha.3",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.0.0-alpha.30",
+    "@typescript-eslint/rule-tester": "8.0.0-alpha.30",
     "ajv": "^6.12.6",
-    "chalk": "^5.3.0",
     "cross-env": "^7.0.3",
     "cross-fetch": "*",
     "eslint": "*",
-    "grapheme-splitter": "^1.0.4",
+    "espree": "^10.0.1",
     "jest": "29.7.0",
     "jest-specific-snapshot": "^8.0.0",
     "json-schema": "*",
@@ -102,8 +99,8 @@
     "unist-util-visit": "^5.0.0"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^7.0.0",
-    "eslint": "^8.57.0"
+    "@typescript-eslint/parser": "^8.0.0 || ^8.0.0-alpha.0",
+    "eslint": "^8.57.0 || ^9.0.0"
   },
   "peerDependenciesMeta": {
     "typescript": {

package/rules.d.ts

@@ -35,11 +35,15 @@ This is likely not portable. A type annotation is necessary. ts(2742)
 ```
 */
 
-import type { RuleModule } from '@typescript-eslint/utils/ts-eslint';
+import type { RuleModuleWithMetaDocs } from '@typescript-eslint/utils/ts-eslint';
+
+import type { ESLintPluginDocs, ESLintPluginRuleModule } from './src/util';
+
+export { ESLintPluginDocs, ESLintPluginRuleModule };
 
 export type TypeScriptESLintRules = Record<
   string,
-  RuleModule<string, unknown[]>
+  RuleModuleWithMetaDocs<string, unknown[], ESLintPluginDocs>
 >;
 declare const rules: TypeScriptESLintRules;
 // eslint-disable-next-line import/no-default-export