@typescript-eslint/eslint-plugin 8.24.2-alpha.1 → 8.24.2-alpha.2

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

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

package/dist/rules/strict-boolean-expressions.d.ts

@@ -0,0 +1,17 @@
+export type Options = [
+    {
+        allowAny?: boolean;
+        allowNullableBoolean?: boolean;
+        allowNullableEnum?: boolean;
+        allowNullableNumber?: boolean;
+        allowNullableObject?: boolean;
+        allowNullableString?: boolean;
+        allowNumber?: boolean;
+        allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
+        allowString?: boolean;
+    }
+];
+export type MessageId = 'conditionErrorAny' | 'conditionErrorNullableBoolean' | 'conditionErrorNullableEnum' | 'conditionErrorNullableNumber' | 'conditionErrorNullableObject' | 'conditionErrorNullableString' | 'conditionErrorNullish' | 'conditionErrorNumber' | 'conditionErrorObject' | 'conditionErrorOther' | 'conditionErrorString' | 'conditionFixCastBoolean' | 'conditionFixCompareArrayLengthNonzero' | 'conditionFixCompareArrayLengthZero' | 'conditionFixCompareEmptyString' | 'conditionFixCompareFalse' | 'conditionFixCompareNaN' | 'conditionFixCompareNullish' | 'conditionFixCompareStringLength' | 'conditionFixCompareTrue' | 'conditionFixCompareZero' | 'conditionFixDefaultEmptyString' | 'conditionFixDefaultFalse' | 'conditionFixDefaultZero' | 'explicitBooleanReturnType' | 'noStrictNullCheck' | 'predicateCannotBeAsync' | 'predicateReturnsNonBoolean';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageId, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=strict-boolean-expressions.d.ts.map

package/dist/rules/strict-boolean-expressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict-boolean-expressions.d.ts","sourceRoot":"","sources":["../../src/rules/strict-boolean-expressions.ts"],"names":[],"mappings":"AAqBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,mBAAmB,GACnB,+BAA+B,GAC/B,4BAA4B,GAC5B,8BAA8B,GAC9B,8BAA8B,GAC9B,8BAA8B,GAC9B,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,GACtB,yBAAyB,GACzB,uCAAuC,GACvC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,wBAAwB,GACxB,4BAA4B,GAC5B,iCAAiC,GACjC,yBAAyB,GACzB,yBAAyB,GACzB,gCAAgC,GAChC,0BAA0B,GAC1B,yBAAyB,GACzB,2BAA2B,GAC3B,mBAAmB,GACnB,wBAAwB,GACxB,4BAA4B,CAAC;;AAEjC,wBAohCG"}

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

@@ -935,4 +935,3 @@ 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/switch-exhaustiveness-check.d.ts

@@ -0,0 +1,32 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type Options = [
+    {
+        /**
+         * If `true`, allow `default` cases on switch statements with exhaustive
+         * cases.
+         *
+         * @default true
+         */
+        allowDefaultCaseForExhaustiveSwitch?: boolean;
+        /**
+         * If `true`, require a `default` clause for switches on non-union types.
+         *
+         * @default false
+         */
+        requireDefaultForNonUnion?: boolean;
+        /**
+         * Regular expression for a comment that can indicate an intentionally omitted default case.
+         */
+        defaultCaseCommentPattern?: string;
+        /**
+         * If `true`, the `default` clause is used to determine whether the switch statement is exhaustive for union types.
+         *
+         * @default false
+         */
+        considerDefaultExhaustiveForUnions?: boolean;
+    }
+];
+export type MessageIds = 'addMissingCases' | 'dangerousDefaultCase' | 'switchIsNotExhaustive';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=switch-exhaustiveness-check.d.ts.map

package/dist/rules/switch-exhaustiveness-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch-exhaustiveness-check.d.ts","sourceRoot":"","sources":["../../src/rules/switch-exhaustiveness-check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAyBnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE;;;;;WAKG;QACH,mCAAmC,CAAC,EAAE,OAAO,CAAC;QAE9C;;;;WAIG;QACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;QAEpC;;WAEG;QACH,yBAAyB,CAAC,EAAE,MAAM,CAAC;QAEnC;;;;WAIG;QACH,kCAAkC,CAAC,EAAE,OAAO,CAAC;KAC9C;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,uBAAuB,CAAC;;AAE5B,wBA+VG"}

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

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

package/dist/rules/triple-slash-reference.d.ts

@@ -0,0 +1,11 @@
+export type Options = [
+    {
+        lib?: 'always' | 'never';
+        path?: 'always' | 'never';
+        types?: 'always' | 'never' | 'prefer-import';
+    }
+];
+export type MessageIds = 'tripleSlashReference';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"tripleSlashReference", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=triple-slash-reference.d.ts.map

package/dist/rules/triple-slash-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triple-slash-reference.d.ts","sourceRoot":"","sources":["../../src/rules/triple-slash-reference.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,GAAG,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;QACzB,IAAI,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;QAC1B,KAAK,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,eAAe,CAAC;KAC9C;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,sBAAsB,CAAC;;AAEhD,wBA0HG"}

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

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

package/dist/rules/typedef.d.ts

@@ -0,0 +1,15 @@
+export declare const enum OptionKeys {
+    ArrayDestructuring = "arrayDestructuring",
+    ArrowParameter = "arrowParameter",
+    MemberVariableDeclaration = "memberVariableDeclaration",
+    ObjectDestructuring = "objectDestructuring",
+    Parameter = "parameter",
+    PropertyDeclaration = "propertyDeclaration",
+    VariableDeclaration = "variableDeclaration",
+    VariableDeclarationIgnoreFunction = "variableDeclarationIgnoreFunction"
+}
+export type Options = [Partial<Record<OptionKeys, boolean>>];
+export type MessageIds = 'expectedTypedef' | 'expectedTypedefNamed';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=typedef.d.ts.map

package/dist/rules/typedef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedef.d.ts","sourceRoot":"","sources":["../../src/rules/typedef.ts"],"names":[],"mappings":"AAMA,0BAAkB,UAAU;IAC1B,kBAAkB,uBAAuB;IACzC,cAAc,mBAAmB;IACjC,yBAAyB,8BAA8B;IACvD,mBAAmB,wBAAwB;IAC3C,SAAS,cAAc;IACvB,mBAAmB,wBAAwB;IAC3C,mBAAmB,wBAAwB;IAC3C,iCAAiC,sCAAsC;CACxE;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;AAE7D,MAAM,MAAM,UAAU,GAAG,iBAAiB,GAAG,sBAAsB,CAAC;;AAEpE,wBAiSG"}

package/dist/rules/typedef.js

