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

package/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.d.ts

@@ -0,0 +1,42 @@
+import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
+import type { SourceCode } from '@typescript-eslint/utils/ts-eslint';
+import type { PreferOptionalChainOptions } from './PreferOptionalChainOptions';
+export declare const enum OperandValidity {
+    Valid = "Valid",
+    Invalid = "Invalid"
+}
+export declare const enum NullishComparisonType {
+    /** `x != null`, `x != undefined` */
+    NotEqualNullOrUndefined = "NotEqualNullOrUndefined",
+    /** `x == null`, `x == undefined` */
+    EqualNullOrUndefined = "EqualNullOrUndefined",
+    /** `x !== null` */
+    NotStrictEqualNull = "NotStrictEqualNull",
+    /** `x === null` */
+    StrictEqualNull = "StrictEqualNull",
+    /** `x !== undefined`, `typeof x !== 'undefined'` */
+    NotStrictEqualUndefined = "NotStrictEqualUndefined",
+    /** `x === undefined`, `typeof x === 'undefined'` */
+    StrictEqualUndefined = "StrictEqualUndefined",
+    /** `!x` */
+    NotBoolean = "NotBoolean",
+    /** `x` */
+    Boolean = "Boolean"
+}
+export interface ValidOperand {
+    comparedName: TSESTree.Node;
+    comparisonType: NullishComparisonType;
+    isYoda: boolean;
+    node: TSESTree.Expression;
+    type: OperandValidity.Valid;
+}
+export interface InvalidOperand {
+    type: OperandValidity.Invalid;
+}
+type Operand = InvalidOperand | ValidOperand;
+export declare function gatherLogicalOperands(node: TSESTree.LogicalExpression, parserServices: ParserServicesWithTypeInformation, sourceCode: Readonly<SourceCode>, options: PreferOptionalChainOptions): {
+    newlySeenLogicals: Set<TSESTree.LogicalExpression>;
+    operands: Operand[];
+};
+export {};
+//# sourceMappingURL=gatherLogicalOperands.d.ts.map

package/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gatherLogicalOperands.d.ts","sourceRoot":"","sources":["../../../src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EACjC,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAYrE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAS/E,0BAAkB,eAAe;IAC/B,KAAK,UAAU;IACf,OAAO,YAAY;CACpB;AACD,0BAAkB,qBAAqB;IACrC,oCAAoC;IACpC,uBAAuB,4BAA4B;IACnD,oCAAoC;IACpC,oBAAoB,yBAAyB;IAE7C,mBAAmB;IACnB,kBAAkB,uBAAuB;IACzC,mBAAmB;IACnB,eAAe,oBAAoB;IAEnC,oDAAoD;IACpD,uBAAuB,4BAA4B;IACnD,oDAAoD;IACpD,oBAAoB,yBAAyB;IAE7C,WAAW;IACX,UAAU,eAAe;IACzB,UAAU;IACV,OAAO,YAAY;CACpB;AACD,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC5B,cAAc,EAAE,qBAAqB,CAAC;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC;IAC1B,IAAI,EAAE,eAAe,CAAC,KAAK,CAAC;CAC7B;AACD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,eAAe,CAAC,OAAO,CAAC;CAC/B;AACD,KAAK,OAAO,GAAG,cAAc,GAAG,YAAY,CAAC;AAwD7C,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,CAAC,iBAAiB,EAChC,cAAc,EAAE,iCAAiC,EACjD,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,EAChC,OAAO,EAAE,0BAA0B,GAClC;IACD,iBAAiB,EAAE,GAAG,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;IACnD,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB,CA0PA"}

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

@@ -33,11 +33,42 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullishComparisonType = exports.OperandValidity = void 0;
 exports.gatherLogicalOperands = gatherLogicalOperands;
 const utils_1 = require("@typescript-eslint/utils");
 const ts_api_utils_1 = require("ts-api-utils");
 const ts = __importStar(require("typescript"));
 const util_1 = require("../../util");
