@typescript-eslint/eslint-plugin 8.29.2-alpha.0 → 8.29.2-alpha.10

package/dist/raw-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-plugin.d.ts","sourceRoot":"","sources":["../src/raw-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,oCAAoC,CAAC;;;;;;;;;;;;;;;;;;wDAetD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqCpB,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDvE,kBAIE"}

package/dist/raw-plugin.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const parserBase = __importStar(require("@typescript-eslint/parser"));
+const all_1 = __importDefault(require("./configs/eslintrc/all"));
+const base_1 = __importDefault(require("./configs/eslintrc/base"));
+const disable_type_checked_1 = __importDefault(require("./configs/eslintrc/disable-type-checked"));
+const eslint_recommended_1 = __importDefault(require("./configs/eslintrc/eslint-recommended"));
+const recommended_1 = __importDefault(require("./configs/eslintrc/recommended"));
+const recommended_type_checked_1 = __importDefault(require("./configs/eslintrc/recommended-type-checked"));
+const recommended_type_checked_only_1 = __importDefault(require("./configs/eslintrc/recommended-type-checked-only"));
+const strict_1 = __importDefault(require("./configs/eslintrc/strict"));
+const strict_type_checked_1 = __importDefault(require("./configs/eslintrc/strict-type-checked"));
+const strict_type_checked_only_1 = __importDefault(require("./configs/eslintrc/strict-type-checked-only"));
+const stylistic_1 = __importDefault(require("./configs/eslintrc/stylistic"));
+const stylistic_type_checked_1 = __importDefault(require("./configs/eslintrc/stylistic-type-checked"));
+const stylistic_type_checked_only_1 = __importDefault(require("./configs/eslintrc/stylistic-type-checked-only"));
+const all_2 = __importDefault(require("./configs/flat/all"));
+const base_2 = __importDefault(require("./configs/flat/base"));
+const disable_type_checked_2 = __importDefault(require("./configs/flat/disable-type-checked"));
+const eslint_recommended_2 = __importDefault(require("./configs/flat/eslint-recommended"));
+const recommended_2 = __importDefault(require("./configs/flat/recommended"));
+const recommended_type_checked_2 = __importDefault(require("./configs/flat/recommended-type-checked"));
+const recommended_type_checked_only_2 = __importDefault(require("./configs/flat/recommended-type-checked-only"));
+const strict_2 = __importDefault(require("./configs/flat/strict"));
+const strict_type_checked_2 = __importDefault(require("./configs/flat/strict-type-checked"));
+const strict_type_checked_only_2 = __importDefault(require("./configs/flat/strict-type-checked-only"));
+const stylistic_2 = __importDefault(require("./configs/flat/stylistic"));
+const stylistic_type_checked_2 = __importDefault(require("./configs/flat/stylistic-type-checked"));
+const stylistic_type_checked_only_2 = __importDefault(require("./configs/flat/stylistic-type-checked-only"));
+const rules_1 = __importDefault(require("./rules"));
+const parser = {
+    meta: parserBase.meta,
+    parseForESLint: parserBase.parseForESLint,
+};
+// note - cannot migrate this to an import statement because it will make TSC copy the package.json to the dist folder
+const { name, version } = require('../package.json');
+const plugin = {
+    // not fully initialized yet.
+    // See https://eslint.org/docs/latest/extend/plugins#configs-in-plugins
+    configs: {
+        all: all_1.default,
+        base: base_1.default,
+        'disable-type-checked': disable_type_checked_1.default,
+        'eslint-recommended': eslint_recommended_1.default,
+        recommended: recommended_1.default,
+        /** @deprecated - please use "recommended-type-checked" instead. */
+        'recommended-requiring-type-checking': recommended_type_checked_1.default,
+        'recommended-type-checked': recommended_type_checked_1.default,
+        'recommended-type-checked-only': recommended_type_checked_only_1.default,
+        strict: strict_1.default,
+        'strict-type-checked': strict_type_checked_1.default,
+        'strict-type-checked-only': strict_type_checked_only_1.default,
+        stylistic: stylistic_1.default,
+        'stylistic-type-checked': stylistic_type_checked_1.default,
+        'stylistic-type-checked-only': stylistic_type_checked_only_1.default,
+    },
+    meta: {
+        name,
+        version,
+    },
+    rules: rules_1.default,
+};
+// @ts-expect-error -- upstream type incompatibility stuff
+const flatPlugin = plugin;
+// included due to https://github.com/eslint/eslint/issues/19513
+const flatConfigs = {
+    'flat/all': (0, all_2.default)(flatPlugin, parser),
+    'flat/base': (0, base_2.default)(flatPlugin, parser),
+    'flat/disable-type-checked': (0, disable_type_checked_2.default)(flatPlugin, parser),
+    'flat/eslint-recommended': (0, eslint_recommended_2.default)(flatPlugin, parser),
+    'flat/recommended': (0, recommended_2.default)(flatPlugin, parser),
+    'flat/recommended-type-checked': (0, recommended_type_checked_2.default)(flatPlugin, parser),
+    'flat/recommended-type-checked-only': (0, recommended_type_checked_only_2.default)(flatPlugin, parser),
+    'flat/strict': (0, strict_2.default)(flatPlugin, parser),
+    'flat/strict-type-checked': (0, strict_type_checked_2.default)(flatPlugin, parser),
+    'flat/strict-type-checked-only': (0, strict_type_checked_only_2.default)(flatPlugin, parser),
+    'flat/stylistic': (0, stylistic_2.default)(flatPlugin, parser),
+    'flat/stylistic-type-checked': (0, stylistic_type_checked_2.default)(flatPlugin, parser),
+    'flat/stylistic-type-checked-only': (0, stylistic_type_checked_only_2.default)(flatPlugin, parser),
+};
+Object.assign(plugin.configs, flatConfigs);
+module.exports = {
+    flatConfigs,
+    parser,
+    plugin,
+};

package/dist/rules/index.d.ts

@@ -153,7 +153,7 @@ declare const rules: {
     'prefer-return-this-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useThisType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'prefer-string-starts-ends-with': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./prefer-string-starts-ends-with").MessageIds, import("./prefer-string-starts-ends-with").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'prefer-ts-expect-error': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferExpectErrorComment", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    'promise-function-async': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAsync", import("./promise-function-async").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'promise-function-async': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./promise-function-async").MessageIds, import("./promise-function-async").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'related-getter-setter-pairs': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatch", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'require-array-sort-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireCompare", import("./require-array-sort-compare").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'require-await': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAwait" | "removeAsync", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/rules/no-explicit-any.d.ts

@@ -5,7 +5,7 @@ export type Options = [
         ignoreRestArgs?: boolean;
     }
 ];
-export type MessageIds = 'suggestNever' | 'suggestUnknown' | 'unexpectedAny';
+export type MessageIds = 'suggestNever' | 'suggestPropertyKey' | 'suggestUnknown' | 'unexpectedAny';
 declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
 export default _default;
 //# sourceMappingURL=no-explicit-any.d.ts.map

package/dist/rules/no-explicit-any.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-explicit-any.d.ts","sourceRoot":"","sources":["../../src/rules/no-explicit-any.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,gBAAgB,GAAG,eAAe,CAAC;;AAE7E,wBAsMG"}
+{"version":3,"file":"no-explicit-any.d.ts","sourceRoot":"","sources":["../../src/rules/no-explicit-any.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAClB,cAAc,GACd,oBAAoB,GACpB,gBAAgB,GAChB,eAAe,CAAC;;AAEpB,wBAuOG"}

package/dist/rules/no-explicit-any.js

@@ -14,6 +14,7 @@ exports.default = (0, util_1.createRule)({
         hasSuggestions: true,
         messages: {
             suggestNever: "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of.",
+            suggestPropertyKey: 'Use `PropertyKey` instead, this is more explicit than `keyof any`.',
             suggestUnknown: 'Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct.',
             unexpectedAny: 'Unexpected any. Specify a different type.',
         },
@@ -133,30 +134,57 @@ exports.default = (0, util_1.createRule)({
             return (isGreatGrandparentRestElement(node) ||
                 isGreatGreatGrandparentRestElement(node));
         }
+        /**
+         * Checks if the node is within a keyof any expression
+         * @param node the node to be validated.
+         * @returns true if the node is within a keyof any expression, false otherwise
+         * @private
+         */
+        function isNodeWithinKeyofAny(node) {
+            return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                node.parent.operator === 'keyof');
+        }
+        /**
+         * Creates a fixer that replaces a keyof any with PropertyKey
+         * @param node the node to be fixed.
+         * @returns a function that will fix the node.
+         * @private
+         */
+        function createPropertyKeyFixer(node) {
+            return (fixer) => {
+                return fixer.replaceText(node.parent, 'PropertyKey');
+            };
+        }
         return {
             TSAnyKeyword(node) {
+                const isKeyofAny = isNodeWithinKeyofAny(node);
                 if (ignoreRestArgs && isNodeDescendantOfRestElementInFunction(node)) {
                     return;
                 }
                 const fixOrSuggest = {
                     fix: null,
-                    suggest: [
-                        {
-                            messageId: 'suggestUnknown',
-                            fix(fixer) {
-                                return fixer.replaceText(node, 'unknown');
+                    suggest: isKeyofAny
+                        ? [
+                            {
+                                messageId: 'suggestPropertyKey',
+                                fix: createPropertyKeyFixer(node),
+                            },
+                        ]
+                        : [
+                            {
+                                messageId: 'suggestUnknown',
+                                fix: fixer => fixer.replaceText(node, 'unknown'),
                             },
-                        },
-                        {
-                            messageId: 'suggestNever',
-                            fix(fixer) {
-                                return fixer.replaceText(node, 'never');
+                            {
+                                messageId: 'suggestNever',
+                                fix: fixer => fixer.replaceText(node, 'never'),
                             },
-                        },
-                    ],
+                        ],
                 };
                 if (fixToUnknown) {
-                    fixOrSuggest.fix = (fixer) => fixer.replaceText(node, 'unknown');
+                    fixOrSuggest.fix = isKeyofAny
+                        ? createPropertyKeyFixer(node)
+                        : fixer => fixer.replaceText(node, 'unknown');
                 }
                 context.report({
                     node,

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

@@ -8,7 +8,7 @@ export type Options = [
         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 type MessageIds = 'missingAsync' | 'missingAsyncHybridReturn';
+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=promise-function-async.d.ts.map

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

@@ -1 +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"}
+{"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,GAAG,0BAA0B,CAAC;;AAErE,wBAyPG"}

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

@@ -47,6 +47,7 @@ exports.default = (0, util_1.createRule)({
         fixable: 'code',
         messages: {
             missingAsync: 'Functions that return promises must be async.',
+            missingAsyncHybridReturn: 'Functions that return promises must be async. Consider adding an explicit return type annotation if the function is intended to return a union of promise and non-promise types.',
         },
         schema: [
             {
@@ -133,10 +134,14 @@ exports.default = (0, util_1.createRule)({
             returnTypes.every(type => (0, util_1.containsAllTypesByName)(type, true, allAllowedPromiseNames, 
             // If no return type is explicitly set, we check if any parts of the return type match a Promise (instead of requiring all to match).
             node.returnType == null))) {
+                const isHybridReturnType = returnTypes.some(type => type.isUnion() &&
+                    !type.types.every(part => (0, util_1.containsAllTypesByName)(part, true, allAllowedPromiseNames)));
                 context.report({
                     loc: (0, util_1.getFunctionHeadLoc)(node, context.sourceCode),
                     node,
-                    messageId: 'missingAsync',
+                    messageId: isHybridReturnType
+                        ? 'missingAsyncHybridReturn'
+                        : 'missingAsync',
                     fix: fixer => {
                         if (node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
                             (node.parent.type === utils_1.AST_NODE_TYPES.Property &&

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.29.2-alpha.0",
+  "version": "8.29.2-alpha.10",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
     "!*.tsbuildinfo",
     "docs",
-    "eslint-recommended-raw.d.ts",
     "index.d.ts",
+    "raw-plugin.d.ts",
     "rules.d.ts",
     "package.json",
     "README.md",
@@ -24,9 +24,9 @@
       "types": "./rules.d.ts",
       "default": "./dist/rules/index.js"
     },
-    "./use-at-your-own-risk/eslint-recommended-raw": {
-      "types": "./eslint-recommended-raw.d.ts",
-      "default": "./dist/configs/eslint-recommended-raw.js"
+    "./use-at-your-own-risk/raw-plugin": {
+      "types": "./raw-plugin.d.ts",
+      "default": "./dist/raw-plugin.js"
     }
   },
   "engines": {
@@ -62,10 +62,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.29.2-alpha.0",
-    "@typescript-eslint/type-utils": "8.29.2-alpha.0",
-    "@typescript-eslint/utils": "8.29.2-alpha.0",
-    "@typescript-eslint/visitor-keys": "8.29.2-alpha.0",
+    "@typescript-eslint/scope-manager": "8.29.2-alpha.10",
+    "@typescript-eslint/type-utils": "8.29.2-alpha.10",
+    "@typescript-eslint/utils": "8.29.2-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.29.2-alpha.10",
     "graphemer": "^1.4.0",
     "ignore": "^5.3.1",
     "natural-compare": "^1.4.0",
@@ -76,8 +76,8 @@
     "@types/marked": "^5.0.2",
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.29.2-alpha.0",
-    "@typescript-eslint/rule-tester": "8.29.2-alpha.0",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.29.2-alpha.10",
+    "@typescript-eslint/rule-tester": "8.29.2-alpha.10",
     "ajv": "^6.12.6",
     "cross-env": "^7.0.3",
     "cross-fetch": "*",

package/raw-plugin.d.ts

@@ -0,0 +1,25 @@
+import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+
+import type plugin from './index';
+
+declare const cjsExport: {
+  flatConfigs: {
+    'flat/all': FlatConfig.ConfigArray;
+    'flat/base': FlatConfig.Config;
+    'flat/disable-type-checked': FlatConfig.Config;
+    'flat/eslint-recommended': FlatConfig.Config;
+    'flat/recommended': FlatConfig.ConfigArray;
+    'flat/recommended-type-checked': FlatConfig.ConfigArray;
+    'flat/recommended-type-checked-only': FlatConfig.ConfigArray;
+    'flat/strict': FlatConfig.ConfigArray;
+    'flat/strict-type-checked': FlatConfig.ConfigArray;
+    'flat/strict-type-checked-only': FlatConfig.ConfigArray;
+    'flat/stylistic': FlatConfig.ConfigArray;
+    'flat/stylistic-type-checked': FlatConfig.ConfigArray;
+    'flat/stylistic-type-checked-only': FlatConfig.ConfigArray;
+  };
+  parser: FlatConfig.Parser;
+  plugin: typeof plugin;
+};
+
+export = cjsExport;

package/dist/configs/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/configs/base.ts"],"names":[],"mappings":";;;;;;;AAEA,kBAIiC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../src/configs/disable-type-checked.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA8DiC"}

package/dist/configs/eslint-recommended.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eslint-recommended.d.ts","sourceRoot":"","sources":["../../src/configs/eslint-recommended.ts"],"names":[],"mappings":"AAAA;;;;GAIG;;;;;;;AAMH,kBAEiC"}

package/dist/configs/recommended-type-checked-only.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recommended-type-checked-only.d.ts","sourceRoot":"","sources":["../../src/configs/recommended-type-checked-only.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA+BiC"}

package/dist/configs/recommended-type-checked.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recommended-type-checked.d.ts","sourceRoot":"","sources":["../../src/configs/recommended-type-checked.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBAsDiC"}

package/dist/configs/recommended.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recommended.d.ts","sourceRoot":"","sources":["../../src/configs/recommended.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA2BiC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"strict-type-checked-only.d.ts","sourceRoot":"","sources":["../../src/configs/strict-type-checked-only.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBAqEiC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"strict-type-checked.d.ts","sourceRoot":"","sources":["../../src/configs/strict-type-checked.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBAwGiC"}

package/dist/configs/strict.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strict.d.ts","sourceRoot":"","sources":["../../src/configs/strict.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBAuCiC"}

package/dist/configs/stylistic-type-checked-only.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stylistic-type-checked-only.d.ts","sourceRoot":"","sources":["../../src/configs/stylistic-type-checked-only.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AASA,kBAaiC"}

package/dist/configs/stylistic-type-checked.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stylistic-type-checked.d.ts","sourceRoot":"","sources":["../../src/configs/stylistic-type-checked.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA2BiC"}

package/dist/configs/stylistic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stylistic.d.ts","sourceRoot":"","sources":["../../src/configs/stylistic.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AASA,kBAkBiC"}

package/eslint-recommended-raw.d.ts

@@ -1,5 +0,0 @@
-declare const config: (style: 'glob' | 'minimatch') => {
-  files: string[];
-  rules: Record<string, 'error' | 'off' | 'warn'>;
-};
-export = config;