@typescript-eslint/eslint-plugin 8.45.1-alpha.0 → 8.45.1-alpha.10

package/dist/index.d.ts

@@ -785,7 +785,7 @@ declare const _default: {
         'no-unsafe-declaration-merging': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedFunctionType", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeComputedMemberAccess" | "unsafeMemberExpression" | "unsafeThisMemberExpression", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-unsafe-member-access").MessageIds, import("./rules/no-unsafe-member-access").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-unary-minus': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unaryMinus", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/raw-plugin.d.ts

@@ -808,7 +808,7 @@ declare const _default: {
             'no-unsafe-declaration-merging': TSESLint.RuleModule<"unsafeMerging", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-enum-comparison': TSESLint.RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-function-type': TSESLint.RuleModule<"bannedFunctionType", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
-            'no-unsafe-member-access': TSESLint.RuleModule<"unsafeComputedMemberAccess" | "unsafeMemberExpression" | "unsafeThisMemberExpression", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+            'no-unsafe-member-access': TSESLint.RuleModule<import("./rules/no-unsafe-member-access").MessageIds, import("./rules/no-unsafe-member-access").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-return': TSESLint.RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-type-assertion': TSESLint.RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-unary-minus': TSESLint.RuleModule<"unaryMinus", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;

package/dist/rules/ban-ts-comment.js

@@ -52,10 +52,22 @@ exports.default = (0, util_1.createRule)({
                         type: 'number',
                         description: 'A minimum character length for descriptions when `allow-with-description` is enabled.',
                     },
-                    'ts-check': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-                    'ts-expect-error': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-                    'ts-ignore': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-                    'ts-nocheck': { $ref: '#/items/0/$defs/directiveConfigSchema' },
+                    'ts-check': {
+                        $ref: '#/items/0/$defs/directiveConfigSchema',
+                        description: 'Whether allow ts-check directives, and with which restrictions.',
+                    },
+                    'ts-expect-error': {
+                        $ref: '#/items/0/$defs/directiveConfigSchema',
+                        description: 'Whether and when expect-error directives, and with which restrictions.',
+                    },
+                    'ts-ignore': {
+                        $ref: '#/items/0/$defs/directiveConfigSchema',
+                        description: 'Whether allow ts-ignore directives, and with which restrictions.',
+                    },
+                    'ts-nocheck': {
+                        $ref: '#/items/0/$defs/directiveConfigSchema',
+                        description: 'Whether allow ts-nocheck directives, and with which restrictions.',
+                    },
                 },
             },
         ],

package/dist/rules/explicit-member-accessibility.js

@@ -61,13 +61,26 @@ exports.default = (0, util_1.createRule)({
                         additionalProperties: false,
                         description: 'Changes to required accessibility modifiers for specific kinds of class members.',
                         properties: {
-                            accessors: { $ref: '#/items/0/$defs/accessibilityLevel' },
-                            constructors: { $ref: '#/items/0/$defs/accessibilityLevel' },
-                            methods: { $ref: '#/items/0/$defs/accessibilityLevel' },
+                            accessors: {
+                                $ref: '#/items/0/$defs/accessibilityLevel',
+                                description: 'Which member accessibility modifier requirements to apply for accessors.',
+                            },
+                            constructors: {
+                                $ref: '#/items/0/$defs/accessibilityLevel',
+                                description: 'Which member accessibility modifier requirements to apply for constructors.',
+                            },
+                            methods: {
+                                $ref: '#/items/0/$defs/accessibilityLevel',
+                                description: 'Which member accessibility modifier requirements to apply for methods.',
+                            },
                             parameterProperties: {
                                 $ref: '#/items/0/$defs/accessibilityLevel',
+                                description: 'Which member accessibility modifier requirements to apply for parameterProperties.',
+                            },
+                            properties: {
+                                $ref: '#/items/0/$defs/accessibilityLevel',
+                                description: 'Which member accessibility modifier requirements to apply for properties.',
                             },
-                            properties: { $ref: '#/items/0/$defs/accessibilityLevel' },
                         },
                     },
                 },

package/dist/rules/index.d.ts

@@ -115,7 +115,7 @@ declare const rules: {
     'no-unsafe-declaration-merging': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedFunctionType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeComputedMemberAccess" | "unsafeMemberExpression" | "unsafeThisMemberExpression", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unsafe-member-access").MessageIds, import("./no-unsafe-member-access").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-unary-minus': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unaryMinus", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/rules/member-ordering.js