+var ComparisonValueType;
+(function (ComparisonValueType) {
+    ComparisonValueType["Null"] = "Null";
+    ComparisonValueType["Undefined"] = "Undefined";
+    ComparisonValueType["UndefinedStringLiteral"] = "UndefinedStringLiteral";
+})(ComparisonValueType || (ComparisonValueType = {}));
+var OperandValidity;
+(function (OperandValidity) {
+    OperandValidity["Valid"] = "Valid";
+    OperandValidity["Invalid"] = "Invalid";
+})(OperandValidity || (exports.OperandValidity = OperandValidity = {}));
+var NullishComparisonType;
+(function (NullishComparisonType) {
+    /** `x != null`, `x != undefined` */
+    NullishComparisonType["NotEqualNullOrUndefined"] = "NotEqualNullOrUndefined";
+    /** `x == null`, `x == undefined` */
+    NullishComparisonType["EqualNullOrUndefined"] = "EqualNullOrUndefined";
+    /** `x !== null` */
+    NullishComparisonType["NotStrictEqualNull"] = "NotStrictEqualNull";
+    /** `x === null` */
+    NullishComparisonType["StrictEqualNull"] = "StrictEqualNull";
+    /** `x !== undefined`, `typeof x !== 'undefined'` */
+    NullishComparisonType["NotStrictEqualUndefined"] = "NotStrictEqualUndefined";
+    /** `x === undefined`, `typeof x === 'undefined'` */
+    NullishComparisonType["StrictEqualUndefined"] = "StrictEqualUndefined";
+    /** `!x` */
+    NullishComparisonType["NotBoolean"] = "NotBoolean";
+    /** `x` */
+    NullishComparisonType["Boolean"] = "Boolean";
+})(NullishComparisonType || (exports.NullishComparisonType = NullishComparisonType = {}));
 const NULLISH_FLAGS = ts.TypeFlags.Null | ts.TypeFlags.Undefined;
 function isValidFalseBooleanCheckType(node, disallowFalseyLiteral, parserServices, options) {
     const type = parserServices.getTypeAtLocation(node);
@@ -104,86 +135,86 @@ function gatherLogicalOperands(node, parserServices, sourceCode, options) {
                         isYoda: true,
                     };
                 })();
