@depup/typescript-eslint__eslint-plugin 8.70.0-depup.0 → 8.71.0-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/typescript-eslint__eslint-plugin
 
 | Field | Value |
 |-------|-------|
-| Original | [@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin) @ 8.70.0 |
-| Processed | 2026-09-08 |
+| Original | [@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin) @ 8.71.0 |
+| Processed | 2026-09-29 |
 | Smoke test | passed |
 | Deps updated | 1 |
 
@@ -22,7 +22,7 @@ npm install @depup/typescript-eslint__eslint-plugin
 
 | Dependency | From | To |
 |------------|------|-----|
-| ignore | ^7.0.5 | ^7.0.8 |
+| ignore | ^7.0.5 | ^7.0.10 |
 
 ---
 

package/changes.json

@@ -2,9 +2,9 @@
   "bumped": {
     "ignore": {
       "from": "^7.0.5",
-      "to": "^7.0.8"
+      "to": "^7.0.10"
     }
   },
-  "timestamp": "2026-09-08T00:33:07.330Z",
+  "timestamp": "2026-09-29T00:34:06.060Z",
   "totalUpdated": 1
 }

package/dist/configs/eslintrc/all.d.ts

@@ -92,6 +92,7 @@ declare const _default: {
         '@typescript-eslint/no-unsafe-assignment': "error";
         '@typescript-eslint/no-unsafe-call': "error";
         '@typescript-eslint/no-unsafe-declaration-merging': "error";
+        '@typescript-eslint/no-unsafe-enum-assignment': "error";
         '@typescript-eslint/no-unsafe-enum-comparison': "error";
         '@typescript-eslint/no-unsafe-function-type': "error";
         '@typescript-eslint/no-unsafe-member-access': "error";

package/dist/configs/eslintrc/all.js

@@ -99,6 +99,7 @@ module.exports = {
         '@typescript-eslint/no-unsafe-assignment': 'error',
         '@typescript-eslint/no-unsafe-call': 'error',
         '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+        '@typescript-eslint/no-unsafe-enum-assignment': 'error',
         '@typescript-eslint/no-unsafe-enum-comparison': 'error',
         '@typescript-eslint/no-unsafe-function-type': 'error',
         '@typescript-eslint/no-unsafe-member-access': 'error',

package/dist/configs/eslintrc/disable-type-checked.d.ts

@@ -35,6 +35,7 @@ declare const _default: {
         '@typescript-eslint/no-unsafe-argument': "off";
         '@typescript-eslint/no-unsafe-assignment': "off";
         '@typescript-eslint/no-unsafe-call': "off";
+        '@typescript-eslint/no-unsafe-enum-assignment': "off";
         '@typescript-eslint/no-unsafe-enum-comparison': "off";
         '@typescript-eslint/no-unsafe-member-access': "off";
         '@typescript-eslint/no-unsafe-return': "off";

package/dist/configs/eslintrc/disable-type-checked.js

@@ -38,6 +38,7 @@ module.exports = {
         '@typescript-eslint/no-unsafe-argument': 'off',
         '@typescript-eslint/no-unsafe-assignment': 'off',
         '@typescript-eslint/no-unsafe-call': 'off',
+        '@typescript-eslint/no-unsafe-enum-assignment': 'off',
         '@typescript-eslint/no-unsafe-enum-comparison': 'off',
         '@typescript-eslint/no-unsafe-member-access': 'off',
         '@typescript-eslint/no-unsafe-return': 'off',

package/dist/configs/eslintrc/strict-type-checked-only.d.ts

@@ -27,6 +27,7 @@ declare const _default: {
         '@typescript-eslint/no-unsafe-argument': "error";
         '@typescript-eslint/no-unsafe-assignment': "error";
         '@typescript-eslint/no-unsafe-call': "error";
+        '@typescript-eslint/no-unsafe-enum-assignment': "error";
         '@typescript-eslint/no-unsafe-enum-comparison': "error";
         '@typescript-eslint/no-unsafe-member-access': "error";
         '@typescript-eslint/no-unsafe-return': "error";

package/dist/configs/eslintrc/strict-type-checked-only.js

@@ -34,6 +34,7 @@ module.exports = {
         '@typescript-eslint/no-unsafe-argument': 'error',
         '@typescript-eslint/no-unsafe-assignment': 'error',
         '@typescript-eslint/no-unsafe-call': 'error',
+        '@typescript-eslint/no-unsafe-enum-assignment': 'error',
         '@typescript-eslint/no-unsafe-enum-comparison': 'error',
         '@typescript-eslint/no-unsafe-member-access': 'error',
         '@typescript-eslint/no-unsafe-return': 'error',

package/dist/configs/eslintrc/strict-type-checked.d.ts

@@ -48,6 +48,7 @@ declare const _default: {
         '@typescript-eslint/no-unsafe-assignment': "error";
         '@typescript-eslint/no-unsafe-call': "error";
         '@typescript-eslint/no-unsafe-declaration-merging': "error";
+        '@typescript-eslint/no-unsafe-enum-assignment': "error";
         '@typescript-eslint/no-unsafe-enum-comparison': "error";
         '@typescript-eslint/no-unsafe-function-type': "error";
         '@typescript-eslint/no-unsafe-member-access': "error";

package/dist/configs/eslintrc/strict-type-checked.js

@@ -56,6 +56,7 @@ module.exports = {
         '@typescript-eslint/no-unsafe-assignment': 'error',
         '@typescript-eslint/no-unsafe-call': 'error',
         '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+        '@typescript-eslint/no-unsafe-enum-assignment': 'error',
         '@typescript-eslint/no-unsafe-enum-comparison': 'error',
         '@typescript-eslint/no-unsafe-function-type': 'error',
         '@typescript-eslint/no-unsafe-member-access': 'error',

package/dist/configs/flat/all.js

@@ -112,6 +112,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-unsafe-assignment': 'error',
             '@typescript-eslint/no-unsafe-call': 'error',
             '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+            '@typescript-eslint/no-unsafe-enum-assignment': 'error',
             '@typescript-eslint/no-unsafe-enum-comparison': 'error',
             '@typescript-eslint/no-unsafe-function-type': 'error',
             '@typescript-eslint/no-unsafe-member-access': 'error',

package/dist/configs/flat/disable-type-checked.js

@@ -43,6 +43,7 @@ exports.default = (_plugin, _parser) => ({
         '@typescript-eslint/no-unsafe-argument': 'off',
         '@typescript-eslint/no-unsafe-assignment': 'off',
         '@typescript-eslint/no-unsafe-call': 'off',
+        '@typescript-eslint/no-unsafe-enum-assignment': 'off',
         '@typescript-eslint/no-unsafe-enum-comparison': 'off',
         '@typescript-eslint/no-unsafe-member-access': 'off',
         '@typescript-eslint/no-unsafe-return': 'off',

package/dist/configs/flat/strict-type-checked-only.js

@@ -47,6 +47,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-unsafe-argument': 'error',
             '@typescript-eslint/no-unsafe-assignment': 'error',
             '@typescript-eslint/no-unsafe-call': 'error',
+            '@typescript-eslint/no-unsafe-enum-assignment': 'error',
             '@typescript-eslint/no-unsafe-enum-comparison': 'error',
             '@typescript-eslint/no-unsafe-member-access': 'error',
             '@typescript-eslint/no-unsafe-return': 'error',

package/dist/configs/flat/strict-type-checked.js

@@ -69,6 +69,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-unsafe-assignment': 'error',
             '@typescript-eslint/no-unsafe-call': 'error',
             '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+            '@typescript-eslint/no-unsafe-enum-assignment': 'error',
             '@typescript-eslint/no-unsafe-enum-comparison': 'error',
             '@typescript-eslint/no-unsafe-function-type': 'error',
             '@typescript-eslint/no-unsafe-member-access': 'error',

package/dist/index.d.ts

@@ -94,6 +94,7 @@ declare const _default: {
                 '@typescript-eslint/no-unsafe-assignment': "error";
                 '@typescript-eslint/no-unsafe-call': "error";
                 '@typescript-eslint/no-unsafe-declaration-merging': "error";
+                '@typescript-eslint/no-unsafe-enum-assignment': "error";
                 '@typescript-eslint/no-unsafe-enum-comparison': "error";
                 '@typescript-eslint/no-unsafe-function-type': "error";
                 '@typescript-eslint/no-unsafe-member-access': "error";
@@ -199,6 +200,7 @@ declare const _default: {
                 '@typescript-eslint/no-unsafe-argument': "off";
                 '@typescript-eslint/no-unsafe-assignment': "off";
                 '@typescript-eslint/no-unsafe-call': "off";
+                '@typescript-eslint/no-unsafe-enum-assignment': "off";
                 '@typescript-eslint/no-unsafe-enum-comparison': "off";
                 '@typescript-eslint/no-unsafe-member-access': "off";
                 '@typescript-eslint/no-unsafe-return': "off";
@@ -498,6 +500,7 @@ declare const _default: {
                 '@typescript-eslint/no-unsafe-assignment': "error";
                 '@typescript-eslint/no-unsafe-call': "error";
                 '@typescript-eslint/no-unsafe-declaration-merging': "error";
+                '@typescript-eslint/no-unsafe-enum-assignment': "error";
                 '@typescript-eslint/no-unsafe-enum-comparison': "error";
                 '@typescript-eslint/no-unsafe-function-type': "error";
                 '@typescript-eslint/no-unsafe-member-access': "error";
@@ -575,6 +578,7 @@ declare const _default: {
                 '@typescript-eslint/no-unsafe-argument': "error";
                 '@typescript-eslint/no-unsafe-assignment': "error";
                 '@typescript-eslint/no-unsafe-call': "error";
+                '@typescript-eslint/no-unsafe-enum-assignment': "error";
                 '@typescript-eslint/no-unsafe-enum-comparison': "error";
                 '@typescript-eslint/no-unsafe-member-access': "error";
                 '@typescript-eslint/no-unsafe-return': "error";
@@ -957,6 +961,9 @@ 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> & {
             name: string;
         };
+        'no-unsafe-enum-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeEnumAccess" | "unsafeEnumArgument" | "unsafeEnumAssertion" | "unsafeEnumAssignment" | "unsafeEnumMutation" | "unsafeEnumReturn", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
@@ -994,7 +1001,7 @@ declare const _default: {
         'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
+        'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "removeDefaultAssignment" | "useOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
             allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
         }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;

package/dist/raw-plugin.d.ts

@@ -116,6 +116,7 @@ declare const _default: {
                     '@typescript-eslint/no-unsafe-assignment': "error";
                     '@typescript-eslint/no-unsafe-call': "error";
                     '@typescript-eslint/no-unsafe-declaration-merging': "error";
+                    '@typescript-eslint/no-unsafe-enum-assignment': "error";
                     '@typescript-eslint/no-unsafe-enum-comparison': "error";
                     '@typescript-eslint/no-unsafe-function-type': "error";
                     '@typescript-eslint/no-unsafe-member-access': "error";
@@ -221,6 +222,7 @@ declare const _default: {
                     '@typescript-eslint/no-unsafe-argument': "off";
                     '@typescript-eslint/no-unsafe-assignment': "off";
                     '@typescript-eslint/no-unsafe-call': "off";
+                    '@typescript-eslint/no-unsafe-enum-assignment': "off";
                     '@typescript-eslint/no-unsafe-enum-comparison': "off";
                     '@typescript-eslint/no-unsafe-member-access': "off";
                     '@typescript-eslint/no-unsafe-return': "off";
@@ -521,6 +523,7 @@ declare const _default: {
                     '@typescript-eslint/no-unsafe-assignment': "error";
                     '@typescript-eslint/no-unsafe-call': "error";
                     '@typescript-eslint/no-unsafe-declaration-merging': "error";
+                    '@typescript-eslint/no-unsafe-enum-assignment': "error";
                     '@typescript-eslint/no-unsafe-enum-comparison': "error";
                     '@typescript-eslint/no-unsafe-function-type': "error";
                     '@typescript-eslint/no-unsafe-member-access': "error";
@@ -598,6 +601,7 @@ declare const _default: {
                     '@typescript-eslint/no-unsafe-argument': "error";
                     '@typescript-eslint/no-unsafe-assignment': "error";
                     '@typescript-eslint/no-unsafe-call': "error";
+                    '@typescript-eslint/no-unsafe-enum-assignment': "error";
                     '@typescript-eslint/no-unsafe-enum-comparison': "error";
                     '@typescript-eslint/no-unsafe-member-access': "error";
                     '@typescript-eslint/no-unsafe-return': "error";
@@ -980,6 +984,9 @@ declare const _default: {
             'no-unsafe-declaration-merging': TSESLint.RuleModule<"unsafeMerging", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
+            'no-unsafe-enum-assignment': TSESLint.RuleModule<"unsafeEnumAccess" | "unsafeEnumArgument" | "unsafeEnumAssertion" | "unsafeEnumAssignment" | "unsafeEnumMutation" | "unsafeEnumReturn", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+                name: string;
+            };
             'no-unsafe-enum-comparison': TSESLint.RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
@@ -1017,7 +1024,7 @@ declare const _default: {
             'no-useless-constructor': TSESLint.RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
-            'no-useless-default-assignment': TSESLint.RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
+            'no-useless-default-assignment': TSESLint.RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "removeDefaultAssignment" | "useOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
                 allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
             }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;

package/dist/rules/await-thenable.js

@@ -77,7 +77,18 @@ exports.default = (0, util_1.createRule)({
                                 messageId: 'removeAwait',
                                 fix(fixer) {
                                     const awaitKeyword = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isAwaitKeyword), util_1.NullThrowsReasons.MissingToken('await', 'await expression'));
-                                    return fixer.remove(awaitKeyword);
+                                    const awaitTokenRemovalRange = (0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitKeyword);
+                                    const awaitRemovalFix = fixer.removeRange(awaitTokenRemovalRange);
+                                    const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(awaitKeyword), util_1.NullThrowsReasons.MissingToken('operand', 'await expression'));
+                                    if ((0, util_1.isStartOfArrowFunctionBodyNeedingParentheses)(node, firstOperandToken, context.sourceCode) ||
+                                        (0, util_1.isStartOfExpressionStatementNeedingParentheses)(node, firstOperandToken)) {
+                                        return [
+                                            awaitRemovalFix,
+                                            fixer.insertTextBefore(awaitArgumentEsNode, '('),
+                                            fixer.insertTextAfter(awaitArgumentEsNode, ')'),
+                                        ];
+                                    }
+                                    return awaitRemovalFix;
                                 },
                             },
                         ],
@@ -135,7 +146,7 @@ exports.default = (0, util_1.createRule)({
                                 messageId: 'convertToOrdinaryFor',
                                 fix(fixer) {
                                     const awaitToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isAwaitKeyword), util_1.NullThrowsReasons.MissingToken('await', 'for await loop'));
-                                    return fixer.remove(awaitToken);
+                                    return fixer.removeRange((0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitToken));
                                 },
                             },
                         ],
@@ -168,7 +179,7 @@ exports.default = (0, util_1.createRule)({
                                     messageId: 'removeAwait',
                                     fix(fixer) {
                                         const awaitToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isAwaitKeyword), util_1.NullThrowsReasons.MissingToken('await', 'await using'));
-                                        return fixer.remove(awaitToken);
+                                        return fixer.removeRange((0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitToken));
                                     },
                                 },
                             }),

package/dist/rules/enum-utils/shared.d.ts

@@ -24,6 +24,10 @@ export declare function getEnumTypes(typeChecker: ts.TypeChecker, type: ts.Type)
  * compared against a non-enum value of the same primitive kind.
  */
 export declare function isMismatchedEnumComparisonTypes(typeChecker: ts.TypeChecker, leftType: ts.Type, rightType: ts.Type): boolean;
+/**
+ * @returns What type a type's enum value is (number or string), if either.
+ */
+export declare function getEnumValueType(type: ts.Type): ts.TypeFlags | undefined;
 /**
  * Returns the enum key that matches the given literal node, or null if none
  * match. For example:

package/dist/rules/enum-utils/shared.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnumLiterals = getEnumLiterals;
 exports.getEnumTypes = getEnumTypes;
 exports.isMismatchedEnumComparisonTypes = isMismatchedEnumComparisonTypes;
+exports.getEnumValueType = getEnumValueType;
 exports.getEnumKeyForLiteral = getEnumKeyForLiteral;
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));

package/dist/rules/index.d.ts

@@ -278,6 +278,9 @@ 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> & {
         name: string;
     };
+    'no-unsafe-enum-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeEnumAccess" | "unsafeEnumArgument" | "unsafeEnumAssertion" | "unsafeEnumAssignment" | "unsafeEnumMutation" | "unsafeEnumReturn", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
     'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
@@ -315,7 +318,7 @@ declare const rules: {
     'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
+    'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "removeDefaultAssignment" | "useOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
         allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
     }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;

package/dist/rules/index.js

@@ -84,6 +84,7 @@ const no_unsafe_argument_1 = __importDefault(require("./no-unsafe-argument"));
 const no_unsafe_assignment_1 = __importDefault(require("./no-unsafe-assignment"));
 const no_unsafe_call_1 = __importDefault(require("./no-unsafe-call"));
 const no_unsafe_declaration_merging_1 = __importDefault(require("./no-unsafe-declaration-merging"));
+const no_unsafe_enum_assignment_1 = __importDefault(require("./no-unsafe-enum-assignment"));
 const no_unsafe_enum_comparison_1 = __importDefault(require("./no-unsafe-enum-comparison"));
 const no_unsafe_function_type_1 = __importDefault(require("./no-unsafe-function-type"));
 const no_unsafe_member_access_1 = __importDefault(require("./no-unsafe-member-access"));
@@ -220,6 +221,7 @@ const rules = {
     'no-unsafe-assignment': no_unsafe_assignment_1.default,
     'no-unsafe-call': no_unsafe_call_1.default,
     'no-unsafe-declaration-merging': no_unsafe_declaration_merging_1.default,
+    'no-unsafe-enum-assignment': no_unsafe_enum_assignment_1.default,
     'no-unsafe-enum-comparison': no_unsafe_enum_comparison_1.default,
     'no-unsafe-function-type': no_unsafe_function_type_1.default,
     'no-unsafe-member-access': no_unsafe_member_access_1.default,

package/dist/rules/no-explicit-any.js

@@ -155,6 +155,14 @@ exports.default = (0, util_1.createRule)({
                 return fixer.replaceText(node.parent, 'PropertyKey');
             };
         }
+        function createUnknownFixer(node) {
+            return (fixer) => {
+                return fixer.replaceText(node, node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+                    isNodeRestElementInFunction(node.parent.parent)
+                    ? 'unknown[]'
+                    : 'unknown');
+            };
+        }
         return {
             TSAnyKeyword(node) {
                 const isKeyofAny = isNodeWithinKeyofAny(node);
@@ -173,7 +181,7 @@ exports.default = (0, util_1.createRule)({
                         : [
                             {
                                 messageId: 'suggestUnknown',
-                                fix: fixer => fixer.replaceText(node, 'unknown'),
+                                fix: createUnknownFixer(node),
                             },
                             {
                                 messageId: 'suggestNever',
@@ -184,7 +192,7 @@ exports.default = (0, util_1.createRule)({
                 if (fixToUnknown) {
                     fixOrSuggest.fix = isKeyofAny
                         ? createPropertyKeyFixer(node)
-                        : fixer => fixer.replaceText(node, 'unknown');
+                        : createUnknownFixer(node);
                 }
                 context.report({
                     node,

package/dist/rules/no-generated-empty-object-type.js

@@ -63,8 +63,12 @@ exports.default = (0, util_1.createRule)({
                 type.getCallSignatures().length === 0 &&
                 type.getConstructSignatures().length === 0 &&
                 // Types still awaiting type arguments, such as `Record<T, unknown>`
-                // inside a generic declaration, also have no members yet.
-                checker.isTypeAssignableTo(checker.getNumberType(), type));
+                // inside a generic declaration, also have no members yet. Every
+                // primitive is assignable to `{}`, so probing with more than one of
+                // them rules those out: a mapped type whose keys are not resolved yet,
+                // such as `{ [K in Keys<T>]: K }`, accepts `number` but not `string`.
+                checker.isTypeAssignableTo(checker.getNumberType(), type) &&
+                checker.isTypeAssignableTo(checker.getStringType(), type));
         }
         function containsEmptyObjectType(type) {
             return (isEmptyObjectType(type) ||

package/dist/rules/no-meaningless-void-operator.js

@@ -84,6 +84,11 @@ exports.default = (0, util_1.createRule)({
                     if (inner.type === utils_1.AST_NODE_TYPES.Literal && inner.value === 0) {
                         return;
                     }
+                    // `void (x = value)` discards the assignment result so the
+                    // expression evaluates to undefined (e.g. `() => void (x = 1)`).
+                    if (inner.type === utils_1.AST_NODE_TYPES.AssignmentExpression) {
+                        return;
+                    }
                     const tsArgument = services.esTreeNodeToTSNodeMap.get(node.argument);
                     const argType = services.getTypeAtLocation(node.argument);
                     // Allow `void promiseValue` so this rule does not fight no-floating-promises.

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

@@ -509,8 +509,13 @@ exports.default = (0, util_1.createRule)({
                 while (current && !(0, util_1.isFunction)(current)) {
                     current = current.parent;
                 }
-                return (0, util_1.nullThrows)(current, util_1.NullThrowsReasons.MissingParent);
+                return current;
             })();
+            // A `return` with no enclosing function is legal in a CommonJS module, and
+            // there is no function signature for the returned value to be misused against.
+            if (!functionNode) {
+                return;
+            }
             if (functionNode.returnType &&
                 !isPossiblyFunctionType(functionNode.returnType)) {
                 return;
@@ -841,19 +846,23 @@ function hasWellKnownSymbolWithVoidReturn(checker, node, type, symbolName) {
 function hasMatchingPromiseTypeArgument(checker, node) {
     const type = checker.getTypeAtLocation(node);
     const unionConstituents = tsutils.unionConstituents(checker.getApparentType(type));
-    const promiseType = unionConstituents.find(type => tsutils.isThenableType(checker, node, type));
-    if (!promiseType) {
+    const promiseTypes = unionConstituents.filter(type => tsutils.isThenableType(checker, node, type));
+    if (promiseTypes.length === 0) {
         return false;
     }
-    const nonPromiseUnionConstituents = unionConstituents.filter(type => type !== promiseType);
-    const awaitedType = checker.getAwaitedType(promiseType);
-    if (!awaitedType) {
-        return false;
+    const nonPromiseUnionConstituents = unionConstituents.filter(type => !promiseTypes.includes(type));
+    const awaitedTypeConstituents = [];
+    for (const promiseType of promiseTypes) {
+        const awaitedType = checker.getAwaitedType(promiseType);
+        if (!awaitedType) {
+            return false;
+        }
+        awaitedTypeConstituents.push(...tsutils.unionConstituents(awaitedType));
     }
-    const awaitedTypeConstituents = tsutils.unionConstituents(awaitedType);
-    return (nonPromiseUnionConstituents.length === awaitedTypeConstituents.length &&
-        nonPromiseUnionConstituents.every(type => awaitedTypeConstituents.some(awaited => checker.isTypeAssignableTo(type, awaited) &&
-            checker.isTypeAssignableTo(awaited, type))));
+    const typesAreEquivalent = (left, right) => checker.isTypeAssignableTo(left, right) &&
+        checker.isTypeAssignableTo(right, left);
+    return (nonPromiseUnionConstituents.every(type => awaitedTypeConstituents.some(awaited => typesAreEquivalent(type, awaited))) &&
+        awaitedTypeConstituents.every(awaited => nonPromiseUnionConstituents.some(type => typesAreEquivalent(type, awaited))));
 }
 function normalizeFlagUnionsOption(checksConditionals) {
     if (!checksConditionals || checksConditionals === true) {

package/dist/rules/no-misused-spread.js

@@ -98,7 +98,7 @@ exports.default = (0, util_1.createRule)({
         }
         function getMapSpreadSuggestions(node, type) {
             const types = tsutils.unionConstituents(type);
-            if (types.some(t => !isMap(services.program, t))) {
+            if (types.some(t => !isIterableMap(services.program, t))) {
                 return null;
             }
             if (node.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
@@ -252,6 +252,9 @@ function isClassDeclaration(type) {
 function isMap(program, type) {
     return isTypeRecurser(type, t => (0, util_1.isBuiltinSymbolLike)(program, t, ['Map', 'ReadonlyMap', 'WeakMap']));
 }
+function isIterableMap(program, type) {
+    return isTypeRecurser(type, t => (0, util_1.isBuiltinSymbolLike)(program, t, ['Map', 'ReadonlyMap']));
+}
 function isTypeRecurser(type, predicate) {
     if (type.isUnionOrIntersection()) {
         return type.types.some(t => isTypeRecurser(t, predicate));

package/dist/rules/no-redundant-type-constituents.js

@@ -308,7 +308,9 @@ exports.default = (0, util_1.createRule)({
                                 messageId: 'primitiveOverridden',
                                 data: {
                                     literal: typeValues.map(name => name.typeName).join(' | '),
-                                    primitive: primitiveTypeFlagNames[primitive],
+                                    primitive: primitiveTypeFlagNames[
+                                    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
+                                    primitive],
                                 },
                             });
                         }

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

@@ -41,6 +41,7 @@ const assertionFunctionUtils_1 = require("../util/assertionFunctionUtils");
 // #region
 const nullishFlag = ts.TypeFlags.Undefined | ts.TypeFlags.Null;
 function isNullishType(type) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
     return tsutils.isTypeFlagSet(type, nullishFlag);
 }
 function isAlwaysNullish(type) {
@@ -55,6 +56,15 @@ function isPossiblyNullish(type) {
         .unionConstituents(type)
         .some(t => isNullishType(t) || (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Void));
 }
+/**
+ * Note that this differs from {@link isNullableType} in that it doesn't consider
+ * `any` or `unknown` to be nullable.
+ */
+function isPossiblyNonNullish(type) {
+    return tsutils
+        .unionConstituents(type)
+        .some(t => !isNullishType(t) && !(0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Void));
+}
 function toStaticValue(type) {
     // type.isLiteral() only covers numbers/bigints and strings, hence the rest of the branches.
     if (tsutils.isBooleanLiteralType(type)) {
@@ -262,11 +272,48 @@ exports.default = (0, util_1.createRule)({
             const propertyType = objectType
                 .getProperties()
                 .find(prop => prop.name === propertyName);
-            if (propertyType &&
-                tsutils.isSymbolFlagSet(propertyType, ts.SymbolFlags.Optional)) {
-                return true;
+            return (propertyType != null &&
+                tsutils.isSymbolFlagSet(propertyType, ts.SymbolFlags.Optional));
+        }
+        /**
+         * Obtains the property types of the computed member expression
+         * @param node The member expression
+         * @returns The property types, unless the node isn't computed.
+         */
+        function getComputedMemberPropertyTypes(node) {
+            if (!node.computed) {
+                return undefined;
+            }
+            const objectType = (0, util_1.getConstrainedTypeAtLocation)(services, node.object);
+            const propertyType = (0, util_1.getConstrainedTypeAtLocation)(services, node.property);
+            const propertyTypes = [];
+            for (const keyType of tsutils.unionConstituents(propertyType)) {
+                if (!keyType.isStringLiteral() && !keyType.isNumberLiteral()) {
+                    return undefined;
+                }
+                const selectedType = (0, util_1.getTypeOfPropertyOfName)(checker, objectType, String(keyType.value));
+                if (!selectedType) {
+                    return undefined;
+                }
+                propertyTypes.push(selectedType);
             }
-            return false;
+            return propertyTypes;
+        }
+        /**
+         * Verify if the node may have non-nullish properties
+         * @param node The node to verify
+         * @returns If it may have non-nullish properties, unless the node isn't a
+         * MemberExpression
+         */
+        function hasPossiblyNonNullishComputedMemberProperty(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return false;
+            }
+            const propertyTypes = getComputedMemberPropertyTypes(node);
+            if (propertyTypes == null) {
+                return false;
+            }
+            return propertyTypes.some(isPossiblyNonNullish);
         }
         /**
          * Checks if a conditional node is necessary:
@@ -344,7 +391,8 @@ exports.default = (0, util_1.createRule)({
                     messageId = 'neverNullish';
                 }
             }
-            else if (isAlwaysNullish(type)) {
+            else if (isAlwaysNullish(type) &&
+                !hasPossiblyNonNullishComputedMemberProperty(node)) {
                 messageId = 'alwaysNullish';
             }
             if (messageId) {

package/dist/rules/no-unnecessary-parameter-property-assignment.js

@@ -101,10 +101,6 @@ exports.default = (0, util_1.createRule)({
                 });
             },
             "MethodDefinition[kind='constructor'] > FunctionExpression AssignmentExpression"(node) {
-                const leftName = getPropertyName(node.left);
-                if (!leftName) {
-                    return;
-                }
                 let functionNode = findParentFunction(node);
                 if (functionNode && isArrowIIFE(functionNode)) {
                     functionNode = findParentFunction(functionNode.parent);
@@ -113,6 +109,18 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 const { assignedBeforeUnnecessary, unnecessaryAssignments } = (0, util_1.nullThrows)(reportInfoStack.at(reportInfoStack.length - 1), 'The top of stack should exist');
+                // A prior write to the parameter binding means a later `this.x = x`
+                // may copy a different value than the parameter property initialized.
+                if (node.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    if (isReferenceFromParameter(node.left)) {
+                        assignedBeforeUnnecessary.add(node.left.name);
+                    }
+                    return;
+                }
+                const leftName = getPropertyName(node.left);
+                if (!leftName) {
+                    return;
+                }
                 if (!UNNECESSARY_OPERATORS.has(node.operator)) {
                     assignedBeforeUnnecessary.add(leftName);
                     return;

package/dist/rules/no-unnecessary-type-assertion.d.ts

@@ -4,7 +4,7 @@ export type Options = [
         typesToIgnore?: string[];
     }
 ];
-export type MessageIds = 'contextuallyUnnecessary' | 'unnecessaryAssertion';
+export type MessageIds = 'contextuallyInferredTypeArguments' | 'contextuallyUnnecessary' | 'unnecessaryAssertion';
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };