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

package/dist/util/getFunctionHeadLoc.d.ts

@@ -0,0 +1,102 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+type FunctionNode = TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression;
+/**
+ * Gets the location of the given function node for reporting.
+ *
+ * - `function foo() {}`
+ *    ^^^^^^^^^^^^
+ * - `(function foo() {})`
+ *     ^^^^^^^^^^^^
+ * - `(function() {})`
+ *     ^^^^^^^^
+ * - `function* foo() {}`
+ *    ^^^^^^^^^^^^^
+ * - `(function* foo() {})`
+ *     ^^^^^^^^^^^^^
+ * - `(function*() {})`
+ *     ^^^^^^^^^
+ * - `() => {}`
+ *       ^^
+ * - `async () => {}`
+ *             ^^
+ * - `({ foo: function foo() {} })`
+ *       ^^^^^^^^^^^^^^^^^
+ * - `({ foo: function() {} })`
+ *       ^^^^^^^^^^^^^
+ * - `({ ['foo']: function() {} })`
+ *       ^^^^^^^^^^^^^^^^^
+ * - `({ [foo]: function() {} })`
+ *       ^^^^^^^^^^^^^^^
+ * - `({ foo() {} })`
+ *       ^^^
+ * - `({ foo: function* foo() {} })`
+ *       ^^^^^^^^^^^^^^^^^^
+ * - `({ foo: function*() {} })`
+ *       ^^^^^^^^^^^^^^
+ * - `({ ['foo']: function*() {} })`
+ *       ^^^^^^^^^^^^^^^^^^
+ * - `({ [foo]: function*() {} })`
+ *       ^^^^^^^^^^^^^^^^
+ * - `({ *foo() {} })`
+ *       ^^^^
+ * - `({ foo: async function foo() {} })`
+ *       ^^^^^^^^^^^^^^^^^^^^^^^
+ * - `({ foo: async function() {} })`
+ *       ^^^^^^^^^^^^^^^^^^^
+ * - `({ ['foo']: async function() {} })`
+ *       ^^^^^^^^^^^^^^^^^^^^^^^
+ * - `({ [foo]: async function() {} })`
+ *       ^^^^^^^^^^^^^^^^^^^^^
+ * - `({ async foo() {} })`
+ *       ^^^^^^^^^
+ * - `({ get foo() {} })`
+ *       ^^^^^^^
+ * - `({ set foo(a) {} })`
+ *       ^^^^^^^
+ * - `class A { constructor() {} }`
+ *              ^^^^^^^^^^^
+ * - `class A { foo() {} }`
+ *              ^^^
+ * - `class A { *foo() {} }`
+ *              ^^^^
+ * - `class A { async foo() {} }`
+ *              ^^^^^^^^^
+ * - `class A { ['foo']() {} }`
+ *              ^^^^^^^
+ * - `class A { *['foo']() {} }`
+ *              ^^^^^^^^
+ * - `class A { async ['foo']() {} }`
+ *              ^^^^^^^^^^^^^
+ * - `class A { [foo]() {} }`
+ *              ^^^^^
+ * - `class A { *[foo]() {} }`
+ *              ^^^^^^
+ * - `class A { async [foo]() {} }`
+ *              ^^^^^^^^^^^
+ * - `class A { get foo() {} }`
+ *              ^^^^^^^
+ * - `class A { set foo(a) {} }`
+ *              ^^^^^^^
+ * - `class A { static foo() {} }`
+ *              ^^^^^^^^^^
+ * - `class A { static *foo() {} }`
+ *              ^^^^^^^^^^^
+ * - `class A { static async foo() {} }`
+ *              ^^^^^^^^^^^^^^^^
+ * - `class A { static get foo() {} }`
+ *              ^^^^^^^^^^^^^^
+ * - `class A { static set foo(a) {} }`
+ *              ^^^^^^^^^^^^^^
+ * - `class A { foo = function() {} }`
+ *              ^^^^^^^^^^^^^^
+ * - `class A { static foo = function() {} }`
+ *              ^^^^^^^^^^^^^^^^^^^^^
+ * - `class A { foo = (a, b) => {} }`
+ *              ^^^^^^
+ * @param node The function node to get.
+ * @param sourceCode The source code object to get tokens.
+ * @returns The location of the function node for reporting.
+ */
+export declare function getFunctionHeadLoc(node: FunctionNode, sourceCode: TSESLint.SourceCode): TSESTree.SourceLocation;
+export {};
+//# sourceMappingURL=getFunctionHeadLoc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getFunctionHeadLoc.d.ts","sourceRoot":"","sources":["../../src/util/getFunctionHeadLoc.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAMnE,KAAK,YAAY,GACb,QAAQ,CAAC,uBAAuB,GAChC,QAAQ,CAAC,mBAAmB,GAC5B,QAAQ,CAAC,kBAAkB,CAAC;AA2ChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,YAAY,EAClB,UAAU,EAAE,QAAQ,CAAC,UAAU,GAC9B,QAAQ,CAAC,cAAc,CAiDzB"}

package/dist/util/getFunctionHeadLoc.js

@@ -159,4 +159,3 @@ function getFunctionHeadLoc(node, sourceCode) {
         start: { ...start },
     };
 }
-//# sourceMappingURL=getFunctionHeadLoc.js.map

package/dist/util/getMemberHeadLoc.d.ts

@@ -0,0 +1,37 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+/**
+ * Generates report loc suitable for reporting on how a class member is
+ * declared, rather than how it's implemented.
+ *
+ * ```ts
+ * class A {
+ *   abstract method(): void;
+ *   ~~~~~~~~~~~~~~~
+ *
+ *   concreteMethod(): void {
+ *   ~~~~~~~~~~~~~~
+ *      // code
+ *   }
+ *
+ *   abstract private property?: string;
+ *   ~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *   @decorator override concreteProperty = 'value';
+ *              ~~~~~~~~~~~~~~~~~~~~~~~~~
+ * }
+ * ```
+ */
+export declare function getMemberHeadLoc(sourceCode: Readonly<TSESLint.SourceCode>, node: TSESTree.AccessorProperty | TSESTree.MethodDefinition | TSESTree.PropertyDefinition | TSESTree.TSAbstractAccessorProperty | TSESTree.TSAbstractMethodDefinition | TSESTree.TSAbstractPropertyDefinition): TSESTree.SourceLocation;
+/**
+ * Generates report loc suitable for reporting on how a parameter property is
+ * declared.
+ *
+ * ```ts
+ * class A {
+ *   constructor(private property: string = 'value') {
+ *               ~~~~~~~~~~~~~~~~
+ *   }
+ * ```
+ */
+export declare function getParameterPropertyHeadLoc(sourceCode: Readonly<TSESLint.SourceCode>, node: TSESTree.TSParameterProperty, nodeName: string): TSESTree.SourceLocation;
+//# sourceMappingURL=getMemberHeadLoc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getMemberHeadLoc.d.ts","sourceRoot":"","sources":["../../src/util/getMemberHeadLoc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAOnE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,EACzC,IAAI,EACA,QAAQ,CAAC,gBAAgB,GACzB,QAAQ,CAAC,gBAAgB,GACzB,QAAQ,CAAC,kBAAkB,GAC3B,QAAQ,CAAC,0BAA0B,GACnC,QAAQ,CAAC,0BAA0B,GACnC,QAAQ,CAAC,4BAA4B,GACxC,QAAQ,CAAC,cAAc,CA8BzB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,EACzC,IAAI,EAAE,QAAQ,CAAC,mBAAmB,EAClC,QAAQ,EAAE,MAAM,GACf,QAAQ,CAAC,cAAc,CAyBzB"}

package/dist/util/getMemberHeadLoc.js

@@ -77,4 +77,3 @@ function getParameterPropertyHeadLoc(sourceCode, node, nodeName) {
         start,
     };
 }
-//# sourceMappingURL=getMemberHeadLoc.js.map

package/dist/util/getOperatorPrecedence.d.ts

@@ -0,0 +1,36 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import { SyntaxKind } from 'typescript';
+import type { ValueOf } from './types';
+export declare enum OperatorPrecedence {
+    Comma = 0,
+    Spread = 1,
+    Yield = 2,
+    Assignment = 3,
+    Conditional = 4,
+    Coalesce = 4,// NOTE: This is wrong
+    LogicalOR = 5,
+    LogicalAND = 6,
+    BitwiseOR = 7,
+    BitwiseXOR = 8,
+    BitwiseAND = 9,
+    Equality = 10,
+    Relational = 11,
+    Shift = 12,
+    Additive = 13,
+    Multiplicative = 14,
+    Exponentiation = 15,
+    Unary = 16,
+    Update = 17,
+    LeftHandSide = 18,
+    Member = 19,
+    Primary = 20,
+    Highest = 20,
+    Lowest = 0,
+    Invalid = -1
+}
+export declare function getOperatorPrecedenceForNode(node: TSESTree.Node): OperatorPrecedence;
+type TSESTreeOperatorKind = ValueOf<TSESTree.BinaryOperatorToText> | ValueOf<TSESTree.PunctuatorTokenToText>;
+export declare function getOperatorPrecedence(nodeKind: SyntaxKind, operatorKind: SyntaxKind, hasArguments?: boolean): OperatorPrecedence;
+export declare function getBinaryOperatorPrecedence(kind: SyntaxKind | TSESTreeOperatorKind): OperatorPrecedence;
+export {};
+//# sourceMappingURL=getOperatorPrecedence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getOperatorPrecedence.d.ts","sourceRoot":"","sources":["../../src/util/getOperatorPrecedence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvC,oBAAY,kBAAkB;IAI5B,KAAK,IAAA;IAKL,MAAM,IAAA;IAkBN,KAAK,IAAA;IAML,UAAU,IAAA;IAWV,WAAW,IAAA;IAOX,QAAQ,IAAc,CAAE,sBAAsB;IAK9C,SAAS,IAAA;IAKT,UAAU,IAAA;IAKV,SAAS,IAAA;IAKT,UAAU,IAAA;IAKV,UAAU,IAAA;IAQV,QAAQ,KAAA;IAWR,UAAU,KAAA;IAOV,KAAK,KAAA;IAML,QAAQ,KAAA;IAMR,cAAc,KAAA;IAKd,cAAc,KAAA;IAed,KAAK,KAAA;IAML,MAAM,KAAA;IAQN,YAAY,KAAA;IAkBZ,MAAM,KAAA;IAiBN,OAAO,KAAA;IAEP,OAAO,KAAU;IACjB,MAAM,IAAQ;IAGd,OAAO,KAAK;CACb;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,CAAC,IAAI,GAClB,kBAAkB,CA8FpB;AAED,KAAK,oBAAoB,GACrB,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC,GACtC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;AAE5C,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,UAAU,EACpB,YAAY,EAAE,UAAU,EACxB,YAAY,CAAC,EAAE,OAAO,GACrB,kBAAkB,CAqGpB;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,UAAU,GAAG,oBAAoB,GACtC,kBAAkB,CAkFpB"}

package/dist/util/getOperatorPrecedence.js

@@ -415,4 +415,3 @@ function getBinaryOperatorPrecedence(kind) {
     // parsing to stop.
     return -1;
 }
-//# sourceMappingURL=getOperatorPrecedence.js.map

package/dist/util/getParentFunctionNode.d.ts

@@ -0,0 +1,3 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function getParentFunctionNode(node: TSESTree.Node): TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | null;
+//# sourceMappingURL=getParentFunctionNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getParentFunctionNode.d.ts","sourceRoot":"","sources":["../../src/util/getParentFunctionNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAEjB,QAAQ,CAAC,uBAAuB,GAChC,QAAQ,CAAC,mBAAmB,GAC5B,QAAQ,CAAC,kBAAkB,GAC3B,IAAI,CAiBP"}

package/dist/util/getParentFunctionNode.js

@@ -16,4 +16,3 @@ function getParentFunctionNode(node) {
     // the parser won't error, so we shouldn't throw here
     /* istanbul ignore next */ return null;
 }
-//# sourceMappingURL=getParentFunctionNode.js.map

package/dist/util/getStaticStringValue.d.ts

@@ -0,0 +1,12 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+/**
+ * Returns the result of the string conversion applied to the evaluated value of the given expression node,
+ * if it can be determined statically.
+ *
+ * This function returns a `string` value for all `Literal` nodes and simple `TemplateLiteral` nodes only.
+ * In all other cases, this function returns `null`.
+ * @param node Expression node.
+ * @returns String value if it can be determined. Otherwise, `null`.
+ */
+export declare function getStaticStringValue(node: TSESTree.Node): string | null;
+//# sourceMappingURL=getStaticStringValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getStaticStringValue.d.ts","sourceRoot":"","sources":["../../src/util/getStaticStringValue.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAMzD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,MAAM,GAAG,IAAI,CAgCvE"}

package/dist/util/getStaticStringValue.js

@@ -42,4 +42,3 @@ function getStaticStringValue(node) {
     }
     return null;
 }
-//# sourceMappingURL=getStaticStringValue.js.map

package/dist/util/getStringLength.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getStringLength.d.ts","sourceRoot":"","sources":["../../src/util/getStringLength.ts"],"names":[],"mappings":"AAQA,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQrD"}

package/dist/util/getStringLength.js

@@ -16,4 +16,3 @@ function getStringLength(value) {
     splitter ??= new graphemer_1.default();
     return splitter.countGraphemes(value);
 }
-//# sourceMappingURL=getStringLength.js.map

package/dist/util/getTextWithParentheses.d.ts

@@ -0,0 +1,4 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { SourceCode } from '@typescript-eslint/utils/ts-eslint';
+export declare function getTextWithParentheses(sourceCode: Readonly<SourceCode>, node: TSESTree.Node): string;
+//# sourceMappingURL=getTextWithParentheses.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getTextWithParentheses.d.ts","sourceRoot":"","sources":["../../src/util/getTextWithParentheses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAUrE,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAClB,MAAM,CAoBR"}

package/dist/util/getTextWithParentheses.js

@@ -14,4 +14,3 @@ function getTextWithParentheses(sourceCode, node) {
     }
     return sourceCode.getText(node, beforeCount, afterCount);
 }
-//# sourceMappingURL=getTextWithParentheses.js.map

package/dist/util/getThisExpression.d.ts

@@ -0,0 +1,3 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function getThisExpression(node: TSESTree.Node): TSESTree.ThisExpression | undefined;
+//# sourceMappingURL=getThisExpression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getThisExpression.d.ts","sourceRoot":"","sources":["../../src/util/getThisExpression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,CAAC,IAAI,GAClB,QAAQ,CAAC,cAAc,GAAG,SAAS,CAgBrC"}

package/dist/util/getThisExpression.js

@@ -22,4 +22,3 @@ function getThisExpression(node) {
     }
     return;
 }
-//# sourceMappingURL=getThisExpression.js.map

package/dist/util/getValueOfLiteralType.d.ts

@@ -0,0 +1,3 @@
+import type * as ts from 'typescript';
+export declare const getValueOfLiteralType: (type: ts.LiteralType) => bigint | number | string;
+//# sourceMappingURL=getValueOfLiteralType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getValueOfLiteralType.d.ts","sourceRoot":"","sources":["../../src/util/getValueOfLiteralType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAYtC,eAAO,MAAM,qBAAqB,SAC1B,EAAE,CAAC,WAAW,KACnB,MAAM,GAAG,MAAM,GAAG,MAKpB,CAAC"}

package/dist/util/getValueOfLiteralType.js

@@ -14,4 +14,3 @@ const getValueOfLiteralType = (type) => {
     return type.value;
 };
 exports.getValueOfLiteralType = getValueOfLiteralType;
-//# sourceMappingURL=getValueOfLiteralType.js.map

package/dist/util/getWrappedCode.d.ts

@@ -0,0 +1,3 @@
+import type { OperatorPrecedence } from './getOperatorPrecedence';
+export declare function getWrappedCode(text: string, nodePrecedence: OperatorPrecedence, parentPrecedence: OperatorPrecedence): string;
+//# sourceMappingURL=getWrappedCode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getWrappedCode.d.ts","sourceRoot":"","sources":["../../src/util/getWrappedCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,kBAAkB,EAClC,gBAAgB,EAAE,kBAAkB,GACnC,MAAM,CAER"}

package/dist/util/getWrappedCode.js

@@ -4,4 +4,3 @@ exports.getWrappedCode = getWrappedCode;
 function getWrappedCode(text, nodePrecedence, parentPrecedence) {
     return nodePrecedence > parentPrecedence ? text : `(${text})`;
 }
-//# sourceMappingURL=getWrappedCode.js.map

package/dist/util/getWrappingFixer.d.ts

@@ -0,0 +1,43 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+interface WrappingFixerParams {
+    /**
+     * Descendant of `node` we want to preserve.
+     * Use this to replace some code with another.
+     * By default it's the node we are modifying (so nothing is removed).
+     * You can pass multiple nodes as an array.
+     */
+    innerNode?: TSESTree.Node | TSESTree.Node[];
+    /** The node we want to modify. */
+    node: TSESTree.Node;
+    /** Source code. */
+    sourceCode: Readonly<TSESLint.SourceCode>;
+    /**
+     * The function which gets the code of the `innerNode` and returns some code around it.
+     * Receives multiple arguments if there are multiple innerNodes.
+     * E.g. ``code => `${code} != null` ``
+     */
+    wrap: (...code: string[]) => string;
+}
+/**
+ * Wraps node with some code. Adds parenthesis as necessary.
+ * @returns Fixer which adds the specified code and parens if necessary.
+ */
+export declare function getWrappingFixer(params: WrappingFixerParams): TSESLint.ReportFixFunction;
+/**
+ * If the node to be moved and the destination node require parentheses, include parentheses in the node to be moved.
+ * @param sourceCode Source code of current file
+ * @param nodeToMove Nodes that need to be moved
+ * @param destinationNode Final destination node with nodeToMove
+ * @returns If parentheses are required, code for the nodeToMove node is returned with parentheses at both ends of the code.
+ */
+export declare function getMovedNodeCode(params: {
+    destinationNode: TSESTree.Node;
+    nodeToMove: TSESTree.Node;
+    sourceCode: Readonly<TSESLint.SourceCode>;
+}): string;
+/**
+ * Check if a node will always have the same precedence if it's parent changes.
+ */
+export declare function isStrongPrecedenceNode(innerNode: TSESTree.Node): boolean;
+export {};
+//# sourceMappingURL=getWrappingFixer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getWrappingFixer.d.ts","sourceRoot":"","sources":["../../src/util/getWrappingFixer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAQnE,UAAU,mBAAmB;IAC3B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC5C,kCAAkC;IAClC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;IACpB,mBAAmB;IACnB,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC1C;;;;OAIG;IACH,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;CACrC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,GAC1B,QAAQ,CAAC,iBAAiB,CA2C5B;AACD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC/B,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC1B,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;CAC3C,GAAG,MAAM,CAeT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAcxE"}

package/dist/util/getWrappingFixer.js

@@ -179,4 +179,3 @@ function isObjectExpressionInOneLineReturn(node, innerNode) {
         node.parent.body === node &&
         innerNode.type === utils_1.AST_NODE_TYPES.ObjectExpression);
 }
-//# sourceMappingURL=getWrappingFixer.js.map

package/dist/util/index.d.ts

@@ -0,0 +1,35 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export * from './astUtils';
+export * from './collectUnusedVariables';
+export * from './createRule';
+export * from './getFixOrSuggest';
+export * from './getFunctionHeadLoc';
+export * from './getOperatorPrecedence';
+export * from './getStaticStringValue';
+export * from './getStringLength';
+export * from './getTextWithParentheses';
+export * from './getThisExpression';
+export * from './getWrappingFixer';
+export * from './isArrayMethodCallWithPredicate';
+export * from './isAssignee';
+export * from './isNodeEqual';
+export * from './isNullLiteral';
+export * from './isStartOfExpressionStatement';
+export * from './isUndefinedIdentifier';
+export * from './misc';
+export * from './needsPrecedingSemiColon';
+export * from './objectIterators';
+export * from './needsToBeAwaited';
+export * from './scopeUtils';
+export * from './types';
+export * from './getConstraintInfo';
+export * from './getValueOfLiteralType';
+export * from './truthinessAndNullishUtils';
+export * from '@typescript-eslint/type-utils';
+export declare const applyDefault: typeof ESLintUtils.applyDefault, deepMerge: typeof ESLintUtils.deepMerge, getParserServices: typeof ESLintUtils.getParserServices, isObjectNotArray: typeof ESLintUtils.isObjectNotArray, nullThrows: typeof ESLintUtils.nullThrows, NullThrowsReasons: {
+    readonly MissingParent: "Expected node to have a parent.";
+    readonly MissingToken: (token: string, thing: string) => string;
+};
+export type InferMessageIdsTypeFromRule<T> = ESLintUtils.InferMessageIdsTypeFromRule<T>;
+export type InferOptionsTypeFromRule<T> = ESLintUtils.InferOptionsTypeFromRule<T>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/util/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kCAAkC,CAAC;AACjD,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,QAAQ,CAAC;AACvB,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAG5C,cAAc,+BAA+B,CAAC;AAE9C,eAAO,MACL,YAAY,mCACZ,SAAS,gCACT,iBAAiB,wCACjB,gBAAgB,uCAChB,UAAU,iCACV,iBAAiB;;;CACJ,CAAC;AAChB,MAAM,MAAM,2BAA2B,CAAC,CAAC,IACvC,WAAW,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC;AAC7C,MAAM,MAAM,wBAAwB,CAAC,CAAC,IACpC,WAAW,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC"}

package/dist/util/index.js

@@ -45,4 +45,3 @@ __exportStar(require("./truthinessAndNullishUtils"), exports);
 // this is done for convenience - saves migrating all of the old rules
 __exportStar(require("@typescript-eslint/type-utils"), exports);
 exports.applyDefault = utils_1.ESLintUtils.applyDefault, exports.deepMerge = utils_1.ESLintUtils.deepMerge, exports.getParserServices = utils_1.ESLintUtils.getParserServices, exports.isObjectNotArray = utils_1.ESLintUtils.isObjectNotArray, exports.nullThrows = utils_1.ESLintUtils.nullThrows, exports.NullThrowsReasons = utils_1.ESLintUtils.NullThrowsReasons;
-//# sourceMappingURL=index.js.map

package/dist/util/isArrayMethodCallWithPredicate.d.ts

@@ -0,0 +1,4 @@
+import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
+import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';
+export declare function isArrayMethodCallWithPredicate(context: RuleContext<string, unknown[]>, services: ParserServicesWithTypeInformation, node: TSESTree.CallExpression): boolean;
+//# sourceMappingURL=isArrayMethodCallWithPredicate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isArrayMethodCallWithPredicate.d.ts","sourceRoot":"","sources":["../../src/util/isArrayMethodCallWithPredicate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EACjC,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAkBtE,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,EACvC,QAAQ,EAAE,iCAAiC,EAC3C,IAAI,EAAE,QAAQ,CAAC,cAAc,GAC5B,OAAO,CAiBT"}

package/dist/util/isArrayMethodCallWithPredicate.js

@@ -62,4 +62,3 @@ function isArrayMethodCallWithPredicate(context, services, node) {
         .flatMap(part => tsutils.intersectionTypeParts(part))
         .some(t => checker.isArrayType(t) || checker.isTupleType(t));
 }
-//# sourceMappingURL=isArrayMethodCallWithPredicate.js.map

package/dist/util/isAssignee.d.ts

@@ -0,0 +1,3 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function isAssignee(node: TSESTree.Node): boolean;
+//# sourceMappingURL=isAssignee.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isAssignee.d.ts","sourceRoot":"","sources":["../../src/util/isAssignee.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAoDvD"}

package/dist/util/isAssignee.js

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

package/dist/util/isNodeEqual.d.ts

@@ -0,0 +1,3 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function isNodeEqual(a: TSESTree.Node, b: TSESTree.Node): boolean;
+//# sourceMappingURL=isNodeEqual.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isNodeEqual.d.ts","sourceRoot":"","sources":["../../src/util/isNodeEqual.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CA4BvE"}

package/dist/util/isNodeEqual.js

@@ -23,4 +23,3 @@ function isNodeEqual(a, b) {
     }
     return false;
 }
-//# sourceMappingURL=isNodeEqual.js.map

package/dist/util/isNullLiteral.d.ts

@@ -0,0 +1,3 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function isNullLiteral(i: TSESTree.Node): i is TSESTree.NullLiteral;
+//# sourceMappingURL=isNullLiteral.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isNullLiteral.d.ts","sourceRoot":"","sources":["../../src/util/isNullLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,wBAAgB,aAAa,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,GAAG,CAAC,IAAI,QAAQ,CAAC,WAAW,CAEzE"}

package/dist/util/isNullLiteral.js

@@ -5,4 +5,3 @@ const utils_1 = require("@typescript-eslint/utils");
 function isNullLiteral(i) {
     return i.type === utils_1.AST_NODE_TYPES.Literal && i.value == null;
 }
-//# sourceMappingURL=isNullLiteral.js.map

package/dist/util/isStartOfExpressionStatement.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+/**
+ * Tests if a node appears at the beginning of an ancestor ExpressionStatement node.
+ * @param node The node to check.
+ * @returns Whether the node appears at the beginning of an ancestor ExpressionStatement node.
+ */
+export declare function isStartOfExpressionStatement(node: TSESTree.Node): boolean;
+//# sourceMappingURL=isStartOfExpressionStatement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isStartOfExpressionStatement.d.ts","sourceRoot":"","sources":["../../src/util/isStartOfExpressionStatement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAOzD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAUzE"}

package/dist/util/isStartOfExpressionStatement.js

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

package/dist/util/isTypeImport.d.ts

@@ -0,0 +1,13 @@
+import type { Definition, ImportBindingDefinition } from '@typescript-eslint/scope-manager';
+/**
+ * Determine whether a variable definition is a type import. e.g.:
+ *
+ * ```ts
+ * import type { Foo } from 'foo';
+ * import { type Bar } from 'bar';
+ * ```
+ *
+ * @param definition - The variable definition to check.
+ */
+export declare function isTypeImport(definition?: Definition): definition is ImportBindingDefinition;
+//# sourceMappingURL=isTypeImport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isTypeImport.d.ts","sourceRoot":"","sources":["../../src/util/isTypeImport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,uBAAuB,EACxB,MAAM,kCAAkC,CAAC;AAK1C;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,UAAU,CAAC,EAAE,UAAU,GACtB,UAAU,IAAI,uBAAuB,CAOvC"}

package/dist/util/isTypeImport.js

@@ -19,4 +19,3 @@ function isTypeImport(definition) {
             (definition.node.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                 definition.node.importKind === 'type')));
 }
-//# sourceMappingURL=isTypeImport.js.map

package/dist/util/isUndefinedIdentifier.d.ts

@@ -0,0 +1,3 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function isUndefinedIdentifier(i: TSESTree.Node): boolean;
+//# sourceMappingURL=isUndefinedIdentifier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isUndefinedIdentifier.d.ts","sourceRoot":"","sources":["../../src/util/isUndefinedIdentifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAE/D"}

package/dist/util/isUndefinedIdentifier.js

@@ -5,4 +5,3 @@ const utils_1 = require("@typescript-eslint/utils");
 function isUndefinedIdentifier(i) {
     return i.type === utils_1.AST_NODE_TYPES.Identifier && i.name === 'undefined';
 }
-//# sourceMappingURL=isUndefinedIdentifier.js.map