@depup/typescript-eslint__eslint-plugin 8.68.0-depup.0 → 8.70.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.68.0 |
-| Processed | 2026-08-25 |
+| Original | [@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin) @ 8.70.0 |
+| Processed | 2026-09-08 |
 | 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.6 |
+| ignore | ^7.0.5 | ^7.0.8 |
 
 ---
 

package/changes.json

@@ -2,9 +2,9 @@
   "bumped": {
     "ignore": {
       "from": "^7.0.5",
-      "to": "^7.0.6"
+      "to": "^7.0.8"
     }
   },
-  "timestamp": "2026-08-25T00:16:47.315Z",
+  "timestamp": "2026-09-08T00:33:07.330Z",
   "totalUpdated": 1
 }

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

@@ -51,6 +51,7 @@ declare const _default: {
         '@typescript-eslint/no-extraneous-class': "error";
         '@typescript-eslint/no-floating-promises': "error";
         '@typescript-eslint/no-for-in-array': "error";
+        '@typescript-eslint/no-generated-empty-object-type': "error";
         'no-implied-eval': "off";
         '@typescript-eslint/no-implied-eval': "error";
         '@typescript-eslint/no-import-type-side-effects': "error";

package/dist/configs/eslintrc/all.js

@@ -58,6 +58,7 @@ module.exports = {
         '@typescript-eslint/no-extraneous-class': 'error',
         '@typescript-eslint/no-floating-promises': 'error',
         '@typescript-eslint/no-for-in-array': 'error',
+        '@typescript-eslint/no-generated-empty-object-type': 'error',
         'no-implied-eval': 'off',
         '@typescript-eslint/no-implied-eval': 'error',
         '@typescript-eslint/no-import-type-side-effects': 'error',

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

@@ -17,6 +17,7 @@ declare const _default: {
         '@typescript-eslint/no-duplicate-type-constituents': "off";
         '@typescript-eslint/no-floating-promises': "off";
         '@typescript-eslint/no-for-in-array': "off";
+        '@typescript-eslint/no-generated-empty-object-type': "off";
         '@typescript-eslint/no-implied-eval': "off";
         '@typescript-eslint/no-meaningless-void-operator': "off";
         '@typescript-eslint/no-misused-promises': "off";

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

@@ -20,6 +20,7 @@ module.exports = {
         '@typescript-eslint/no-duplicate-type-constituents': 'off',
         '@typescript-eslint/no-floating-promises': 'off',
         '@typescript-eslint/no-for-in-array': 'off',
+        '@typescript-eslint/no-generated-empty-object-type': 'off',
         '@typescript-eslint/no-implied-eval': 'off',
         '@typescript-eslint/no-meaningless-void-operator': 'off',
         '@typescript-eslint/no-misused-promises': 'off',

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

@@ -9,6 +9,7 @@ declare const _default: {
         '@typescript-eslint/no-duplicate-type-constituents': "error";
         '@typescript-eslint/no-floating-promises': "error";
         '@typescript-eslint/no-for-in-array': "error";
+        '@typescript-eslint/no-generated-empty-object-type': "error";
         'no-implied-eval': "off";
         '@typescript-eslint/no-implied-eval': "error";
         '@typescript-eslint/no-meaningless-void-operator': "error";

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

@@ -16,6 +16,7 @@ module.exports = {
         '@typescript-eslint/no-duplicate-type-constituents': 'error',
         '@typescript-eslint/no-floating-promises': 'error',
         '@typescript-eslint/no-for-in-array': 'error',
+        '@typescript-eslint/no-generated-empty-object-type': 'error',
         'no-implied-eval': 'off',
         '@typescript-eslint/no-implied-eval': 'error',
         '@typescript-eslint/no-meaningless-void-operator': 'error',

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

@@ -20,6 +20,7 @@ declare const _default: {
         '@typescript-eslint/no-extraneous-class': "error";
         '@typescript-eslint/no-floating-promises': "error";
         '@typescript-eslint/no-for-in-array': "error";
+        '@typescript-eslint/no-generated-empty-object-type': "error";
         'no-implied-eval': "off";
         '@typescript-eslint/no-implied-eval': "error";
         '@typescript-eslint/no-invalid-void-type': "error";

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

@@ -28,6 +28,7 @@ module.exports = {
         '@typescript-eslint/no-extraneous-class': 'error',
         '@typescript-eslint/no-floating-promises': 'error',
         '@typescript-eslint/no-for-in-array': 'error',
+        '@typescript-eslint/no-generated-empty-object-type': 'error',
         'no-implied-eval': 'off',
         '@typescript-eslint/no-implied-eval': 'error',
         '@typescript-eslint/no-invalid-void-type': 'error',

package/dist/configs/flat/all.js

@@ -71,6 +71,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-extraneous-class': 'error',
             '@typescript-eslint/no-floating-promises': 'error',
             '@typescript-eslint/no-for-in-array': 'error',
+            '@typescript-eslint/no-generated-empty-object-type': 'error',
             'no-implied-eval': 'off',
             '@typescript-eslint/no-implied-eval': 'error',
             '@typescript-eslint/no-import-type-side-effects': 'error',

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

@@ -25,6 +25,7 @@ exports.default = (_plugin, _parser) => ({
         '@typescript-eslint/no-duplicate-type-constituents': 'off',
         '@typescript-eslint/no-floating-promises': 'off',
         '@typescript-eslint/no-for-in-array': 'off',
+        '@typescript-eslint/no-generated-empty-object-type': 'off',
         '@typescript-eslint/no-implied-eval': 'off',
         '@typescript-eslint/no-meaningless-void-operator': 'off',
         '@typescript-eslint/no-misused-promises': 'off',

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

@@ -29,6 +29,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-duplicate-type-constituents': 'error',
             '@typescript-eslint/no-floating-promises': 'error',
             '@typescript-eslint/no-for-in-array': 'error',
+            '@typescript-eslint/no-generated-empty-object-type': 'error',
             'no-implied-eval': 'off',
             '@typescript-eslint/no-implied-eval': 'error',
             '@typescript-eslint/no-meaningless-void-operator': 'error',

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

@@ -41,6 +41,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-extraneous-class': 'error',
             '@typescript-eslint/no-floating-promises': 'error',
             '@typescript-eslint/no-for-in-array': 'error',
+            '@typescript-eslint/no-generated-empty-object-type': 'error',
             'no-implied-eval': 'off',
             '@typescript-eslint/no-implied-eval': 'error',
             '@typescript-eslint/no-invalid-void-type': 'error',

package/dist/index.d.ts

@@ -53,6 +53,7 @@ declare const _default: {
                 '@typescript-eslint/no-extraneous-class': "error";
                 '@typescript-eslint/no-floating-promises': "error";
                 '@typescript-eslint/no-for-in-array': "error";
+                '@typescript-eslint/no-generated-empty-object-type': "error";
                 'no-implied-eval': "off";
                 '@typescript-eslint/no-implied-eval': "error";
                 '@typescript-eslint/no-import-type-side-effects': "error";
@@ -180,6 +181,7 @@ declare const _default: {
                 '@typescript-eslint/no-duplicate-type-constituents': "off";
                 '@typescript-eslint/no-floating-promises': "off";
                 '@typescript-eslint/no-for-in-array': "off";
+                '@typescript-eslint/no-generated-empty-object-type': "off";
                 '@typescript-eslint/no-implied-eval': "off";
                 '@typescript-eslint/no-meaningless-void-operator': "off";
                 '@typescript-eslint/no-misused-promises': "off";
@@ -468,6 +470,7 @@ declare const _default: {
                 '@typescript-eslint/no-extraneous-class': "error";
                 '@typescript-eslint/no-floating-promises': "error";
                 '@typescript-eslint/no-for-in-array': "error";
+                '@typescript-eslint/no-generated-empty-object-type': "error";
                 'no-implied-eval': "off";
                 '@typescript-eslint/no-implied-eval': "error";
                 '@typescript-eslint/no-invalid-void-type': "error";
@@ -554,6 +557,7 @@ declare const _default: {
                 '@typescript-eslint/no-duplicate-type-constituents': "error";
                 '@typescript-eslint/no-floating-promises': "error";
                 '@typescript-eslint/no-for-in-array': "error";
+                '@typescript-eslint/no-generated-empty-object-type': "error";
                 'no-implied-eval': "off";
                 '@typescript-eslint/no-implied-eval': "error";
                 '@typescript-eslint/no-meaningless-void-operator': "error";
@@ -820,6 +824,9 @@ declare const _default: {
         'no-for-in-array': import("@typescript-eslint/utils/ts-eslint").RuleModule<"forInViolation", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'no-generated-empty-object-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noGeneratedEmptyObjectType", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'no-implied-eval': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noFunctionConstructor" | "noImpliedEvalError", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
@@ -855,7 +862,7 @@ declare const _default: {
         }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOperator" | "removeVoid", import("./rules/no-meaningless-void-operator").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", import("./rules/no-meaningless-void-operator").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         'no-misused-new': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {

package/dist/raw-plugin.d.ts

@@ -75,6 +75,7 @@ declare const _default: {
                     '@typescript-eslint/no-extraneous-class': "error";
                     '@typescript-eslint/no-floating-promises': "error";
                     '@typescript-eslint/no-for-in-array': "error";
+                    '@typescript-eslint/no-generated-empty-object-type': "error";
                     'no-implied-eval': "off";
                     '@typescript-eslint/no-implied-eval': "error";
                     '@typescript-eslint/no-import-type-side-effects': "error";
@@ -202,6 +203,7 @@ declare const _default: {
                     '@typescript-eslint/no-duplicate-type-constituents': "off";
                     '@typescript-eslint/no-floating-promises': "off";
                     '@typescript-eslint/no-for-in-array': "off";
+                    '@typescript-eslint/no-generated-empty-object-type': "off";
                     '@typescript-eslint/no-implied-eval': "off";
                     '@typescript-eslint/no-meaningless-void-operator': "off";
                     '@typescript-eslint/no-misused-promises': "off";
@@ -491,6 +493,7 @@ declare const _default: {
                     '@typescript-eslint/no-extraneous-class': "error";
                     '@typescript-eslint/no-floating-promises': "error";
                     '@typescript-eslint/no-for-in-array': "error";
+                    '@typescript-eslint/no-generated-empty-object-type': "error";
                     'no-implied-eval': "off";
                     '@typescript-eslint/no-implied-eval': "error";
                     '@typescript-eslint/no-invalid-void-type': "error";
@@ -577,6 +580,7 @@ declare const _default: {
                     '@typescript-eslint/no-duplicate-type-constituents': "error";
                     '@typescript-eslint/no-floating-promises': "error";
                     '@typescript-eslint/no-for-in-array': "error";
+                    '@typescript-eslint/no-generated-empty-object-type': "error";
                     'no-implied-eval': "off";
                     '@typescript-eslint/no-implied-eval': "error";
                     '@typescript-eslint/no-meaningless-void-operator': "error";
@@ -843,6 +847,9 @@ declare const _default: {
             'no-for-in-array': TSESLint.RuleModule<"forInViolation", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
+            'no-generated-empty-object-type': TSESLint.RuleModule<"noGeneratedEmptyObjectType", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+                name: string;
+            };
             'no-implied-eval': TSESLint.RuleModule<"noFunctionConstructor" | "noImpliedEvalError", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
@@ -878,7 +885,7 @@ declare const _default: {
             }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
-            'no-meaningless-void-operator': TSESLint.RuleModule<"meaninglessVoidOperator" | "removeVoid", import("./rules/no-meaningless-void-operator").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+            'no-meaningless-void-operator': TSESLint.RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", import("./rules/no-meaningless-void-operator").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
             'no-misused-new': TSESLint.RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {

package/dist/rules/index.d.ts

@@ -145,6 +145,9 @@ declare const rules: {
     'no-for-in-array': import("@typescript-eslint/utils/ts-eslint").RuleModule<"forInViolation", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
+    'no-generated-empty-object-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noGeneratedEmptyObjectType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
     'no-implied-eval': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noFunctionConstructor" | "noImpliedEvalError", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
@@ -180,7 +183,7 @@ declare const rules: {
     }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOperator" | "removeVoid", import("./no-meaningless-void-operator").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", import("./no-meaningless-void-operator").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
     'no-misused-new': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {

package/dist/rules/index.js

@@ -44,6 +44,7 @@ const no_extra_non_null_assertion_1 = __importDefault(require("./no-extra-non-nu
 const no_extraneous_class_1 = __importDefault(require("./no-extraneous-class"));
 const no_floating_promises_1 = __importDefault(require("./no-floating-promises"));
 const no_for_in_array_1 = __importDefault(require("./no-for-in-array"));
+const no_generated_empty_object_type_1 = __importDefault(require("./no-generated-empty-object-type"));
 const no_implied_eval_1 = __importDefault(require("./no-implied-eval"));
 const no_import_type_side_effects_1 = __importDefault(require("./no-import-type-side-effects"));
 const no_inferrable_types_1 = __importDefault(require("./no-inferrable-types"));
@@ -179,6 +180,7 @@ const rules = {
     'no-extraneous-class': no_extraneous_class_1.default,
     'no-floating-promises': no_floating_promises_1.default,
     'no-for-in-array': no_for_in_array_1.default,
+    'no-generated-empty-object-type': no_generated_empty_object_type_1.default,
     'no-implied-eval': no_implied_eval_1.default,
     'no-import-type-side-effects': no_import_type_side_effects_1.default,
     'no-inferrable-types': no_inferrable_types_1.default,

package/dist/rules/member-ordering.js

@@ -330,6 +330,57 @@ function isMemberOptional(node) {
     }
     return false;
 }
+function getMemberInitializer(node) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.AccessorProperty:
+        case utils_1.AST_NODE_TYPES.PropertyDefinition:
+            return node.value;
+    }
+    return undefined;
+}
+function getThisPropertyName(node) {
+    return node.computed
+        ? (0, util_1.getStaticStringValue)(node.property)
+        : node.property.name;
+}
+function isEvaluatedLater(node, initializer) {
+    for (let current = node; current !== initializer.parent; current = (0, util_1.nullThrows)(current.parent, util_1.NullThrowsReasons.MissingParent)) {
+        if (current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            current.type === utils_1.AST_NODE_TYPES.ClassBody ||
+            current.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            return true;
+        }
+    }
+    return false;
+}
+function collectImmediateThisPropertyNames(initializer) {
+    const names = new Set();
+    (0, util_1.forEachChildESTree)(initializer, node => {
+        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+            !isEvaluatedLater(node, initializer)) {
+            const name = getThisPropertyName(node);
+            if (name != null) {
+                names.add(name);
+            }
+        }
+        return null;
+    });
+    return names;
+}
+function isBlockedByEarlierMemberReferences(member, members, fromIndex, toIndex, sourceCode) {
+    const initializer = getMemberInitializer(member);
+    if (!initializer) {
+        return false;
+    }
+    const referencedNames = collectImmediateThisPropertyNames(initializer);
+    return members.slice(fromIndex, toIndex).some(other => {
+        const otherName = getMemberName(other, sourceCode);
+        return (otherName != null &&
+            getMemberInitializer(other) != null &&
+            referencedNames.has(otherName));
+    });
+}
 /**
  * Gets the calculated rank using the provided method definition.
  * The algorithm is as follows:
@@ -664,13 +715,17 @@ exports.default = (0, util_1.createRule)({
          */
         function checkAlphaSort(members, order) {
             let previousName = '';
+            let previousIndex = 0;
             let isCorrectlySorted = true;
             // Find first member which isn't correctly sorted
-            members.forEach(member => {
+            members.forEach((member, index) => {
                 const name = getMemberName(member, context.sourceCode);
                 // Note: Not all members have names
                 if (name) {
                     if (naturalOutOfOrder(name, previousName, order)) {
+                        if (isBlockedByEarlierMemberReferences(member, members, previousIndex, index, context.sourceCode)) {
+                            return;
+                        }
                         context.report({
                             node: member,
                             messageId: 'incorrectOrder',
@@ -682,6 +737,7 @@ exports.default = (0, util_1.createRule)({
                         isCorrectlySorted = false;
                     }
                     previousName = name;
+                    previousIndex = index;
                 }
             });
             return isCorrectlySorted;

package/dist/rules/no-deprecated.js

@@ -291,7 +291,7 @@ exports.default = (0, util_1.createRule)({
                 return (searchForDeprecationInAliasesChain(propertySymbol, true) ??
                     getJsDocDeprecation(property) ??
                     getJsDocDeprecation(propertySymbol) ??
-                    getJsDocDeprecation(valueSymbol));
+                    searchForDeprecationInAliasesChain(valueSymbol, true));
             }
             return searchForDeprecationInAliasesChain(services.getSymbolAtLocation(node), true);
         }

package/dist/rules/no-generated-empty-object-type.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noGeneratedEmptyObjectType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

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

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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");
+exports.default = (0, util_1.createRule)({
+    name: 'no-generated-empty-object-type',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow type operations that resolve to the "empty object" type',
+            recommended: 'strict',
+            requiresTypeChecking: true,
+        },
+        messages: {
+            noGeneratedEmptyObjectType: 'This type resolves to `{}`, the empty object type. This was likely not intentional.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = (0, util_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        function isEmptyObjectType(type) {
+            return (tsutils.isObjectType(type) &&
+                !tsutils.isObjectFlagSet(type, ts.ObjectFlags.Class | ts.ObjectFlags.Interface) &&
+                checker.getPropertiesOfType(type).length === 0 &&
+                checker.getIndexInfosOfType(type).length === 0 &&
+                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));
+        }
+        function containsEmptyObjectType(type) {
+            return (isEmptyObjectType(type) ||
+                (type.isUnion() && type.types.some(isEmptyObjectType)));
+        }
+        function checkNode(node) {
+            if (containsEmptyObjectType(services.getTypeAtLocation(node))) {
+                context.report({
+                    node,
+                    messageId: 'noGeneratedEmptyObjectType',
+                });
+            }
+        }
+        return {
+            TSIntersectionType: checkNode,
+            TSTypeReference(node) {
+                if (node.typeArguments &&
+                    node.parent.type !== utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                    checkNode(node);
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-generated-empty-object-type.js.map

package/dist/rules/no-meaningless-void-operator.d.ts

@@ -4,7 +4,7 @@ export type Options = [
         checkNever: boolean;
     }
 ];
-declare const _default: TSESLint.RuleModule<"meaninglessVoidOperator" | "removeVoid", Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+declare const _default: TSESLint.RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
     name: string;
 };
 export default _default;

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

@@ -49,6 +49,7 @@ exports.default = (0, util_1.createRule)({
         fixable: 'code',
         hasSuggestions: true,
         messages: {
+            meaninglessVoidOnNonCall: "void operator is useless here; it should only discard a call's return value",
             meaninglessVoidOperator: "void operator shouldn't be used on {{type}}; it should convey that a return value is being ignored",
             removeVoid: "Remove 'void'",
         },
@@ -59,7 +60,7 @@ exports.default = (0, util_1.createRule)({
                 properties: {
                     checkNever: {
                         type: 'boolean',
-                        description: 'Whether to suggest removing `void` when the argument has type `never`.',
+                        description: "Whether to suggest removing `void` when a call's return type is `never`.",
                     },
                 },
             },
@@ -77,6 +78,27 @@ exports.default = (0, util_1.createRule)({
                         context.sourceCode.getTokens(node)[1].range[0],
                     ]);
                 };
+                const inner = unwrapVoidArgument(node.argument);
+                if (inner.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                    // `void 0` is a common undefined idiom, not a discarded call.
+                    if (inner.type === utils_1.AST_NODE_TYPES.Literal && inner.value === 0) {
+                        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.
+                    if (tsutils.isThenableType(checker, tsArgument, argType)) {
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'meaninglessVoidOnNonCall',
+                        fix: node.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement
+                            ? fix
+                            : undefined,
+                    });
+                    return;
+                }
                 const argType = services.getTypeAtLocation(node.argument);
                 const unionParts = tsutils.unionConstituents(argType);
                 if (unionParts.every(part => tsutils.isTypeFlagSet(part, ts.TypeFlags.Void | ts.TypeFlags.Undefined))) {
@@ -100,4 +122,23 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+function unwrapVoidArgument(node) {
+    let current = node;
+    while (true) {
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.ChainExpression:
+            case utils_1.AST_NODE_TYPES.TSAsExpression:
+            case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+            case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+                current = current.expression;
+                continue;
+            case utils_1.AST_NODE_TYPES.SequenceExpression:
+                current = (0, util_1.nullThrows)(current.expressions.at(-1), 'Expected SequenceExpression to have at least one expression');
+                continue;
+            default:
+                return current;
+        }
+    }
+}
 //# sourceMappingURL=no-meaningless-void-operator.js.map

package/dist/rules/no-misused-promises.d.ts

@@ -1,11 +1,15 @@
 import type { TSESLint } from '@typescript-eslint/utils';
 export type Options = [
     {
-        checksConditionals?: boolean;
+        checksConditionals?: boolean | ChecksConditionalsOptions;
         checksSpreads?: boolean;
         checksVoidReturn?: boolean | ChecksVoidReturnOptions;
     }
 ];
+export type FlagUnionsOptions = 'all' | 'none' | 'strict';
+export interface ChecksConditionalsOptions {
+    flagUnions?: FlagUnionsOptions;
+}
 export interface ChecksVoidReturnOptions {
     arguments?: boolean;
     attributes?: boolean;

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

@@ -89,8 +89,25 @@ exports.default = (0, util_1.createRule)({
                 additionalProperties: false,
                 properties: {
                     checksConditionals: {
-                        type: 'boolean',
                         description: 'Whether to warn when a Promise is provided to conditional statements.',
+                        oneOf: [
+                            {
+                                type: 'boolean',
+                                description: 'Whether to check conditionals.',
+                            },
+                            {
+                                type: 'object',
+                                additionalProperties: false,
+                                description: 'Detailed settings for conditional inspection.',
+                                properties: {
+                                    flagUnions: {
+                                        type: 'string',
+                                        description: 'Configures how union types containing Promise-like types are checked.',
+                                        enum: ['all', 'strict', 'none'],
+                                    },
+                                },
+                            },
+                        ],
                     },
                     checksSpreads: {
                         type: 'boolean',
@@ -151,6 +168,7 @@ exports.default = (0, util_1.createRule)({
         const services = (0, util_1.getParserServices)(context);
         const checker = services.program.getTypeChecker();
         const checkedNodes = new Set();
+        const flagUnionsOption = normalizeFlagUnionsOption(checksConditionals);
         const conditionalChecks = {
             'CallExpression > MemberExpression': checkArrayPredicates,
             ConditionalExpression: checkTestConditional,
@@ -284,6 +302,22 @@ exports.default = (0, util_1.createRule)({
                     node,
                     messageId: 'conditional',
                 });
+                return;
+            }
+            if (
+            // none -> Report `Promise` but not `Promise | ...`
+            (flagUnionsOption === 'none' && isAlwaysThenable(checker, tsNode)) ||
+                //
+                // all -> Report `Promise` and `Promise | ...`
+                (flagUnionsOption === 'all' && isSometimesThenable(checker, tsNode)) ||
+                //
+                // strict -> Report `Promise<T> | T` but not `Promise<T> | NotT`
+                (flagUnionsOption === 'strict' &&
+                    hasMatchingPromiseTypeArgument(checker, tsNode))) {
+                context.report({
+                    node,
+                    messageId: 'conditional',
+                });
             }
         }
         function checkArrayPredicates(node) {
@@ -801,4 +835,30 @@ function hasWellKnownSymbolWithVoidReturn(checker, node, type, symbolName) {
         return isVoidReturningFunctionType(checker, node, checker.getTypeOfSymbolAtLocation(symbol, node));
     });
 }
+/**
+ * Check that the Promise argument is the same as the rest of the type when it is a Union that contains Promise.
+ */
+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) {
+        return false;
+    }
+    const nonPromiseUnionConstituents = unionConstituents.filter(type => type !== promiseType);
+    const awaitedType = checker.getAwaitedType(promiseType);
+    if (!awaitedType) {
+        return false;
+    }
+    const awaitedTypeConstituents = tsutils.unionConstituents(awaitedType);
+    return (nonPromiseUnionConstituents.length === awaitedTypeConstituents.length &&
+        nonPromiseUnionConstituents.every(type => awaitedTypeConstituents.some(awaited => checker.isTypeAssignableTo(type, awaited) &&
+            checker.isTypeAssignableTo(awaited, type))));
+}
+function normalizeFlagUnionsOption(checksConditionals) {
+    if (!checksConditionals || checksConditionals === true) {
+        return 'none';
+    }
+    return checksConditionals.flagUnions ?? 'none';
+}
 //# sourceMappingURL=no-misused-promises.js.map

package/dist/rules/no-mixed-enums.js

@@ -62,14 +62,40 @@ exports.default = (0, util_1.createRule)({
     create(context) {
         const parserServices = (0, util_1.getParserServices)(context);
         const typeChecker = parserServices.program.getTypeChecker();
+        function getModuleName(id) {
+            if (id.type === utils_1.AST_NODE_TYPES.Literal) {
+                return JSON.stringify(id.value);
+            }
+            let qualifiers = '';
+            let current = id;
+            while (current.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                qualifiers = `.${current.right.name}${qualifiers}`;
+                current = current.left;
+            }
+            return context.sourceCode.getText(current) + qualifiers;
+        }
+        function getMergedScopes(scope) {
+            const { block } = scope;
+            if (block.type !== utils_1.AST_NODE_TYPES.TSModuleDeclaration) {
+                return [scope];
+            }
+            const name = getModuleName(block.id);
+            return getEnclosingScopes(block).flatMap(enclosing => enclosing.childScopes.filter(childScope => childScope.block.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration &&
+                getModuleName(childScope.block.id) === name));
+        }
+        function getEnclosingScopes(node) {
+            const enclosing = (0, util_1.nullThrows)(context.sourceCode.getScope(node).upper, util_1.NullThrowsReasons.MissingParent);
+            return node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration
+                ? getMergedScopes(enclosing)
+                : [enclosing];
+        }
         function collectNodeDefinitions(node) {
             const { name } = node.id;
             const found = {
                 imports: [],
                 previousSibling: undefined,
             };
-            let scope = context.sourceCode.getScope(node);
-            for (const definition of scope.upper?.set.get(name)?.defs ?? []) {
+            for (const definition of getEnclosingScopes(node).flatMap(enclosing => enclosing.set.get(name)?.defs ?? [])) {
                 if (definition.node.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration &&
                     definition.node.range[0] < node.range[0] &&
                     definition.node.body.members.length > 0) {
@@ -77,6 +103,7 @@ exports.default = (0, util_1.createRule)({
                     break;
                 }
             }
+            let scope = context.sourceCode.getScope(node);
             while (scope) {
                 scope.set.get(name)?.defs.forEach(definition => {
                     if (definition.type === scope_manager_1.DefinitionType.ImportBinding) {
@@ -138,33 +165,16 @@ exports.default = (0, util_1.createRule)({
             // Case: Multiple enum declarations in the same file
             // enum MyEnum { A }
             // enum MyEnum { B }
-            if (previousSibling) {
-                return getMemberType(previousSibling.body.members[0]);
-            }
-            // Case: Namespace declaration merging
+            //
+            // ...including ones merged across namespace declarations
             // namespace MyNamespace {
             //   export enum MyEnum { A }
             // }
             // namespace MyNamespace {
             //   export enum MyEnum { B }
             // }
-            if (node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
-                node.parent.parent.type === utils_1.AST_NODE_TYPES.TSModuleBlock) {
-                // https://github.com/typescript-eslint/typescript-eslint/issues/8352
-                // TODO: We don't need to dip into the TypeScript type checker here!
-                // Merged namespaces must all exist in the same file.
-                // We could instead compare this file's nodes to find the merges.
-                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.id);
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const declarations = typeChecker
-                    .getSymbolAtLocation(tsNode)
-                    .getDeclarations();
-                const [{ initializer }] = declarations[0]
-                    .members;
-                return initializer &&
-                    tsutils.isTypeFlagSet(typeChecker.getTypeAtLocation(initializer), ts.TypeFlags.StringLike)
-                    ? AllowedType.String
-                    : AllowedType.Number;
+            if (previousSibling) {
+                return getMemberType(previousSibling.body.members[0]);
             }
             // Finally, we default to the type of the first enum member
             return getMemberType(node.body.members[0]);

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

@@ -110,6 +110,24 @@ function booleanComparison(left, operator, right) {
             return left >= right;
     }
 }
+function isOnlyUsedForTruthiness(node) {
+    const parent = node.parent;
+    switch (parent.type) {
+        case utils_1.AST_NODE_TYPES.ConditionalExpression:
+        case utils_1.AST_NODE_TYPES.DoWhileStatement:
+        case utils_1.AST_NODE_TYPES.ForStatement:
+        case utils_1.AST_NODE_TYPES.IfStatement:
+        case utils_1.AST_NODE_TYPES.WhileStatement:
+            return parent.test === node;
+        case utils_1.AST_NODE_TYPES.LogicalExpression:
+            return ((parent.operator === '&&' && parent.left === node) ||
+                isOnlyUsedForTruthiness(parent));
+        case utils_1.AST_NODE_TYPES.UnaryExpression:
+            return parent.operator === '!';
+        default:
+            return false;
+    }
+}
 const constantLoopConditionsAllowedLiterals = new Set([
     true,
     false,
@@ -266,15 +284,20 @@ exports.default = (0, util_1.createRule)({
             if (!isNoUncheckedIndexedAccess && isArrayIndexExpression(expression)) {
                 return;
             }
-            // When checking logical expressions, only check the right side
-            //  as the left side has been checked by checkLogicalExpressionForUnnecessaryConditionals
+            // Only check the right side when the logical expression is used for
+            // truthiness, as the left side has already been checked by
+            // checkLogicalExpressionForUnnecessaryConditionals.
             //
-            // Unless the node is nullish coalescing, as it's common to use patterns like `nullBool ?? true` to to strict
-            //  boolean checks if we inspect the right here, it'll usually be a constant condition on purpose.
+            // Unless the node is nullish coalescing, as it's common to use patterns like
+            // `nullBool ?? true` to perform strict boolean checks. If we inspect the right
+            // here, it'll usually be a constant condition on purpose.
             // In this case it's better to inspect the type of the expression as a whole.
             if (expression.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
                 expression.operator !== '??') {
-                return checkNode(expression.right);
+                if (isOnlyUsedForTruthiness(expression)) {
+                    checkNode(expression.right);
+                }
+                return;
             }
             const type = (0, util_1.getConstrainedTypeAtLocation)(services, expression);
             if (isConditionalAlwaysNecessary(type)) {

package/dist/rules/unified-signatures.js

@@ -334,8 +334,7 @@ exports.default = (0, util_1.createRule)({
                 (b.type === utils_1.AST_NODE_TYPES.RestElement) && optionalA === optionalB);
         }
         function typeParametersAreEqual(a, b) {
-            return (a.name.name === b.name.name &&
-                constraintsAreEqual(a.constraint, b.constraint));
+            return (a.name.name === b.name.name && typesAreEqual(a.constraint, b.constraint));
         }
         function typesAreEqual(a, b) {
             return (a === b ||
@@ -343,9 +342,6 @@ exports.default = (0, util_1.createRule)({
                     b != null &&
                     context.sourceCode.getText(a) === context.sourceCode.getText(b)));
         }
-        function constraintsAreEqual(a, b) {
-            return a === b || (a != null && a.type === b?.type);
-        }
         /* Returns the first index where `a` and `b` differ. */
         function getIndexOfFirstDifference(a, b, equal) {
             for (let i = 0; i < a.length && i < b.length; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/typescript-eslint__eslint-plugin",
-  "version": "8.68.0-depup.0",
+  "version": "8.70.0-depup.0",
   "description": "TypeScript plugin for ESLint (with updated dependencies)",
   "files": [
     "dist",
@@ -55,11 +55,11 @@
   ],
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.68.0",
-    "@typescript-eslint/type-utils": "8.68.0",
-    "@typescript-eslint/utils": "8.68.0",
-    "@typescript-eslint/visitor-keys": "8.68.0",
-    "ignore": "^7.0.6",
+    "@typescript-eslint/scope-manager": "8.70.0",
+    "@typescript-eslint/type-utils": "8.70.0",
+    "@typescript-eslint/utils": "8.70.0",
+    "@typescript-eslint/visitor-keys": "8.70.0",
+    "ignore": "^7.0.8",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0"
   },
@@ -68,8 +68,8 @@
     "@types/mdast": "^4.0.4",
     "@types/natural-compare": "^1.4.3",
     "@types/react": "^18.3.21",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.68.0",
-    "@typescript-eslint/rule-tester": "8.68.0",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.70.0",
+    "@typescript-eslint/rule-tester": "8.70.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@vitest/coverage-v8": "^4.0.18",
     "ajv": "^6.12.6",
@@ -89,7 +89,7 @@
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.68.0",
+    "@typescript-eslint/parser": "^8.70.0",
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0"
   },
@@ -105,12 +105,12 @@
     "targets": {
       "generate-breaking-changes": {
         "command": "tsx tools/generate-breaking-changes.mts",
-        "options": {
-          "cwd": "{projectRoot}"
-        },
         "dependsOn": [
           "type-utils:build"
-        ]
+        ],
+        "options": {
+          "cwd": "{projectRoot}"
+        }
       },
       "lint": {
         "command": "eslint"
@@ -121,10 +121,10 @@
         "dependsOn": [
           "build"
         ],
+        "command": "pnpm pack --out attw-check.tgz && attw attw-check.tgz --profile node16 --exclude-entrypoints use-at-your-own-risk/raw-plugin --exclude-entrypoints use-at-your-own-risk/rules --ignore-rules named-exports",
         "options": {
           "cwd": "{projectRoot}"
-        },
-        "command": "pnpm pack --out attw-check.tgz && attw attw-check.tgz --profile node16 --exclude-entrypoints use-at-your-own-risk/raw-plugin --exclude-entrypoints use-at-your-own-risk/rules --ignore-rules named-exports"
+        }
       }
     }
   },
@@ -144,13 +144,13 @@
     "changes": {
       "ignore": {
         "from": "^7.0.5",
-        "to": "^7.0.6"
+        "to": "^7.0.8"
       }
     },
     "depsUpdated": 1,
     "originalPackage": "@typescript-eslint/eslint-plugin",
-    "originalVersion": "8.68.0",
-    "processedAt": "2026-08-25T00:16:59.780Z",
+    "originalVersion": "8.70.0",
+    "processedAt": "2026-09-08T00:33:17.890Z",
     "smokeTest": "passed"
   }
 }