@@ -1,7 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionKeys = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const util_1 = require("../util");
+var OptionKeys;
+(function (OptionKeys) {
+    OptionKeys["ArrayDestructuring"] = "arrayDestructuring";
+    OptionKeys["ArrowParameter"] = "arrowParameter";
+    OptionKeys["MemberVariableDeclaration"] = "memberVariableDeclaration";
+    OptionKeys["ObjectDestructuring"] = "objectDestructuring";
+    OptionKeys["Parameter"] = "parameter";
+    OptionKeys["PropertyDeclaration"] = "propertyDeclaration";
+    OptionKeys["VariableDeclaration"] = "variableDeclaration";
+    OptionKeys["VariableDeclarationIgnoreFunction"] = "variableDeclarationIgnoreFunction";
+})(OptionKeys || (exports.OptionKeys = OptionKeys = {}));
 exports.default = (0, util_1.createRule)({
     name: 'typedef',
     meta: {
@@ -18,35 +30,35 @@ exports.default = (0, util_1.createRule)({
                 type: 'object',
                 additionalProperties: false,
                 properties: {
-                    ["arrayDestructuring" /* OptionKeys.ArrayDestructuring */]: {
+                    [OptionKeys.ArrayDestructuring]: {
                         type: 'boolean',
                         description: 'Whether to enforce type annotations on variables declared using array destructuring.',
                     },
-                    ["arrowParameter" /* OptionKeys.ArrowParameter */]: {
+                    [OptionKeys.ArrowParameter]: {
                         type: 'boolean',
                         description: 'Whether to enforce type annotations for parameters of arrow functions.',
                     },
-                    ["memberVariableDeclaration" /* OptionKeys.MemberVariableDeclaration */]: {
+                    [OptionKeys.MemberVariableDeclaration]: {
                         type: 'boolean',
                         description: 'Whether to enforce type annotations on member variables of classes.',
                     },
-                    ["objectDestructuring" /* OptionKeys.ObjectDestructuring */]: {
+                    [OptionKeys.ObjectDestructuring]: {
                         type: 'boolean',
                         description: 'Whether to enforce type annotations on variables declared using object destructuring.',
                     },
-                    ["parameter" /* OptionKeys.Parameter */]: {
+                    [OptionKeys.Parameter]: {
                         type: 'boolean',
                         description: 'Whether to enforce type annotations for parameters of functions and methods.',
                     },
-                    ["propertyDeclaration" /* OptionKeys.PropertyDeclaration */]: {
+                    [OptionKeys.PropertyDeclaration]: {
                         type: 'boolean',
                         description: 'Whether to enforce type annotations for properties of interfaces and types.',
                     },
-                    ["variableDeclaration" /* OptionKeys.VariableDeclaration */]: {
+                    [OptionKeys.VariableDeclaration]: {
                         type: 'boolean',
                         description: 'Whether to enforce type annotations for variable declarations, excluding array and object destructuring.',
                     },
-                    ["variableDeclarationIgnoreFunction" /* OptionKeys.VariableDeclarationIgnoreFunction */]: {
+                    [OptionKeys.VariableDeclarationIgnoreFunction]: {
                         type: 'boolean',
                         description: 'Whether to ignore variable declarations for non-arrow and arrow functions.',
                     },
@@ -56,14 +68,14 @@ exports.default = (0, util_1.createRule)({
     },
     defaultOptions: [
         {
-            ["arrayDestructuring" /* OptionKeys.ArrayDestructuring */]: false,
-            ["arrowParameter" /* OptionKeys.ArrowParameter */]: false,
-            ["memberVariableDeclaration" /* OptionKeys.MemberVariableDeclaration */]: false,
-            ["objectDestructuring" /* OptionKeys.ObjectDestructuring */]: false,
-            ["parameter" /* OptionKeys.Parameter */]: false,
-            ["propertyDeclaration" /* OptionKeys.PropertyDeclaration */]: false,
-            ["variableDeclaration" /* OptionKeys.VariableDeclaration */]: false,
-            ["variableDeclarationIgnoreFunction" /* OptionKeys.VariableDeclarationIgnoreFunction */]: false,
+            [OptionKeys.ArrayDestructuring]: false,
+            [OptionKeys.ArrowParameter]: false,
+            [OptionKeys.MemberVariableDeclaration]: false,
+            [OptionKeys.ObjectDestructuring]: false,
+            [OptionKeys.Parameter]: false,
+            [OptionKeys.PropertyDeclaration]: false,
+            [OptionKeys.VariableDeclaration]: false,
+            [OptionKeys.VariableDeclarationIgnoreFunction]: false,
         },
     ],
     create(context, [{ arrayDestructuring, arrowParameter, memberVariableDeclaration, objectDestructuring, parameter, propertyDeclaration, variableDeclaration, variableDeclarationIgnoreFunction, },]) {
@@ -221,4 +233,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=typedef.js.map

package/dist/rules/unbound-method.d.ts

@@ -0,0 +1,8 @@
+interface Config {
+    ignoreStatic: boolean;
+}
+export type Options = [Config];
+export type MessageIds = 'unbound' | 'unboundWithoutThisAnnotation';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=unbound-method.d.ts.map

package/dist/rules/unbound-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbound-method.d.ts","sourceRoot":"","sources":["../../src/rules/unbound-method.ts"],"names":[],"mappings":"AAkBA,UAAU,MAAM;IACd,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,8BAA8B,CAAC;;AAiFpE,wBA0KG"}

package/dist/rules/unbound-method.js

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

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

@@ -0,0 +1,9 @@
+export type MessageIds = 'omittingRestParameter' | 'omittingSingleParameter' | 'singleParameterDifference';
+export type Options = [
+    {
+        ignoreDifferentlyNamedParameters?: boolean;
+    }
+];
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=unified-signatures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unified-signatures.d.ts","sourceRoot":"","sources":["../../src/rules/unified-signatures.ts"],"names":[],"mappings":"AAuDA,MAAM,MAAM,UAAU,GAClB,uBAAuB,GACvB,yBAAyB,GACzB,2BAA2B,CAAC;AAEhC,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,gCAAgC,CAAC,EAAE,OAAO,CAAC;KAC5C;CACF,CAAC;;AAEF,wBAugBG"}

package/dist/rules/unified-signatures.js

@@ -396,4 +396,3 @@ function getStaticParameterName(param) {
 function isIdentifier(node) {
     return node.type === utils_1.AST_NODE_TYPES.Identifier;
 }
-//# sourceMappingURL=unified-signatures.js.map

package/dist/rules/use-unknown-in-catch-callback-variable.d.ts

@@ -0,0 +1,5 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type MessageIds = 'addUnknownRestTypeAnnotationSuggestion' | 'addUnknownTypeAnnotationSuggestion' | 'useUnknown' | 'useUnknownArrayDestructuringPattern' | 'useUnknownObjectDestructuringPattern' | 'wrongRestTypeAnnotationSuggestion' | 'wrongTypeAnnotationSuggestion';
+declare const _default: TSESLint.RuleModule<MessageIds, [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=use-unknown-in-catch-callback-variable.d.ts.map

package/dist/rules/use-unknown-in-catch-callback-variable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-unknown-in-catch-callback-variable.d.ts","sourceRoot":"","sources":["../../src/rules/use-unknown-in-catch-callback-variable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAgBnE,MAAM,MAAM,UAAU,GAClB,wCAAwC,GACxC,oCAAoC,GACpC,YAAY,GACZ,qCAAqC,GACrC,sCAAsC,GACtC,mCAAmC,GACnC,+BAA+B,CAAC;;AAKpC,wBAmSG"}

package/dist/rules/use-unknown-in-catch-callback-variable.js

@@ -260,4 +260,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=use-unknown-in-catch-callback-variable.js.map

package/dist/util/assertionFunctionUtils.d.ts

@@ -0,0 +1,17 @@
+import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+/**
+ * Inspect a call expression to see if it's a call to an assertion function.
+ * If it is, return the node of the argument that is asserted.
+ */
+export declare function findTruthinessAssertedArgument(services: ParserServicesWithTypeInformation, node: TSESTree.CallExpression): TSESTree.Expression | undefined;
+/**
+ * Inspect a call expression to see if it's a call to an assertion function.
+ * If it is, return the node of the argument that is asserted and other useful info.
+ */
+export declare function findTypeGuardAssertedArgument(services: ParserServicesWithTypeInformation, node: TSESTree.CallExpression): {
+    argument: TSESTree.Expression;
+    asserts: boolean;
+    type: ts.Type;
+} | undefined;
+//# sourceMappingURL=assertionFunctionUtils.d.ts.map

package/dist/util/assertionFunctionUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertionFunctionUtils.d.ts","sourceRoot":"","sources":["../../src/util/assertionFunctionUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EACjC,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,iCAAiC,EAC3C,IAAI,EAAE,QAAQ,CAAC,cAAc,GAC5B,QAAQ,CAAC,UAAU,GAAG,SAAS,CAsCjC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,iCAAiC,EAC3C,IAAI,EAAE,QAAQ,CAAC,cAAc,GAE3B;IACE,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;CACf,GACD,SAAS,CAmDZ"}

package/dist/util/assertionFunctionUtils.js

@@ -116,4 +116,3 @@ function findTypeGuardAssertedArgument(services, node) {
         type,
     };
 }
-//# sourceMappingURL=assertionFunctionUtils.js.map

package/dist/util/astUtils.d.ts

@@ -0,0 +1,13 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+export * from '@typescript-eslint/utils/ast-utils';
+/**
+ * Get the `loc` object of a given name in a `/*globals` directive comment.
+ * @param sourceCode The source code to convert index to loc.
+ * @param comment The `/*globals` directive comment which include the name.
+ * @param name The name to find.
+ * @returns The `loc` object.
+ */
+export declare function getNameLocationInGlobalDirectiveComment(sourceCode: TSESLint.SourceCode, comment: TSESTree.Comment, name: string): TSESTree.SourceLocation;
+export declare function forEachReturnStatement<T>(body: ts.Block, visitor: (stmt: ts.ReturnStatement) => T): T | undefined;
+//# sourceMappingURL=astUtils.d.ts.map

package/dist/util/astUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astUtils.d.ts","sourceRoot":"","sources":["../../src/util/astUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAKjC,cAAc,oCAAoC,CAAC;AAKnD;;;;;;GAMG;AACH,wBAAgB,uCAAuC,CACrD,UAAU,EAAE,QAAQ,CAAC,UAAU,EAC/B,OAAO,EAAE,QAAQ,CAAC,OAAO,EACzB,IAAI,EAAE,MAAM,GACX,QAAQ,CAAC,cAAc,CAsBzB;AAKD,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,IAAI,EAAE,EAAE,CAAC,KAAK,EACd,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,eAAe,KAAK,CAAC,GACvC,CAAC,GAAG,SAAS,CA2Bf"}

package/dist/util/astUtils.js

@@ -95,4 +95,3 @@ function forEachReturnStatement(body, visitor) {
         return undefined;
     }
 }
-//# sourceMappingURL=astUtils.js.map

package/dist/util/collectUnusedVariables.d.ts

@@ -0,0 +1,16 @@
+import type { ScopeVariable } from '@typescript-eslint/scope-manager';
+import { TSESLint } from '@typescript-eslint/utils';
+interface VariableAnalysis {
+    readonly unusedVariables: ReadonlySet<ScopeVariable>;
+    readonly usedVariables: ReadonlySet<ScopeVariable>;
+}
+/**
+ * Collects the set of unused variables for a given context.
+ *
+ * Due to complexity, this does not take into consideration:
+ * - variables within declaration files
+ * - variables within ambient module declarations
+ */
+export declare function collectVariables<MessageIds extends string, Options extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<MessageIds, Options>>): VariableAnalysis;
+export {};
+//# sourceMappingURL=collectUnusedVariables.d.ts.map

package/dist/util/collectUnusedVariables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectUnusedVariables.d.ts","sourceRoot":"","sources":["../../src/util/collectUnusedVariables.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,aAAa,EACd,MAAM,kCAAkC,CAAC;AAQ1C,OAAO,EAIL,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAKlC,UAAU,gBAAgB;IACxB,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC;IACrD,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC;CACpD;AAqxBD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,SAAS,MAAM,EACzB,OAAO,SAAS,SAAS,OAAO,EAAE,EAElC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,GAC3D,gBAAgB,CAQlB"}

package/dist/util/collectUnusedVariables.js

@@ -602,4 +602,3 @@ function isUsedVariable(variable) {
 function collectVariables(context) {
     return UnusedVarsVisitor.collectUnusedVariables(context.sourceCode.ast, utils_1.ESLintUtils.nullThrows(context.sourceCode.scopeManager, 'Missing required scope manager'));
 }
-//# sourceMappingURL=collectUnusedVariables.js.map

package/dist/util/createRule.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import type { ESLintPluginDocs } from '../../rules';
+export declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, ESLintPluginDocs>>) => ESLintUtils.RuleModule<MessageIds, Options, ESLintPluginDocs, ESLintUtils.RuleListener>;
+//# sourceMappingURL=createRule.d.ts.map

package/dist/util/createRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRule.d.ts","sourceRoot":"","sources":["../../src/util/createRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,eAAO,MAAM,UAAU,uQAEtB,CAAC"}

package/dist/util/createRule.js

@@ -3,4 +3,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRule = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 exports.createRule = utils_1.ESLintUtils.RuleCreator(name => `https://typescript-eslint.io/rules/${name}`);
-//# sourceMappingURL=createRule.js.map

package/dist/util/escapeRegExp.d.ts

@@ -0,0 +1,2 @@
+export declare function escapeRegExp(string?: string): string;
+//# sourceMappingURL=escapeRegExp.d.ts.map

package/dist/util/escapeRegExp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escapeRegExp.d.ts","sourceRoot":"","sources":["../../src/util/escapeRegExp.ts"],"names":[],"mappings":"AAOA,wBAAgB,YAAY,CAAC,MAAM,SAAK,GAAG,MAAM,CAIhD"}

package/dist/util/escapeRegExp.js

@@ -12,4 +12,3 @@ function escapeRegExp(string = '') {
         ? string.replaceAll(reRegExpChar, '\\$&')
         : string;
 }
-//# sourceMappingURL=escapeRegExp.js.map

package/dist/util/explicitReturnTypeUtils.d.ts

@@ -0,0 +1,48 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+export type FunctionExpression = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;
+export type FunctionNode = FunctionExpression | TSESTree.FunctionDeclaration;
+export interface FunctionInfo<T extends FunctionNode> {
+    node: T;
+    returns: TSESTree.ReturnStatement[];
+}
+/**
+ * Checks if a function belongs to:
+ * ```
+ * () => () => ...
+ * () => function () { ... }
+ * () => { return () => ... }
+ * () => { return function () { ... } }
+ * function fn() { return () => ... }
+ * function fn() { return function() { ... } }
+ * ```
+ */
+export declare function doesImmediatelyReturnFunctionExpression({ node, returns, }: FunctionInfo<FunctionNode>): boolean;
+interface Options {
+    allowDirectConstAssertionInArrowFunctions?: boolean;
+    allowExpressions?: boolean;
+    allowHigherOrderFunctions?: boolean;
+    allowTypedFunctionExpressions?: boolean;
+}
+/**
+ * True when the provided function expression is typed.
+ */
+export declare function isTypedFunctionExpression(node: FunctionExpression, options: Options): boolean;
+/**
+ * Check whether the function expression return type is either typed or valid
+ * with the provided options.
+ */
+export declare function isValidFunctionExpressionReturnType(node: FunctionExpression, options: Options): boolean;
+/**
+ * Checks if a function declaration/expression has a return type.
+ */
+export declare function checkFunctionReturnType({ node, returns }: FunctionInfo<FunctionNode>, options: Options, sourceCode: TSESLint.SourceCode, report: (loc: TSESTree.SourceLocation) => void): void;
+/**
+ * Checks if a function declaration/expression has a return type.
+ */
+export declare function checkFunctionExpressionReturnType(info: FunctionInfo<FunctionExpression>, options: Options, sourceCode: TSESLint.SourceCode, report: (loc: TSESTree.SourceLocation) => void): void;
+/**
+ * Check whether any ancestor of the provided function has a valid return type.
+ */
+export declare function ancestorHasReturnType(node: FunctionNode): boolean;
+export {};
+//# sourceMappingURL=explicitReturnTypeUtils.d.ts.map

package/dist/util/explicitReturnTypeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicitReturnTypeUtils.d.ts","sourceRoot":"","sources":["../../src/util/explicitReturnTypeUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAWnE,MAAM,MAAM,kBAAkB,GAC1B,QAAQ,CAAC,uBAAuB,GAChC,QAAQ,CAAC,kBAAkB,CAAC;AAChC,MAAM,MAAM,YAAY,GAAG,kBAAkB,GAAG,QAAQ,CAAC,mBAAmB,CAAC;AAE7E,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,YAAY;IAClD,IAAI,EAAE,CAAC,CAAC;IACR,OAAO,EAAE,QAAQ,CAAC,eAAe,EAAE,CAAC;CACrC;AA6HD;;;;;;;;;;GAUG;AACH,wBAAgB,uCAAuC,CAAC,EACtD,IAAI,EACJ,OAAO,GACR,EAAE,YAAY,CAAC,YAAY,CAAC,GAAG,OAAO,CAetC;AAyBD,UAAU,OAAO;IACf,yCAAyC,CAAC,EAAE,OAAO,CAAC;IACpD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,6BAA6B,CAAC,EAAE,OAAO,CAAC;CACzC;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,OAAO,GACf,OAAO,CAeT;AAED;;;GAGG;AACH,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,OAAO,GACf,OAAO,CAiCT;AAuBD;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,YAAY,CAAC,YAAY,CAAC,EAC7C,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,QAAQ,CAAC,UAAU,EAC/B,MAAM,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,cAAc,KAAK,IAAI,GAC7C,IAAI,CAMN;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,YAAY,CAAC,kBAAkB,CAAC,EACtC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,QAAQ,CAAC,UAAU,EAC/B,MAAM,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,cAAc,KAAK,IAAI,GAC7C,IAAI,CAMN;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAyCjE"}

package/dist/util/explicitReturnTypeUtils.js

@@ -238,4 +238,3 @@ function ancestorHasReturnType(node) {
     }
     return false;
 }
-//# sourceMappingURL=explicitReturnTypeUtils.js.map

package/dist/util/getConstraintInfo.d.ts

@@ -0,0 +1,36 @@
+import type * as ts from 'typescript';
+export interface ConstraintTypeInfoUnconstrained {
+    constraintType: undefined;
+    isTypeParameter: true;
+}
+export interface ConstraintTypeInfoConstrained {
+    constraintType: ts.Type;
+    isTypeParameter: true;
+}
+export interface ConstraintTypeInfoNonGeneric {
+    constraintType: ts.Type;
+    isTypeParameter: false;
+}
+export type ConstraintTypeInfo = ConstraintTypeInfoConstrained | ConstraintTypeInfoNonGeneric | ConstraintTypeInfoUnconstrained;
+/**
+ * Returns whether the type is a generic and what its constraint is.
+ *
+ * If the type is not a generic, `isTypeParameter` will be `false`, and
+ * `constraintType` will be the same as the input type.
+ *
+ * If the type is a generic, and it is constrained, `isTypeParameter` will be
+ * `true`, and `constraintType` will be the constraint type.
+ *
+ * If the type is a generic, but it is not constrained, `constraintType` will be
+ * `undefined` (rather than an `unknown` type), due to https://github.com/microsoft/TypeScript/issues/60475
+ *
+ * Successor to {@link getConstrainedTypeAtLocation} due to https://github.com/typescript-eslint/typescript-eslint/issues/10438
+ *
+ * This is considered internal since it is unstable for now and may have breaking changes at any time.
+ * Use at your own risk.
+ *
+ * @internal
+ *
+ */
+export declare function getConstraintInfo(checker: ts.TypeChecker, type: ts.Type): ConstraintTypeInfo;
+//# sourceMappingURL=getConstraintInfo.d.ts.map

package/dist/util/getConstraintInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getConstraintInfo.d.ts","sourceRoot":"","sources":["../../src/util/getConstraintInfo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAItC,MAAM,WAAW,+BAA+B;IAC9C,cAAc,EAAE,SAAS,CAAC;IAC1B,eAAe,EAAE,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,6BAA6B;IAC5C,cAAc,EAAE,EAAE,CAAC,IAAI,CAAC;IACxB,eAAe,EAAE,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,4BAA4B;IAC3C,cAAc,EAAE,EAAE,CAAC,IAAI,CAAC;IACxB,eAAe,EAAE,KAAK,CAAC;CACxB;AAED,MAAM,MAAM,kBAAkB,GAC1B,6BAA6B,GAC7B,4BAA4B,GAC5B,+BAA+B,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,EAAE,EAAE,CAAC,IAAI,GACZ,kBAAkB,CAYpB"}

package/dist/util/getConstraintInfo.js

@@ -68,4 +68,3 @@ function getConstraintInfo(checker, type) {
         isTypeParameter: false,
     };
 }
-//# sourceMappingURL=getConstraintInfo.js.map

package/dist/util/getESLintCoreRule.d.ts

@@ -0,0 +1,28 @@
+interface RuleMap {
+    'arrow-parens': typeof import('eslint/lib/rules/arrow-parens');
+    'consistent-return': typeof import('eslint/lib/rules/consistent-return');
+    'dot-notation': typeof import('eslint/lib/rules/dot-notation');
+    'init-declarations': typeof import('eslint/lib/rules/init-declarations');
+    'max-params': typeof import('eslint/lib/rules/max-params');
+    'no-dupe-args': typeof import('eslint/lib/rules/no-dupe-args');
+    'no-dupe-class-members': typeof import('eslint/lib/rules/no-dupe-class-members');
+    'no-empty-function': typeof import('eslint/lib/rules/no-empty-function');
+    'no-implicit-globals': typeof import('eslint/lib/rules/no-implicit-globals');
+    'no-invalid-this': typeof import('eslint/lib/rules/no-invalid-this');
+    'no-loop-func': typeof import('eslint/lib/rules/no-loop-func');
+    'no-loss-of-precision': typeof import('eslint/lib/rules/no-loss-of-precision');
+    'no-magic-numbers': typeof import('eslint/lib/rules/no-magic-numbers');
+    'no-restricted-globals': typeof import('eslint/lib/rules/no-restricted-globals');
+    'no-restricted-imports': typeof import('eslint/lib/rules/no-restricted-imports');
+    'no-undef': typeof import('eslint/lib/rules/no-undef');
+    'no-unused-expressions': typeof import('eslint/lib/rules/no-unused-expressions');
+    'no-useless-constructor': typeof import('eslint/lib/rules/no-useless-constructor');
+    'prefer-const': typeof import('eslint/lib/rules/prefer-const');
+    'prefer-destructuring': typeof import('eslint/lib/rules/prefer-destructuring');
+    strict: typeof import('eslint/lib/rules/strict');
+}
+type RuleId = keyof RuleMap;
+export declare const getESLintCoreRule: <R extends RuleId>(ruleId: R) => RuleMap[R];
+export declare function maybeGetESLintCoreRule<R extends RuleId>(ruleId: R): RuleMap[R] | null;
+export {};
+//# sourceMappingURL=getESLintCoreRule.d.ts.map

package/dist/util/getESLintCoreRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getESLintCoreRule.d.ts","sourceRoot":"","sources":["../../src/util/getESLintCoreRule.ts"],"names":[],"mappings":"AAGA,UAAU,OAAO;IAEf,cAAc,EAAE,cAAc,+BAA+B,CAAC,CAAC;IAC/D,mBAAmB,EAAE,cAAc,oCAAoC,CAAC,CAAC;IACzE,cAAc,EAAE,cAAc,+BAA+B,CAAC,CAAC;IAC/D,mBAAmB,EAAE,cAAc,oCAAoC,CAAC,CAAC;IACzE,YAAY,EAAE,cAAc,6BAA6B,CAAC,CAAC;IAC3D,cAAc,EAAE,cAAc,+BAA+B,CAAC,CAAC;IAC/D,uBAAuB,EAAE,cAAc,wCAAwC,CAAC,CAAC;IACjF,mBAAmB,EAAE,cAAc,oCAAoC,CAAC,CAAC;IACzE,qBAAqB,EAAE,cAAc,sCAAsC,CAAC,CAAC;IAC7E,iBAAiB,EAAE,cAAc,kCAAkC,CAAC,CAAC;IACrE,cAAc,EAAE,cAAc,+BAA+B,CAAC,CAAC;IAC/D,sBAAsB,EAAE,cAAc,uCAAuC,CAAC,CAAC;IAC/E,kBAAkB,EAAE,cAAc,mCAAmC,CAAC,CAAC;IACvE,uBAAuB,EAAE,cAAc,wCAAwC,CAAC,CAAC;IACjF,uBAAuB,EAAE,cAAc,wCAAwC,CAAC,CAAC;IACjF,UAAU,EAAE,cAAc,2BAA2B,CAAC,CAAC;IACvD,uBAAuB,EAAE,cAAc,wCAAwC,CAAC,CAAC;IACjF,wBAAwB,EAAE,cAAc,yCAAyC,CAAC,CAAC;IACnF,cAAc,EAAE,cAAc,+BAA+B,CAAC,CAAC;IAC/D,sBAAsB,EAAE,cAAc,uCAAuC,CAAC,CAAC;IAC/E,MAAM,EAAE,cAAc,yBAAyB,CAAC,CAAC;CAElD;AAED,KAAK,MAAM,GAAG,MAAM,OAAO,CAAC;AAE5B,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,MAAM,UAAU,CAAC,KAAG,OAAO,CAAC,CAAC,CAItE,CAAC;AAEJ,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,EACrD,MAAM,EAAE,CAAC,GACR,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAMnB"}

package/dist/util/getESLintCoreRule.js

@@ -14,4 +14,3 @@ function maybeGetESLintCoreRule(ruleId) {
         return null;
     }
 }
-//# sourceMappingURL=getESLintCoreRule.js.map

package/dist/util/getFixOrSuggest.d.ts

@@ -0,0 +1,10 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export declare function getFixOrSuggest<MessageId extends string>({ fixOrSuggest, suggestion, }: {
+    fixOrSuggest: 'fix' | 'none' | 'suggest';
+    suggestion: TSESLint.SuggestionReportDescriptor<MessageId>;
+}): {
+    fix: TSESLint.ReportFixFunction;
+} | {
+    suggest: TSESLint.SuggestionReportDescriptor<MessageId>[];
+} | undefined;
+//# sourceMappingURL=getFixOrSuggest.d.ts.map

package/dist/util/getFixOrSuggest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFixOrSuggest.d.ts","sourceRoot":"","sources":["../../src/util/getFixOrSuggest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD,wBAAgB,eAAe,CAAC,SAAS,SAAS,MAAM,EAAE,EACxD,YAAY,EACZ,UAAU,GACX,EAAE;IACD,YAAY,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CAAC;IACzC,UAAU,EAAE,QAAQ,CAAC,0BAA0B,CAAC,SAAS,CAAC,CAAC;CAC5D,GACG;IAAE,GAAG,EAAE,QAAQ,CAAC,iBAAiB,CAAA;CAAE,GACnC;IAAE,OAAO,EAAE,QAAQ,CAAC,0BAA0B,CAAC,SAAS,CAAC,EAAE,CAAA;CAAE,GAC7D,SAAS,CASZ"}

package/dist/util/getFixOrSuggest.js

@@ -11,4 +11,3 @@ function getFixOrSuggest({ fixOrSuggest, suggestion, }) {
             return { suggest: [suggestion] };
     }
 }
-//# sourceMappingURL=getFixOrSuggest.js.map

package/dist/util/getForStatementHeadLoc.d.ts

@@ -0,0 +1,18 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+/**
+ * Gets the location of the head of the given for statement variant for reporting.
+ *
+ * - `for (const foo in bar) expressionOrBlock`
+ *    ^^^^^^^^^^^^^^^^^^^^^^
+ *
+ * - `for (const foo of bar) expressionOrBlock`
+ *    ^^^^^^^^^^^^^^^^^^^^^^
+ *
+ * - `for await (const foo of bar) expressionOrBlock`
+ *    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ *
+ * - `for (let i = 0; i < 10; i++) expressionOrBlock`
+ *    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ */
+export declare function getForStatementHeadLoc(sourceCode: TSESLint.SourceCode, node: TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement): TSESTree.SourceLocation;
+//# sourceMappingURL=getForStatementHeadLoc.d.ts.map

package/dist/util/getForStatementHeadLoc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getForStatementHeadLoc.d.ts","sourceRoot":"","sources":["../../src/util/getForStatementHeadLoc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAInE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,QAAQ,CAAC,UAAU,EAC/B,IAAI,EACA,QAAQ,CAAC,cAAc,GACvB,QAAQ,CAAC,cAAc,GACvB,QAAQ,CAAC,YAAY,GACxB,QAAQ,CAAC,cAAc,CASzB"}

package/dist/util/getForStatementHeadLoc.js

@@ -24,4 +24,3 @@ function getForStatementHeadLoc(sourceCode, node) {
         start: structuredClone(node.loc.start),
     };
 }
-//# sourceMappingURL=getForStatementHeadLoc.js.map