-                if (comparedValue === "UndefinedStringLiteral" /* ComparisonValueType.UndefinedStringLiteral */) {
+                if (comparedValue === ComparisonValueType.UndefinedStringLiteral) {
                     if (comparedExpression.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
                         comparedExpression.operator === 'typeof') {
                         const argument = comparedExpression.argument;
                         if (argument.type === utils_1.AST_NODE_TYPES.Identifier &&
                             // typeof window === 'undefined'
                             (0, util_1.isReferenceToGlobalFunction)(argument.name, argument, sourceCode)) {
-                            result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                            result.push({ type: OperandValidity.Invalid });
                             continue;
                         }
                         // typeof x.y === 'undefined'
                         result.push({
                             comparedName: comparedExpression.argument,
                             comparisonType: operand.operator.startsWith('!')
-                                ? "NotStrictEqualUndefined" /* NullishComparisonType.NotStrictEqualUndefined */
-                                : "StrictEqualUndefined" /* NullishComparisonType.StrictEqualUndefined */,
+                                ? NullishComparisonType.NotStrictEqualUndefined
+                                : NullishComparisonType.StrictEqualUndefined,
                             isYoda,
                             node: operand,
-                            type: "Valid" /* OperandValidity.Valid */,
+                            type: OperandValidity.Valid,
                         });
                         continue;
                     }
                     // y === 'undefined'
-                    result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                    result.push({ type: OperandValidity.Invalid });
                     continue;
                 }
                 switch (operand.operator) {
                     case '!=':
                     case '==':
-                        if (comparedValue === "Null" /* ComparisonValueType.Null */ ||
-                            comparedValue === "Undefined" /* ComparisonValueType.Undefined */) {
+                        if (comparedValue === ComparisonValueType.Null ||
+                            comparedValue === ComparisonValueType.Undefined) {
                             // x == null, x == undefined
                             result.push({
                                 comparedName: comparedExpression,
                                 comparisonType: operand.operator.startsWith('!')
-                                    ? "NotEqualNullOrUndefined" /* NullishComparisonType.NotEqualNullOrUndefined */
-                                    : "EqualNullOrUndefined" /* NullishComparisonType.EqualNullOrUndefined */,
+                                    ? NullishComparisonType.NotEqualNullOrUndefined
+                                    : NullishComparisonType.EqualNullOrUndefined,
                                 isYoda,
                                 node: operand,
-                                type: "Valid" /* OperandValidity.Valid */,
+                                type: OperandValidity.Valid,
                             });
                             continue;
                         }
                         // x == something :(
-                        result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                        result.push({ type: OperandValidity.Invalid });
                         continue;
                     case '!==':
                     case '===': {
                         const comparedName = comparedExpression;
                         switch (comparedValue) {
-                            case "Null" /* ComparisonValueType.Null */:
+                            case ComparisonValueType.Null:
                                 result.push({
                                     comparedName,
                                     comparisonType: operand.operator.startsWith('!')
-                                        ? "NotStrictEqualNull" /* NullishComparisonType.NotStrictEqualNull */
-                                        : "StrictEqualNull" /* NullishComparisonType.StrictEqualNull */,
+                                        ? NullishComparisonType.NotStrictEqualNull
+                                        : NullishComparisonType.StrictEqualNull,
                                     isYoda,
                                     node: operand,
-                                    type: "Valid" /* OperandValidity.Valid */,
+                                    type: OperandValidity.Valid,
                                 });
                                 continue;
-                            case "Undefined" /* ComparisonValueType.Undefined */:
+                            case ComparisonValueType.Undefined:
                                 result.push({
                                     comparedName,
                                     comparisonType: operand.operator.startsWith('!')
-                                        ? "NotStrictEqualUndefined" /* NullishComparisonType.NotStrictEqualUndefined */
-                                        : "StrictEqualUndefined" /* NullishComparisonType.StrictEqualUndefined */,
+                                        ? NullishComparisonType.NotStrictEqualUndefined
+                                        : NullishComparisonType.StrictEqualUndefined,
                                     isYoda,
                                     node: operand,
-                                    type: "Valid" /* OperandValidity.Valid */,
+                                    type: OperandValidity.Valid,
                                 });
                                 continue;
                             default:
                                 // x === something :(
-                                result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                                result.push({ type: OperandValidity.Invalid });
                                 continue;
                         }
                     }
                 }
-                result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                result.push({ type: OperandValidity.Invalid });
                 continue;
             }
             case utils_1.AST_NODE_TYPES.UnaryExpression:
@@ -191,31 +222,31 @@ function gatherLogicalOperands(node, parserServices, sourceCode, options) {
                     isValidFalseBooleanCheckType(operand.argument, areMoreOperands && node.operator === '||', parserServices, options)) {
                     result.push({
                         comparedName: operand.argument,
-                        comparisonType: "NotBoolean" /* NullishComparisonType.NotBoolean */,
+                        comparisonType: NullishComparisonType.NotBoolean,
                         isYoda: false,
                         node: operand,
-                        type: "Valid" /* OperandValidity.Valid */,
+                        type: OperandValidity.Valid,
                     });
                     continue;
                 }
-                result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                result.push({ type: OperandValidity.Invalid });
                 continue;
             case utils_1.AST_NODE_TYPES.LogicalExpression:
                 // explicitly ignore the mixed logical expression cases
-                result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                result.push({ type: OperandValidity.Invalid });
                 continue;
             default:
                 if (isValidFalseBooleanCheckType(operand, areMoreOperands && node.operator === '&&', parserServices, options)) {
                     result.push({
                         comparedName: operand,
-                        comparisonType: "Boolean" /* NullishComparisonType.Boolean */,
+                        comparisonType: NullishComparisonType.Boolean,
                         isYoda: false,
                         node: operand,
-                        type: "Valid" /* OperandValidity.Valid */,
+                        type: OperandValidity.Valid,
                     });
                 }
                 else {
-                    result.push({ type: "Invalid" /* OperandValidity.Invalid */ });
+                    result.push({ type: OperandValidity.Invalid });
                 }
                 continue;
         }