@@ -579,18 +579,23 @@ exports.default = (0, util_1.createRule)({
                 properties: {
                     classes: {
                         $ref: '#/items/0/$defs/baseConfig',
+                        description: 'Which ordering to enforce for classes.',
                     },
                     classExpressions: {
                         $ref: '#/items/0/$defs/baseConfig',
+                        description: 'Which ordering to enforce for classExpressions.',
                     },
                     default: {
                         $ref: '#/items/0/$defs/baseConfig',
+                        description: 'Which ordering to enforce for default.',
                     },
                     interfaces: {
                         $ref: '#/items/0/$defs/typesConfig',
+                        description: 'Which ordering to enforce for interfaces.',
                     },
                     typeLiterals: {
                         $ref: '#/items/0/$defs/typesConfig',
+                        description: 'Which ordering to enforce for typeLiterals.',
                     },
                 },
             },

package/dist/rules/method-signature-style.js

@@ -17,6 +17,7 @@ exports.default = (0, util_1.createRule)({
         schema: [
             {
                 type: 'string',
+                description: 'The method signature style to enforce using.',
                 enum: ['property', 'method'],
             },
         ],

package/dist/rules/no-base-to-string.js

@@ -72,7 +72,7 @@ exports.default = (0, util_1.createRule)({
                     },
                     ignoredTypeNames: {
                         type: 'array',
-                        description: 'Stringified regular expressions of type names to ignore.',
+                        description: 'Stringified type names to ignore.',
                         items: {
                             type: 'string',
                         },

package/dist/rules/no-deprecated.js

@@ -149,6 +149,9 @@ exports.default = (0, util_1.createRule)({
                 case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration:
                 case utils_1.AST_NODE_TYPES.TSTypeParameter:
                     return true;
+                // treat `export import Bar = Foo;` (and `import Foo = require('...')`) as declarations
+                case utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration:
+                    return parent.id === node;
                 default:
                     return false;
             }

package/dist/rules/no-floating-promises.js

@@ -35,7 +35,6 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
 const tsutils = __importStar(require("ts-api-utils"));
-const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
 const promiseUtils_1 = require("../util/promiseUtils");
 const messageBase = 'Promises must be awaited, end with a call to .catch, or end with a call to .then with a rejection handler.';
@@ -141,8 +140,9 @@ exports.default = (0, util_1.createRule)({
                                 {
                                     messageId: 'floatingFixVoid',
                                     fix(fixer) {
-                                        const tsNode = services.esTreeNodeToTSNodeMap.get(node.expression);
-                                        if (isHigherPrecedenceThanUnary(tsNode)) {
+                                        if ((0, util_1.isParenthesized)(expression, context.sourceCode) ||
+                                            (0, util_1.getOperatorPrecedenceForNode)(expression) >
+                                                util_1.OperatorPrecedence.Unary) {
                                             return fixer.insertTextBefore(node, 'void ');
                                         }
                                         return [
@@ -180,8 +180,8 @@ exports.default = (0, util_1.createRule)({
                 expression.operator === 'void') {
                 return fixer.replaceTextRange([expression.range[0], expression.range[0] + 4], 'await');
             }
-            const tsNode = services.esTreeNodeToTSNodeMap.get(node.expression);
-            if (isHigherPrecedenceThanUnary(tsNode)) {
+            if ((0, util_1.isParenthesized)(expression, context.sourceCode) ||
+                (0, util_1.getOperatorPrecedenceForNode)(expression) > util_1.OperatorPrecedence.Unary) {
                 return fixer.insertTextBefore(node, 'await ');
             }
             return [
@@ -199,13 +199,6 @@ exports.default = (0, util_1.createRule)({
             }
             return (0, util_1.typeMatchesSomeSpecifier)(type, allowForKnownSafeCalls, services.program);
         }
-        function isHigherPrecedenceThanUnary(node) {
-            const operator = ts.isBinaryExpression(node)
-                ? node.operatorToken.kind
-                : ts.SyntaxKind.Unknown;
-            const nodePrecedence = (0, util_1.getOperatorPrecedence)(node.kind, operator);
-            return nodePrecedence > util_1.OperatorPrecedence.Unary;
-        }
         function isAsyncIife(node) {
             if (node.expression.type !== utils_1.AST_NODE_TYPES.CallExpression) {
                 return false;

package/dist/rules/no-unnecessary-condition.js

@@ -149,9 +149,11 @@ exports.default = (0, util_1.createRule)({
                         oneOf: [
                             {
                                 type: 'boolean',
+                                description: 'Always ignore or not ignore the loop conditions',
                             },
                             {
                                 type: 'string',
+                                description: 'Which situations to ignore constant conditions in.',
                                 enum: ['always', 'never', 'only-allowed-literals'],
                             },
                         ],

package/dist/rules/no-unsafe-member-access.d.ts

@@ -1,2 +1,8 @@
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeComputedMemberAccess" | "unsafeMemberExpression" | "unsafeThisMemberExpression", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export type Options = [
+    {
+        allowOptionalChaining?: boolean;
+    }
+];
+export type MessageIds = 'unsafeComputedMemberAccess' | 'unsafeMemberExpression' | 'unsafeThisMemberExpression';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
 export default _default;

package/dist/rules/no-unsafe-member-access.js

@@ -40,6 +40,7 @@ var State;
 (function (State) {
     State[State["Unsafe"] = 1] = "Unsafe";
     State[State["Safe"] = 2] = "Safe";
+    State[State["Chained"] = 3] = "Chained";
 })(State || (State = {}));
 function createDataType(type) {
     const isErrorType = tsutils.isIntrinsicErrorType(type);
@@ -62,15 +63,41 @@ exports.default = (0, util_1.createRule)({
                 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
             ].join('\n'),
         },
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowOptionalChaining: {
+                        type: 'boolean',
+                        description: 'Whether to allow `?.` optional chains on `any` values.',
+                    },
+                },
+            },
+        ],
     },
-    defaultOptions: [],
-    create(context) {
+    defaultOptions: [
+        {
+            allowOptionalChaining: false,
+        },
+    ],
+    create(context, [{ allowOptionalChaining }]) {
         const services = (0, util_1.getParserServices)(context);
         const compilerOptions = services.program.getCompilerOptions();
         const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'noImplicitThis');
         const stateCache = new Map();
+        // Case notes:
+        // value?.outer.middle.inner
+        // The ChainExpression is a child of the root expression, and a parent of all the MemberExpressions.
+        // But the left-most expression is what we want to report on: the inner-most expressions.
+        // In fact, this is true even if the chain is on the inside!
+        // value.outer.middle?.inner;
+        // It was already true that every `object` (MemberExpression) has optional: boolean
         function checkMemberExpression(node) {
+            if (allowOptionalChaining && node.optional) {
+                stateCache.set(node, State.Chained);
+                return State.Chained;
+            }
             const cachedState = stateCache.get(node);
             if (cachedState) {
                 return cachedState;
@@ -113,6 +140,10 @@ exports.default = (0, util_1.createRule)({
             // ignore MemberExpressions with ancestors of type `TSClassImplements` or `TSInterfaceHeritage`
             'MemberExpression:not(TSClassImplements MemberExpression, TSInterfaceHeritage MemberExpression)': checkMemberExpression,
             'MemberExpression[computed = true] > *.property'(node) {
+                if (allowOptionalChaining &&
+                    node.parent.optional) {
+                    return;
+                }
                 if (
                 // x[1]
                 node.type === utils_1.AST_NODE_TYPES.Literal ||

package/dist/rules/no-unused-vars.d.ts

@@ -9,6 +9,7 @@ export type Options = [
         destructuredArrayIgnorePattern?: string;
         ignoreClassWithStaticInitBlock?: boolean;
         ignoreRestSiblings?: boolean;
+        ignoreUsingDeclarations?: boolean;
         reportUsedIgnorePattern?: boolean;
         vars?: 'all' | 'local';
         varsIgnorePattern?: string;

package/dist/rules/no-unused-vars.js

@@ -23,6 +23,7 @@ exports.default = (0, util_1.createRule)({
                 oneOf: [
                     {
                         type: 'string',
+                        description: 'Broad setting for unused variables to target.',
                         enum: ['all', 'local'],
                     },
                     {
@@ -59,6 +60,10 @@ exports.default = (0, util_1.createRule)({
                                 type: 'boolean',
                                 description: 'Whether to ignore sibling properties in `...` destructurings.',
                             },
+                            ignoreUsingDeclarations: {
+                                type: 'boolean',
+                                description: 'Whether to ignore using or await using declarations.',
+                            },
                             reportUsedIgnorePattern: {
                                 type: 'boolean',
                                 description: 'Whether to report variables that match any of the valid ignore pattern options if they have been used.',
@@ -87,6 +92,7 @@ exports.default = (0, util_1.createRule)({
                 caughtErrors: 'all',
                 ignoreClassWithStaticInitBlock: false,
                 ignoreRestSiblings: false,
+                ignoreUsingDeclarations: false,
                 reportUsedIgnorePattern: false,
                 vars: 'all',
             };
@@ -98,6 +104,9 @@ exports.default = (0, util_1.createRule)({
                 options.args = firstOption.args ?? options.args;
                 options.ignoreRestSiblings =
                     firstOption.ignoreRestSiblings ?? options.ignoreRestSiblings;
+                options.ignoreUsingDeclarations =
+                    firstOption.ignoreUsingDeclarations ??
+                        options.ignoreUsingDeclarations;
                 options.caughtErrors = firstOption.caughtErrors ?? options.caughtErrors;
                 options.ignoreClassWithStaticInitBlock =
                     firstOption.ignoreClassWithStaticInitBlock ??
@@ -381,6 +390,11 @@ exports.default = (0, util_1.createRule)({
                     }
                     continue;
                 }
+                if (def.type === utils_1.TSESLint.Scope.DefinitionType.Variable &&
+                    options.ignoreUsingDeclarations &&
+                    (def.parent.kind === 'await using' || def.parent.kind === 'using')) {
+                    continue;
+                }
                 if (hasRestSpreadSibling(variable)) {
                     continue;
                 }

package/dist/rules/no-use-before-define.js

@@ -165,6 +165,7 @@ exports.default = (0, util_1.createRule)({
                 oneOf: [
                     {
                         type: 'string',
+                        description: 'Broadly set functions and allowNamedExports to false.',
                         enum: ['nofunc'],
                     },
                     {

package/dist/rules/unbound-method.js

@@ -99,7 +99,10 @@ const isNotImported = (symbol, currentSourceFile) => {
     return (!!currentSourceFile &&
         currentSourceFile !== valueDeclaration.getSourceFile());
 };
-const BASE_MESSAGE = 'Avoid referencing unbound methods which may cause unintentional scoping of `this`.';
+const BASE_MESSAGE = [
+    `A method that is not declared with \`this: void\` may cause unintentional scoping of \`this\` when separated from its object.`,
+    `Consider using an arrow function or explicitly \`.bind()\`ing the method to avoid calling the method with an unintended \`this\` value. `,
+].join('\n');
 exports.default = (0, util_1.createRule)({
     name: 'unbound-method',
     meta: {
@@ -111,7 +114,7 @@ exports.default = (0, util_1.createRule)({
         },
         messages: {
             unbound: BASE_MESSAGE,
-            unboundWithoutThisAnnotation: `${BASE_MESSAGE}\nIf your function does not access \`this\`, you can annotate it with \`this: void\`, or consider using an arrow function instead.`,
+            unboundWithoutThisAnnotation: `${BASE_MESSAGE}\nIf a function does not access \`this\`, it can be annotated with \`this: void\`.`,
         },
         schema: [
             {

package/dist/util/getOperatorPrecedence.d.ts

@@ -28,6 +28,10 @@ export declare enum OperatorPrecedence {
     Lowest = 0,
     Invalid = -1
 }
+/**
+ * Note that this does not take into account parenthesization. You should check
+ * for parenthesization separately if it's relevant to your usage.
+ */
 export declare function getOperatorPrecedenceForNode(node: TSESTree.Node): OperatorPrecedence;
 type TSESTreeOperatorKind = ValueOf<TSESTree.BinaryOperatorToText> | ValueOf<TSESTree.PunctuatorTokenToText>;
 export declare function getOperatorPrecedence(nodeKind: SyntaxKind, operatorKind: SyntaxKind, hasArguments?: boolean): OperatorPrecedence;

package/dist/util/getOperatorPrecedence.js

@@ -175,6 +175,10 @@ var OperatorPrecedence;
     // parsing to stop.
     OperatorPrecedence[OperatorPrecedence["Invalid"] = -1] = "Invalid";
 })(OperatorPrecedence || (exports.OperatorPrecedence = OperatorPrecedence = {}));
+/**
+ * Note that this does not take into account parenthesization. You should check
+ * for parenthesization separately if it's relevant to your usage.
+ */
 function getOperatorPrecedenceForNode(node) {
     switch (node.type) {
         case utils_1.AST_NODE_TYPES.SpreadElement:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.45.1-alpha.0",
+  "version": "8.45.1-alpha.10",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.45.1-alpha.0",
-    "@typescript-eslint/type-utils": "8.45.1-alpha.0",
-    "@typescript-eslint/utils": "8.45.1-alpha.0",
-    "@typescript-eslint/visitor-keys": "8.45.1-alpha.0",
+    "@typescript-eslint/scope-manager": "8.45.1-alpha.10",
+    "@typescript-eslint/type-utils": "8.45.1-alpha.10",
+    "@typescript-eslint/utils": "8.45.1-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.45.1-alpha.10",
     "graphemer": "^1.4.0",
     "ignore": "^7.0.0",
     "natural-compare": "^1.4.0",
@@ -71,8 +71,8 @@
   "devDependencies": {
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.45.1-alpha.0",
-    "@typescript-eslint/rule-tester": "8.45.1-alpha.0",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.45.1-alpha.10",
+    "@typescript-eslint/rule-tester": "8.45.1-alpha.10",
     "@vitest/coverage-v8": "^3.1.3",
     "ajv": "^6.12.6",
     "cross-fetch": "*",
@@ -92,7 +92,7 @@
     "vitest": "^3.1.3"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.45.1-alpha.0",
+    "@typescript-eslint/parser": "^8.45.1-alpha.10",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },