@typescript-eslint/eslint-plugin 8.67.1-alpha.9 → 8.68.0

package/dist/rules/no-unsafe-enum-comparison.js

@@ -1,74 +1,7 @@
 "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 tsutils = __importStar(require("ts-api-utils"));
-const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
 const shared_1 = require("./enum-utils/shared");
-/**
- * @returns Whether the right type is an unsafe comparison against any left type.
- */
-function typeViolates(leftTypeParts, rightType) {
-    const leftEnumValueTypes = new Set(leftTypeParts.map(getEnumValueType));
-    return ((leftEnumValueTypes.has(ts.TypeFlags.Number) && isNumberLike(rightType)) ||
-        (leftEnumValueTypes.has(ts.TypeFlags.String) && isStringLike(rightType)));
-}
-function isNumberLike(type) {
-    return tsutils
-        .unionConstituents(type)
-        .every(unionPart => tsutils
-        .intersectionConstituents(unionPart)
-        .some(intersectionPart => tsutils.isTypeFlagSet(intersectionPart, ts.TypeFlags.Number | ts.TypeFlags.NumberLike)));
-}
-function isStringLike(type) {
-    return tsutils
-        .unionConstituents(type)
-        .every(unionPart => tsutils
-        .intersectionConstituents(unionPart)
-        .some(intersectionPart => tsutils.isTypeFlagSet(intersectionPart, ts.TypeFlags.String | ts.TypeFlags.StringLike)));
-}
-/**
- * @returns What type a type's enum value is (number or string), if either.
- */
-function getEnumValueType(type) {
-    return tsutils.isTypeFlagSet(type, ts.TypeFlags.EnumLike)
-        ? tsutils.isTypeFlagSet(type, ts.TypeFlags.NumberLiteral)
-            ? ts.TypeFlags.Number
-            : ts.TypeFlags.String
-        : undefined;
-}
 exports.default = (0, util_1.createRule)({
     name: 'no-unsafe-enum-comparison',
     meta: {
@@ -90,55 +23,11 @@ exports.default = (0, util_1.createRule)({
     create(context) {
         const parserServices = (0, util_1.getParserServices)(context);
         const typeChecker = parserServices.program.getTypeChecker();
-        function isMismatchedComparison(leftType, rightType) {
-            // Allow comparisons that don't have anything to do with enums:
-            //
-            // ```ts
-            // 1 === 2;
-            // ```
-            const leftEnumTypes = (0, shared_1.getEnumTypes)(typeChecker, leftType);
-            const rightEnumTypes = new Set((0, shared_1.getEnumTypes)(typeChecker, rightType));
-            if (leftEnumTypes.length === 0 && rightEnumTypes.size === 0) {
-                return false;
-            }
-            // Allow comparisons that share an enum type:
-            //
-            // ```ts
-            // Fruit.Apple === Fruit.Banana;
-            // ```
-            for (const leftEnumType of leftEnumTypes) {
-                if (rightEnumTypes.has(leftEnumType)) {
-                    return false;
-                }
-            }
-            // We need to split the type into the union type parts in order to find
-            // valid enum comparisons like:
-            //
-            // ```ts
-            // declare const something: Fruit | Vegetable;
-            // something === Fruit.Apple;
-            // ```
-            const leftTypeParts = tsutils.unionConstituents(leftType);
-            const rightTypeParts = tsutils.unionConstituents(rightType);
-            // If a type exists in both sides, we consider this comparison safe:
-            //
-            // ```ts
-            // declare const fruit: Fruit.Apple | 0;
-            // fruit === 0;
-            // ```
-            for (const leftTypePart of leftTypeParts) {
-                if (rightTypeParts.includes(leftTypePart)) {
-                    return false;
-                }
-            }
-            return (typeViolates(leftTypeParts, rightType) ||
-                typeViolates(rightTypeParts, leftType));
-        }
         return {
             'BinaryExpression[operator=/^[<>!=]?={0,2}$/]'(node) {
                 const leftType = parserServices.getTypeAtLocation(node.left);
                 const rightType = parserServices.getTypeAtLocation(node.right);
-                if (isMismatchedComparison(leftType, rightType)) {
+                if ((0, shared_1.isMismatchedEnumComparisonTypes)(typeChecker, leftType, rightType)) {
                     context.report({
                         node,
                         messageId: 'mismatchedCondition',
@@ -180,7 +69,7 @@ exports.default = (0, util_1.createRule)({
                 const { parent } = node;
                 const leftType = parserServices.getTypeAtLocation(parent.discriminant);
                 const rightType = parserServices.getTypeAtLocation(node.test);
-                if (isMismatchedComparison(leftType, rightType)) {
+                if ((0, shared_1.isMismatchedEnumComparisonTypes)(typeChecker, leftType, rightType)) {
                     context.report({
                         node,
                         messageId: 'mismatchedCase',
@@ -190,3 +79,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unsafe-enum-comparison.js.map

package/dist/rules/no-unsafe-function-type.js

@@ -43,3 +43,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unsafe-function-type.js.map

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

@@ -181,3 +181,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unsafe-member-access.js.map

package/dist/rules/no-unsafe-return.js

@@ -182,3 +182,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unsafe-return.js.map

package/dist/rules/no-unsafe-type-assertion.js

@@ -163,3 +163,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unsafe-type-assertion.js.map

package/dist/rules/no-unsafe-unary-minus.js

@@ -76,3 +76,4 @@ exports.default = util.createRule({
         };
     },
 });
+//# sourceMappingURL=no-unsafe-unary-minus.js.map

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

@@ -62,3 +62,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unused-expressions.js.map

package/dist/rules/no-unused-private-class-members.js

@@ -42,3 +42,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unused-private-class-members.js.map

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

@@ -1033,3 +1033,4 @@ interface Bar {} // this Bar should be unused
 export const Bar = 1;
 
 */
+//# sourceMappingURL=no-unused-vars.js.map

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

@@ -301,3 +301,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-use-before-define.js.map

package/dist/rules/no-useless-constructor.js

@@ -55,3 +55,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-useless-constructor.js.map

package/dist/rules/no-useless-default-assignment.js

@@ -322,3 +322,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-useless-default-assignment.js.map

package/dist/rules/no-useless-empty-export.js

@@ -68,3 +68,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-useless-empty-export.js.map

package/dist/rules/no-var-requires.js

@@ -81,3 +81,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-var-requires.js.map

package/dist/rules/no-wrapper-object-types.js

@@ -58,3 +58,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-wrapper-object-types.js.map

package/dist/rules/non-nullable-type-assertion-style.js

@@ -130,3 +130,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=non-nullable-type-assertion-style.js.map

package/dist/rules/only-throw-error.js

@@ -156,3 +156,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=only-throw-error.js.map

package/dist/rules/parameter-properties.js

@@ -162,3 +162,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=parameter-properties.js.map

package/dist/rules/prefer-as-const.js

@@ -70,3 +70,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-as-const.js.map

package/dist/rules/prefer-destructuring.js

@@ -214,3 +214,4 @@ function isArrayLiteralIntegerIndexAccess(node) {
     }
     return Number.isInteger(node.property.value);
 }
+//# sourceMappingURL=prefer-destructuring.js.map

package/dist/rules/prefer-enum-initializers.js

@@ -60,3 +60,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-enum-initializers.js.map

package/dist/rules/prefer-find.js

@@ -245,3 +245,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-find.js.map

package/dist/rules/prefer-for-of.js

@@ -113,3 +113,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-for-of.js.map

package/dist/rules/prefer-function-type.js

@@ -184,3 +184,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-function-type.js.map

package/dist/rules/prefer-includes.js

@@ -240,3 +240,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-includes.js.map

package/dist/rules/prefer-literal-enum-member.js

@@ -114,3 +114,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-literal-enum-member.js.map

package/dist/rules/prefer-namespace-keyword.js

@@ -40,3 +40,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-namespace-keyword.js.map

package/dist/rules/prefer-nullish-coalescing.js

@@ -615,3 +615,4 @@ function formatComments(comments, separator) {
         : `/*${value}*/${separator}`)
         .join('');
 }
+//# sourceMappingURL=prefer-nullish-coalescing.js.map

package/dist/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PreferOptionalChainOptions.js.map

package/dist/rules/prefer-optional-chain-utils/analyzeChain.js

@@ -612,3 +612,4 @@ function analyzeChain(context, parserServices, options, node, operator, chain, l
     // check the leftovers
     maybeReportThenReset();
 }
+//# sourceMappingURL=analyzeChain.js.map

package/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.js

@@ -43,3 +43,4 @@ function checkNullishAndReport(context, parserServices, { requireNullish }, mayb
         context.report(descriptor);
     }
 }
+//# sourceMappingURL=checkNullishAndReport.js.map

package/dist/rules/prefer-optional-chain-utils/compareNodes.js

@@ -324,3 +324,4 @@ function compareNodes(nodeA, nodeB) {
     mapA.set(nodeB, result);
     return result;
 }
+//# sourceMappingURL=compareNodes.js.map

package/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.js

@@ -409,3 +409,4 @@ function gatherLogicalOperands(node, parserServices, sourceCode, options) {
         return null;
     }
 }
+//# sourceMappingURL=gatherLogicalOperands.js.map

package/dist/rules/prefer-optional-chain.js

@@ -148,3 +148,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-optional-chain.js.map

package/dist/rules/prefer-promise-reject-errors.js

@@ -122,3 +122,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-promise-reject-errors.js.map

package/dist/rules/prefer-readonly-parameter-types.js

@@ -96,3 +96,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-readonly-parameter-types.js.map

package/dist/rules/prefer-readonly.js

@@ -437,3 +437,4 @@ function getMemberName(name) {
     }
     return undefined;
 }
+//# sourceMappingURL=prefer-readonly.js.map

package/dist/rules/prefer-reduce-type-parameter.js

@@ -112,3 +112,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-reduce-type-parameter.js.map

package/dist/rules/prefer-regexp-exec.js

@@ -180,3 +180,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-regexp-exec.js.map

package/dist/rules/prefer-return-this-type.js

@@ -152,3 +152,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-return-this-type.js.map

package/dist/rules/prefer-string-starts-ends-with.js

@@ -511,3 +511,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-string-starts-ends-with.js.map

package/dist/rules/prefer-ts-expect-error.js

@@ -69,3 +69,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=prefer-ts-expect-error.js.map

package/dist/rules/promise-function-async.js

@@ -202,3 +202,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=promise-function-async.js.map

package/dist/rules/related-getter-setter-pairs.js

@@ -69,3 +69,4 @@ exports.default = (0, util_1.createRule)({
 function getMethodFromNode(node) {
     return node.type === utils_1.AST_NODE_TYPES.TSMethodSignature ? node : node.value;
 }
+//# sourceMappingURL=related-getter-setter-pairs.js.map

package/dist/rules/require-array-sort-compare.js

@@ -61,3 +61,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=require-array-sort-compare.js.map

package/dist/rules/require-await.js

@@ -261,3 +261,4 @@ function hasTypeName(typeReference, typeName) {
     return (typeReference.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
         typeReference.typeName.name === typeName);
 }
+//# sourceMappingURL=require-await.js.map

package/dist/rules/restrict-plus-operands.js

@@ -229,3 +229,4 @@ function isTypeFlagSetInUnion(type, flag) {
         .unionConstituents(type)
         .some(subType => tsutils.isTypeFlagSet(subType, flag));
 }
+//# sourceMappingURL=restrict-plus-operands.js.map

package/dist/rules/restrict-template-expressions.js

@@ -117,3 +117,4 @@ exports.default = (0, util_1.createRule)({
         }
     },
 });
+//# sourceMappingURL=restrict-template-expressions.js.map

package/dist/rules/return-await.js

@@ -372,3 +372,4 @@ function getConfiguration(option) {
             };
     }
 }
+//# sourceMappingURL=return-await.js.map

package/dist/rules/sort-type-constituents.js

@@ -270,3 +270,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=sort-type-constituents.js.map

package/dist/rules/strict-boolean-expressions.js

@@ -880,3 +880,4 @@ function isBrandedBoolean(type) {
 function isBooleanType(expressionType) {
     return tsutils.isTypeFlagSet(expressionType, ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral);
 }
+//# sourceMappingURL=strict-boolean-expressions.js.map

package/dist/rules/strict-void-return.d.ts

@@ -1,10 +1,11 @@
+import type { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         allowReturnAny?: boolean;
     }
 ];
-type MessageId = `asyncFunc` | `nonVoidFunc` | `nonVoidReturn`;
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageId, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+type MessageId = `asyncFunc` | `nonVoidFunc` | `nonVoidReturn` | `suggestAddVoidOp` | `suggestWrapInAsyncIIFE`;
+declare const _default: TSESLint.RuleModule<MessageId, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
     name: string;
 };
 export default _default;

package/dist/rules/strict-void-return.js

@@ -45,10 +45,13 @@ exports.default = util.createRule({
             description: 'Disallow passing a value-returning function in a position accepting a void function',
             requiresTypeChecking: true,
         },
+        hasSuggestions: true,
         messages: {
             asyncFunc: 'Async function used in a context where a void function is expected.',
             nonVoidFunc: 'Value-returning function used in a context where a void function is expected.',
             nonVoidReturn: 'Value returned in a context where a void return is expected.',
+            suggestAddVoidOp: 'Add a void operator to discard the return value.',
+            suggestWrapInAsyncIIFE: 'Wrap the function body in an async IIFE.',
         },
         schema: [
             {
@@ -324,20 +327,55 @@ exports.default = util.createRule({
             }
             if (funcNode.async) {
                 // The provided function is an async function.
-                // Async functions aren't allowed.
+                if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                    // This async function is an arrow function shorthand without braces.
+                    return context.report({
+                        loc: util.getFunctionHeadLoc(funcNode, sourceCode),
+                        messageId: 'asyncFunc',
+                        suggest: utils_1.ASTUtils.hasSideEffect(funcNode.body, sourceCode)
+                            ? // This function has side effects, e.g. `async () => doSomething()`.
+                                // Suggest removing the async keyword and adding a void operator.
+                                [
+                                    {
+                                        messageId: 'suggestAddVoidOp',
+                                        fix: fixer => addVoidToArrowFix(fixer, funcNode),
+                                    },
+                                ]
+                            : [],
+                    });
+                }
+                // This async function has a block body.
+                // Suggest wrapping its body in an async IIFE.
                 return context.report({
                     loc: util.getFunctionHeadLoc(funcNode, sourceCode),
-                    messageId: `asyncFunc`,
+                    messageId: 'asyncFunc',
+                    suggest: [
+                        {
+                            messageId: 'suggestWrapInAsyncIIFE',
+                            fix: fixer => wrapInAsyncIIFEFix(fixer, funcNode),
+                        },
+                    ],
                 });
             }
+            // This function is a regular or arrow sync function.
             if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
-                // The provided function is an arrow function shorthand without braces.
+                // This function is an arrow function shorthand without braces.
                 return context.report({
                     node: funcNode.body,
-                    messageId: `nonVoidReturn`,
+                    messageId: 'nonVoidReturn',
+                    suggest: utils_1.ASTUtils.hasSideEffect(funcNode.body, sourceCode)
+                        ? // This function has side effects, e.g. `() => doSomething()`.
+                            // Suggest adding a void operator.
+                            [
+                                {
+                                    messageId: 'suggestAddVoidOp',
+                                    fix: fixer => addVoidToArrowFix(fixer, funcNode),
+                                },
+                            ]
+                        : [],
                 });
             }
-            // The function is a regular or arrow function with a block body.
+            // This function is a regular or arrow sync function with a block body.
             // Check return type annotation.
             if (funcNode.returnType != null) {
                 // The provided function has an explicit return type annotation.
@@ -373,5 +411,59 @@ exports.default = util.createRule({
             }
             // No invalid returns found. The function is allowed.
         }
+        /**
+         * Removes the async keyword and replaces the return type with void.
+         */
+        function* makeSyncFuncFix(fixer, funcNode) {
+            if (funcNode.async) {
+                // Remove async keyword
+                const funcHeadNode = funcNode.parent.type === utils_1.AST_NODE_TYPES.Property ||
+                    funcNode.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition
+                    ? funcNode.parent
+                    : funcNode;
+                const asyncToken = util.nullThrows(sourceCode.getFirstToken(funcHeadNode, {
+                    filter: token => token.value === 'async',
+                }), util.NullThrowsReasons.MissingToken('async keyword', funcNode.type));
+                yield fixer.remove(asyncToken);
+            }
+            // Replace return type with void
+            if (funcNode.returnType != null) {
+                yield fixer.replaceText(funcNode.returnType.typeAnnotation, 'void');
+            }
+        }
+        /**
+         * Makes the function sync and adds a void operator to the arrow shorthand body.
+         */
+        function* addVoidToArrowFix(fixer, funcNode) {
+            yield* makeSyncFuncFix(fixer, funcNode);
+            // Add void operator
+            yield util.getWrappingFixer({
+                node: funcNode.body,
+                sourceCode,
+                wrap: code => `void ${code}`,
+            })(fixer);
+        }
+        /**
+         * Makes the function sync and wraps the body in an inner async IIFE.
+         */
+        function* wrapInAsyncIIFEFix(fixer, funcNode) {
+            yield* makeSyncFuncFix(fixer, funcNode);
+            // Wrap body in async IIFE.
+            // This preserves the node kind (normal/arrow) for the _outer_ function
+            // and uses an arrow function for the _inner_ function,
+            // so that `this` will always refer to the same value as before.
+            if (funcNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                const arrowToken = util.nullThrows(sourceCode.getTokenBefore(funcNode.body, {
+                    filter: token => token.value === '=>',
+                }), util.NullThrowsReasons.MissingToken('arrow token', 'before arrow function body'));
+                yield fixer.insertTextAfter(arrowToken, ' void (async () =>');
+                yield fixer.insertTextAfter(funcNode, ')()');
+            }
+            else {
+                yield fixer.insertTextBefore(funcNode.body, '{ (async () => ');
+                yield fixer.insertTextAfter(funcNode.body, ')(); }');
+            }
+        }
     },
 });
+//# sourceMappingURL=strict-void-return.js.map

package/dist/rules/switch-exhaustiveness-check.js

@@ -289,3 +289,4 @@ function doesTypeContainNonLiteralType(type) {
         .intersectionConstituents(type)
         .every(subType => !isTypeLiteralLikeType(subType)));
 }
+//# sourceMappingURL=switch-exhaustiveness-check.js.map

package/dist/rules/triple-slash-reference.js

@@ -108,3 +108,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=triple-slash-reference.js.map

package/dist/rules/typedef.js

@@ -237,3 +237,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=typedef.js.map

package/dist/rules/unbound-method.js

@@ -359,3 +359,4 @@ function isSafeUse(node) {
     }
     return false;
 }
+//# sourceMappingURL=unbound-method.js.map

package/dist/rules/unified-signatures.d.ts

@@ -1,4 +1,4 @@
-export type MessageIds = 'omittingRestParameter' | 'omittingSingleParameter' | 'singleParameterDifference';
+export type MessageIds = 'allParametersAreSame' | 'omittingRestParameter' | 'omittingSingleParameter' | 'singleParameterDifference';
 export type Options = [
     {
         ignoreDifferentlyNamedParameters?: boolean;