@@ -271,19 +302,18 @@ function gatherLogicalOperands(node, parserServices, sourceCode, options) {
             case utils_1.AST_NODE_TYPES.Literal:
                 // eslint-disable-next-line eqeqeq, @typescript-eslint/internal/eqeq-nullish -- intentional exact comparison against null
                 if (node.value === null && node.raw === 'null') {
-                    return "Null" /* ComparisonValueType.Null */;
+                    return ComparisonValueType.Null;
                 }
                 if (node.value === 'undefined') {
-                    return "UndefinedStringLiteral" /* ComparisonValueType.UndefinedStringLiteral */;
+                    return ComparisonValueType.UndefinedStringLiteral;
                 }
                 return null;
             case utils_1.AST_NODE_TYPES.Identifier:
                 if (node.name === 'undefined') {
-                    return "Undefined" /* ComparisonValueType.Undefined */;
+                    return ComparisonValueType.Undefined;
                 }
                 return null;
         }
         return null;
     }
 }
-//# sourceMappingURL=gatherLogicalOperands.js.map

package/dist/rules/prefer-optional-chain.d.ts

@@ -0,0 +1,4 @@
+import type { PreferOptionalChainMessageIds, PreferOptionalChainOptions } from './prefer-optional-chain-utils/PreferOptionalChainOptions';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<PreferOptionalChainMessageIds, [PreferOptionalChainOptions], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-optional-chain.d.ts.map

package/dist/rules/prefer-optional-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-optional-chain.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-optional-chain.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,6BAA6B,EAC7B,0BAA0B,EAC3B,MAAM,0DAA0D,CAAC;;AAelE,wBAiMG"}

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

@@ -88,7 +88,7 @@ exports.default = (0, util_1.createRule)({
                 }
                 let currentChain = [];
                 for (const operand of operands) {
-                    if (operand.type === "Invalid" /* OperandValidity.Invalid */) {
+                    if (operand.type === gatherLogicalOperands_1.OperandValidity.Invalid) {
                         (0, analyzeChain_1.analyzeChain)(context, parserServices, options, node, node.operator, currentChain);
                         currentChain = [];
                     }
@@ -144,4 +144,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=prefer-optional-chain.js.map

package/dist/rules/prefer-promise-reject-errors.d.ts

@@ -0,0 +1,11 @@
+export type MessageIds = 'rejectAnError';
+export type Options = [
+    {
+        allowEmptyReject?: boolean;
+        allowThrowingAny?: boolean;
+        allowThrowingUnknown?: boolean;
+    }
+];
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"rejectAnError", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-promise-reject-errors.d.ts.map

package/dist/rules/prefer-promise-reject-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-promise-reject-errors.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-promise-reject-errors.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,UAAU,GAAG,eAAe,CAAC;AAEzC,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC;CACF,CAAC;;AAEF,wBAoJG"}

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

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

package/dist/rules/prefer-readonly-parameter-types.d.ts

@@ -0,0 +1,13 @@
+import type { TypeOrValueSpecifier } from '../util';
+export type Options = [
+    {
+        allow?: TypeOrValueSpecifier[];
+        checkParameterProperties?: boolean;
+        ignoreInferredTypes?: boolean;
+        treatMethodsAsReadonly?: boolean;
+    }
+];
+export type MessageIds = 'shouldBeReadonly';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeReadonly", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-readonly-parameter-types.d.ts.map

package/dist/rules/prefer-readonly-parameter-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-readonly-parameter-types.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-readonly-parameter-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAUpD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAC/B,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,sBAAsB,CAAC,EAAE,OAAO,CAAC;KAClC;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC;;AAE5C,wBAqHG"}

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

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

package/dist/rules/prefer-readonly.d.ts

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

package/dist/rules/prefer-readonly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-readonly.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-readonly.ts"],"names":[],"mappings":"AAiBA,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAC1C,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,iBAAiB,CAAC,EAAE,OAAO,CAAC;KAC7B;CACF,CAAC;;AASF,wBAgUG"}

package/dist/rules/prefer-readonly.js

@@ -390,4 +390,3 @@ class ClassScope {
         return this.memberVariableWithConstructorModifications.has(name);
     }
 }
-//# sourceMappingURL=prefer-readonly.js.map

package/dist/rules/prefer-reduce-type-parameter.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-reduce-type-parameter.d.ts.map

package/dist/rules/prefer-reduce-type-parameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-reduce-type-parameter.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-reduce-type-parameter.ts"],"names":[],"mappings":";AAiBA,wBA6GG"}

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

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

package/dist/rules/prefer-regexp-exec.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"regExpExecOverStringMatch", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-regexp-exec.d.ts.map

package/dist/rules/prefer-regexp-exec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-regexp-exec.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-regexp-exec.ts"],"names":[],"mappings":";AAsBA,wBAkKG"}

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

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

package/dist/rules/prefer-return-this-type.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useThisType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-return-this-type.d.ts.map

package/dist/rules/prefer-return-this-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-return-this-type.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-return-this-type.ts"],"names":[],"mappings":";AAeA,wBA8JG"}

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

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

package/dist/rules/prefer-string-starts-ends-with.d.ts

@@ -0,0 +1,11 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+type AllowedSingleElementEquality = 'always' | 'never';
+export type Options = [
+    {
+        allowSingleElementEquality?: AllowedSingleElementEquality;
+    }
+];
+export type MessageIds = 'preferEndsWith' | 'preferStartsWith';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-string-starts-ends-with.d.ts.map

package/dist/rules/prefer-string-starts-ends-with.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-string-starts-ends-with.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-string-starts-ends-with.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAoBnE,KAAK,4BAA4B,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEvD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,0BAA0B,CAAC,EAAE,4BAA4B,CAAC;KAC3D;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;;AAE/D,wBAyrBG"}

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

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

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

@@ -0,0 +1,4 @@
+export type MessageIds = 'preferExpectErrorComment';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferExpectErrorComment", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-ts-expect-error.d.ts.map

package/dist/rules/prefer-ts-expect-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-expect-error.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-ts-expect-error.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,UAAU,GAAG,0BAA0B,CAAC;;AAEpD,wBA0EG"}

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

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

package/dist/rules/promise-function-async.d.ts

@@ -0,0 +1,14 @@
+export type Options = [
+    {
+        allowAny?: boolean;
+        allowedPromiseNames?: string[];
+        checkArrowFunctions?: boolean;
+        checkFunctionDeclarations?: boolean;
+        checkFunctionExpressions?: boolean;
+        checkMethodDeclarations?: boolean;
+    }
+];
+export type MessageIds = 'missingAsync';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAsync", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=promise-function-async.d.ts.map

package/dist/rules/promise-function-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-function-async.d.ts","sourceRoot":"","sources":["../../src/rules/promise-function-async.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;QAC/B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,yBAAyB,CAAC,EAAE,OAAO,CAAC;QACpC,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,uBAAuB,CAAC,EAAE,OAAO,CAAC;KACnC;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,cAAc,CAAC;;AAExC,wBA6OG"}

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

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

package/dist/rules/related-getter-setter-pairs.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatch", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=related-getter-setter-pairs.d.ts.map

package/dist/rules/related-getter-setter-pairs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"related-getter-setter-pairs.d.ts","sourceRoot":"","sources":["../../src/rules/related-getter-setter-pairs.ts"],"names":[],"mappings":";AAwBA,wBAoFG"}

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

@@ -69,4 +69,3 @@ 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.d.ts

@@ -0,0 +1,9 @@
+export type Options = [
+    {
+        ignoreStringArrays?: boolean;
+    }
+];
+export type MessageIds = 'requireCompare';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireCompare", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=require-array-sort-compare.d.ts.map

package/dist/rules/require-array-sort-compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-array-sort-compare.d.ts","sourceRoot":"","sources":["../../src/rules/require-array-sort-compare.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC;;AAE1C,wBAyEG"}

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

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

package/dist/rules/require-await.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAwait" | "removeAsync", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=require-await.d.ts.map

package/dist/rules/require-await.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-await.d.ts","sourceRoot":"","sources":["../../src/rules/require-await.ts"],"names":[],"mappings":";AA8BA,wBAuRG"}

package/dist/rules/require-await.js

@@ -261,4 +261,3 @@ 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.d.ts

@@ -0,0 +1,14 @@
+export type Options = [
+    {
+        allowAny?: boolean;
+        allowBoolean?: boolean;
+        allowNullish?: boolean;
+        allowNumberAndString?: boolean;
+        allowRegExp?: boolean;
+        skipCompoundAssignments?: boolean;
+    }
+];
+export type MessageIds = 'bigintAndNumber' | 'invalid' | 'mismatched';
+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=restrict-plus-operands.d.ts.map

package/dist/rules/restrict-plus-operands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restrict-plus-operands.d.ts","sourceRoot":"","sources":["../../src/rules/restrict-plus-operands.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,uBAAuB,CAAC,EAAE,OAAO,CAAC;KACnC;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,iBAAiB,GAAG,SAAS,GAAG,YAAY,CAAC;;AAEtE,wBA0OG"}

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

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

package/dist/rules/restrict-template-expressions.d.ts

@@ -0,0 +1,18 @@
+import type { Type, TypeChecker } from 'typescript';
+import type { TypeOrValueSpecifier } from '../util';
+import { isTypeAnyType, isTypeNeverType } from '../util';
+type OptionTester = (type: Type, checker: TypeChecker, recursivelyCheckType: (type: Type) => boolean) => boolean;
+declare const optionTesters: {
+    type: "Array" | "RegExp" | "Boolean" | "Number" | "Any" | "Nullish" | "Never";
+    option: "allowAny" | "allowBoolean" | "allowNullish" | "allowRegExp" | "allowNever" | "allowNumber" | "allowArray";
+    tester: typeof isTypeAnyType | typeof isTypeNeverType | OptionTester | ((type: Type, checker: TypeChecker, recursivelyCheckType: (type: Type) => boolean) => boolean) | ((type: Type, checker: TypeChecker) => boolean);
+}[];
+export type Options = [
+    {
+        allow?: TypeOrValueSpecifier[];
+    } & Partial<Record<(typeof optionTesters)[number]['option'], boolean>>
+];
+export type MessageId = 'invalidType';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidType", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=restrict-template-expressions.d.ts.map

package/dist/rules/restrict-template-expressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restrict-template-expressions.d.ts","sourceRoot":"","sources":["../../src/rules/restrict-template-expressions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AASpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,OAAO,EAKL,aAAa,EAEb,eAAe,EAChB,MAAM,SAAS,CAAC;AAEjB,KAAK,YAAY,GAAG,CAClB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,WAAW,EACpB,oBAAoB,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,KAC1C,OAAO,CAAC;AAOb,QAAA,MAAM,aAAa;;;4IARY,IAAI,KAAK,OAAO,KAaF,OAAO,2CAW7B,OAAO;GAQ3B,CAAC;AAEJ,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;KAChC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC;CACvE,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,aAAa,CAAC;;AAEtC,wBA2GG"}

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

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

package/dist/rules/return-await.d.ts

@@ -0,0 +1,4 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const _default: TSESLint.RuleModule<"disallowedPromiseAwait" | "disallowedPromiseAwaitSuggestion" | "nonPromiseAwait" | "requiredPromiseAwait" | "requiredPromiseAwaitSuggestion", [string], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=return-await.d.ts.map

package/dist/rules/return-await.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"return-await.d.ts","sourceRoot":"","sources":["../../src/rules/return-await.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;;AAiCnE,wBAmYG"}

package/dist/rules/return-await.js

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

package/dist/rules/sort-type-constituents.d.ts

@@ -0,0 +1,13 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type Options = [
+    {
+        caseSensitive?: boolean;
+        checkIntersections?: boolean;
+        checkUnions?: boolean;
+        groupOrder?: string[];
+    }
+];
+export type MessageIds = 'notSorted' | 'notSortedNamed' | 'suggestFix';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=sort-type-constituents.d.ts.map

package/dist/rules/sort-type-constituents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-type-constituents.d.ts","sourceRoot":"","sources":["../../src/rules/sort-type-constituents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AA6GnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;KACvB;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,gBAAgB,GAAG,YAAY,CAAC;;AAEvE,wBAiLG"}