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

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

@@ -5,7 +5,7 @@
  */
 declare const config: (style: "glob" | "minimatch") => {
     files: string[];
-    rules: Record<string, "off" | "warn" | "error">;
+    rules: Record<string, "error" | "off" | "warn">;
 };
 export = config;
 //# sourceMappingURL=eslint-recommended-raw.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"eslint-recommended-raw.d.ts","sourceRoot":"","sources":["../../src/configs/eslint-recommended-raw.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,QAAA,MAAM,MAAM,GACV,OAAO,MAAM,GAAG,WAAW,KAC1B;IACD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CAkChD,CAAC;AAEH,SAAS,MAAM,CAAC"}
+{"version":3,"file":"eslint-recommended-raw.d.ts","sourceRoot":"","sources":["../../src/configs/eslint-recommended-raw.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,QAAA,MAAM,MAAM,GACV,OAAO,MAAM,GAAG,WAAW,KAC1B;IACD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC,CAAC;CAkChD,CAAC;AAEH,SAAS,MAAM,CAAC"}

package/dist/configs/eslint-recommended-raw.js

@@ -1,7 +1,5 @@
 "use strict";
-// NOTE: this file is isolated to be shared across legacy and flat configs
-// it is exported via `./use-at-your-own-risk/eslint-recommended-raw`
-// and it has types manually defined in `./eslint-recommended-raw.d.ts`
+// NOTE: this file is isolated to be shared across legacy and flat configs.
 /**
  * This is a compatibility ruleset that:
  * - disables rules from eslint:recommended which are already handled by TypeScript.
@@ -24,8 +22,8 @@ const config = (style) => ({
         'no-func-assign': 'off', // ts(2630)
         'no-import-assign': 'off', // ts(2632) & ts(2540)
         // TODO - remove this once we no longer support ESLint v8
-        'no-new-symbol': 'off', // ts(7009)
         'no-new-native-nonconstructor': 'off', // ts(7009)
+        'no-new-symbol': 'off', // ts(7009)
         'no-obj-calls': 'off', // ts(2349)
         'no-redeclare': 'off', // ts(2451)
         'no-setter-return': 'off', // ts(2408)
@@ -34,10 +32,10 @@ const config = (style) => ({
         'no-unreachable': 'off', // ts(7027)
         'no-unsafe-negation': 'off', // ts(2365) & ts(2322) & ts(2358)
         'no-var': 'error', // ts transpiles let/const to var, so no need for vars any more
+        'no-with': 'off', // ts(1101) & ts(2410)
         'prefer-const': 'error', // ts provides better types with const
         'prefer-rest-params': 'error', // ts provides better types with rest args over arguments
         'prefer-spread': 'error', // ts transpiles spread to apply, so no need for manual apply
-        'no-with': 'off', // ts(1101) & ts(2410)
     },
 });
 module.exports = config;

package/dist/configs/{all.d.ts.map → eslintrc/all.d.ts.map}

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

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

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

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

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

package/dist/configs/{eslint-recommended.d.ts → eslintrc/eslint-recommended.d.ts}

@@ -6,7 +6,7 @@
 declare const _default: {
     overrides: {
         files: string[];
-        rules: Record<string, "off" | "warn" | "error">;
+        rules: Record<string, "error" | "off" | "warn">;
     }[];
 };
 export = _default;

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

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

package/dist/configs/{eslint-recommended.js → eslintrc/eslint-recommended.js}

@@ -7,7 +7,7 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-const eslint_recommended_raw_1 = __importDefault(require("./eslint-recommended-raw"));
+const eslint_recommended_raw_1 = __importDefault(require("../eslint-recommended-raw"));
 module.exports = {
     overrides: [(0, eslint_recommended_raw_1.default)('glob')],
 };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/configs/flat/all.d.ts

@@ -0,0 +1,8 @@
+import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+/**
+ * Enables each the rules provided as a part of typescript-eslint. Note that many rules are not applicable in all codebases, or are meant to be configured.
+ * @see {@link https://typescript-eslint.io/users/configs#all}
+ */
+declare const _default: (plugin: FlatConfig.Plugin, parser: FlatConfig.Parser) => FlatConfig.ConfigArray;
+export default _default;
+//# sourceMappingURL=all.d.ts.map

package/dist/configs/flat/all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/all.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAKrE;;;GAGG;yBAED,QAAQ,UAAU,CAAC,MAAM,EACzB,QAAQ,UAAU,CAAC,MAAM,KACxB,UAAU,CAAC,WAAW;AAHzB,wBAiKE"}

package/dist/configs/flat/all.js

@@ -0,0 +1,175 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// SEE https://typescript-eslint.io/users/configs
+//
+// For developers working in the typescript-eslint monorepo:
+// You can regenerate it using `yarn generate:configs`
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base"));
+const eslint_recommended_1 = __importDefault(require("./eslint-recommended"));
+/**
+ * Enables each the rules provided as a part of typescript-eslint. Note that many rules are not applicable in all codebases, or are meant to be configured.
+ * @see {@link https://typescript-eslint.io/users/configs#all}
+ */
+exports.default = (plugin, parser) => [
+    (0, base_1.default)(plugin, parser),
+    (0, eslint_recommended_1.default)(plugin, parser),
+    {
+        name: 'typescript-eslint/all',
+        rules: {
+            '@typescript-eslint/adjacent-overload-signatures': 'error',
+            '@typescript-eslint/array-type': 'error',
+            '@typescript-eslint/await-thenable': 'error',
+            '@typescript-eslint/ban-ts-comment': 'error',
+            '@typescript-eslint/ban-tslint-comment': 'error',
+            '@typescript-eslint/class-literal-property-style': 'error',
+            'class-methods-use-this': 'off',
+            '@typescript-eslint/class-methods-use-this': 'error',
+            '@typescript-eslint/consistent-generic-constructors': 'error',
+            '@typescript-eslint/consistent-indexed-object-style': 'error',
+            'consistent-return': 'off',
+            '@typescript-eslint/consistent-return': 'error',
+            '@typescript-eslint/consistent-type-assertions': 'error',
+            '@typescript-eslint/consistent-type-definitions': 'error',
+            '@typescript-eslint/consistent-type-exports': 'error',
+            '@typescript-eslint/consistent-type-imports': 'error',
+            'default-param-last': 'off',
+            '@typescript-eslint/default-param-last': 'error',
+            'dot-notation': 'off',
+            '@typescript-eslint/dot-notation': 'error',
+            '@typescript-eslint/explicit-function-return-type': 'error',
+            '@typescript-eslint/explicit-member-accessibility': 'error',
+            '@typescript-eslint/explicit-module-boundary-types': 'error',
+            'init-declarations': 'off',
+            '@typescript-eslint/init-declarations': 'error',
+            'max-params': 'off',
+            '@typescript-eslint/max-params': 'error',
+            '@typescript-eslint/member-ordering': 'error',
+            '@typescript-eslint/method-signature-style': 'error',
+            '@typescript-eslint/naming-convention': 'error',
+            'no-array-constructor': 'off',
+            '@typescript-eslint/no-array-constructor': 'error',
+            '@typescript-eslint/no-array-delete': 'error',
+            '@typescript-eslint/no-base-to-string': 'error',
+            '@typescript-eslint/no-confusing-non-null-assertion': 'error',
+            '@typescript-eslint/no-confusing-void-expression': 'error',
+            '@typescript-eslint/no-deprecated': 'error',
+            'no-dupe-class-members': 'off',
+            '@typescript-eslint/no-dupe-class-members': 'error',
+            '@typescript-eslint/no-duplicate-enum-values': 'error',
+            '@typescript-eslint/no-duplicate-type-constituents': 'error',
+            '@typescript-eslint/no-dynamic-delete': 'error',
+            'no-empty-function': 'off',
+            '@typescript-eslint/no-empty-function': 'error',
+            '@typescript-eslint/no-empty-object-type': 'error',
+            '@typescript-eslint/no-explicit-any': 'error',
+            '@typescript-eslint/no-extra-non-null-assertion': 'error',
+            '@typescript-eslint/no-extraneous-class': 'error',
+            '@typescript-eslint/no-floating-promises': 'error',
+            '@typescript-eslint/no-for-in-array': 'error',
+            'no-implied-eval': 'off',
+            '@typescript-eslint/no-implied-eval': 'error',
+            '@typescript-eslint/no-import-type-side-effects': 'error',
+            '@typescript-eslint/no-inferrable-types': 'error',
+            'no-invalid-this': 'off',
+            '@typescript-eslint/no-invalid-this': 'error',
+            '@typescript-eslint/no-invalid-void-type': 'error',
+            'no-loop-func': 'off',
+            '@typescript-eslint/no-loop-func': 'error',
+            'no-magic-numbers': 'off',
+            '@typescript-eslint/no-magic-numbers': 'error',
+            '@typescript-eslint/no-meaningless-void-operator': 'error',
+            '@typescript-eslint/no-misused-new': 'error',
+            '@typescript-eslint/no-misused-promises': 'error',
+            '@typescript-eslint/no-misused-spread': 'error',
+            '@typescript-eslint/no-mixed-enums': 'error',
+            '@typescript-eslint/no-namespace': 'error',
+            '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error',
+            '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
+            '@typescript-eslint/no-non-null-assertion': 'error',
+            'no-redeclare': 'off',
+            '@typescript-eslint/no-redeclare': 'error',
+            '@typescript-eslint/no-redundant-type-constituents': 'error',
+            '@typescript-eslint/no-require-imports': 'error',
+            'no-restricted-imports': 'off',
+            '@typescript-eslint/no-restricted-imports': 'error',
+            '@typescript-eslint/no-restricted-types': 'error',
+            'no-shadow': 'off',
+            '@typescript-eslint/no-shadow': 'error',
+            '@typescript-eslint/no-this-alias': 'error',
+            '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error',
+            '@typescript-eslint/no-unnecessary-condition': 'error',
+            '@typescript-eslint/no-unnecessary-parameter-property-assignment': 'error',
+            '@typescript-eslint/no-unnecessary-qualifier': 'error',
+            '@typescript-eslint/no-unnecessary-template-expression': 'error',
+            '@typescript-eslint/no-unnecessary-type-arguments': 'error',
+            '@typescript-eslint/no-unnecessary-type-assertion': 'error',
+            '@typescript-eslint/no-unnecessary-type-constraint': 'error',
+            '@typescript-eslint/no-unnecessary-type-parameters': 'error',
+            '@typescript-eslint/no-unsafe-argument': 'error',
+            '@typescript-eslint/no-unsafe-assignment': 'error',
+            '@typescript-eslint/no-unsafe-call': 'error',
+            '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+            '@typescript-eslint/no-unsafe-enum-comparison': 'error',
+            '@typescript-eslint/no-unsafe-function-type': 'error',
+            '@typescript-eslint/no-unsafe-member-access': 'error',
+            '@typescript-eslint/no-unsafe-return': 'error',
+            '@typescript-eslint/no-unsafe-type-assertion': 'error',
+            '@typescript-eslint/no-unsafe-unary-minus': 'error',
+            'no-unused-expressions': 'off',
+            '@typescript-eslint/no-unused-expressions': 'error',
+            'no-unused-vars': 'off',
+            '@typescript-eslint/no-unused-vars': 'error',
+            'no-use-before-define': 'off',
+            '@typescript-eslint/no-use-before-define': 'error',
+            'no-useless-constructor': 'off',
+            '@typescript-eslint/no-useless-constructor': 'error',
+            '@typescript-eslint/no-useless-empty-export': 'error',
+            '@typescript-eslint/no-wrapper-object-types': 'error',
+            '@typescript-eslint/non-nullable-type-assertion-style': 'error',
+            'no-throw-literal': 'off',
+            '@typescript-eslint/only-throw-error': 'error',
+            '@typescript-eslint/parameter-properties': 'error',
+            '@typescript-eslint/prefer-as-const': 'error',
+            'prefer-destructuring': 'off',
+            '@typescript-eslint/prefer-destructuring': 'error',
+            '@typescript-eslint/prefer-enum-initializers': 'error',
+            '@typescript-eslint/prefer-find': 'error',
+            '@typescript-eslint/prefer-for-of': 'error',
+            '@typescript-eslint/prefer-function-type': 'error',
+            '@typescript-eslint/prefer-includes': 'error',
+            '@typescript-eslint/prefer-literal-enum-member': 'error',
+            '@typescript-eslint/prefer-namespace-keyword': 'error',
+            '@typescript-eslint/prefer-nullish-coalescing': 'error',
+            '@typescript-eslint/prefer-optional-chain': 'error',
+            'prefer-promise-reject-errors': 'off',
+            '@typescript-eslint/prefer-promise-reject-errors': 'error',
+            '@typescript-eslint/prefer-readonly': 'error',
+            '@typescript-eslint/prefer-readonly-parameter-types': 'error',
+            '@typescript-eslint/prefer-reduce-type-parameter': 'error',
+            '@typescript-eslint/prefer-regexp-exec': 'error',
+            '@typescript-eslint/prefer-return-this-type': 'error',
+            '@typescript-eslint/prefer-string-starts-ends-with': 'error',
+            '@typescript-eslint/promise-function-async': 'error',
+            '@typescript-eslint/related-getter-setter-pairs': 'error',
+            '@typescript-eslint/require-array-sort-compare': 'error',
+            'require-await': 'off',
+            '@typescript-eslint/require-await': 'error',
+            '@typescript-eslint/restrict-plus-operands': 'error',
+            '@typescript-eslint/restrict-template-expressions': 'error',
+            'no-return-await': 'off',
+            '@typescript-eslint/return-await': 'error',
+            '@typescript-eslint/strict-boolean-expressions': 'error',
+            '@typescript-eslint/switch-exhaustiveness-check': 'error',
+            '@typescript-eslint/triple-slash-reference': 'error',
+            '@typescript-eslint/typedef': 'error',
+            '@typescript-eslint/unbound-method': 'error',
+            '@typescript-eslint/unified-signatures': 'error',
+            '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error',
+        },
+    },
+];

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

@@ -0,0 +1,9 @@
+import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+/**
+ * A minimal ruleset that sets only the required parser and plugin options needed to run typescript-eslint.
+ * We don't recommend using this directly; instead, extend from an earlier recommended rule.
+ * @see {@link https://typescript-eslint.io/users/configs#base}
+ */
+declare const _default: (plugin: FlatConfig.Plugin, parser: FlatConfig.Parser) => FlatConfig.Config;
+export default _default;
+//# sourceMappingURL=base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAErE;;;;GAIG;yBAED,QAAQ,UAAU,CAAC,MAAM,EACzB,QAAQ,UAAU,CAAC,MAAM,KACxB,UAAU,CAAC,MAAM;AAHpB,wBAYG"}

package/dist/configs/flat/base.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A minimal ruleset that sets only the required parser and plugin options needed to run typescript-eslint.
+ * We don't recommend using this directly; instead, extend from an earlier recommended rule.
+ * @see {@link https://typescript-eslint.io/users/configs#base}
+ */
+exports.default = (plugin, parser) => ({
+    name: 'typescript-eslint/base',
+    languageOptions: {
+        parser,
+        sourceType: 'module',
+    },
+    plugins: {
+        '@typescript-eslint': plugin,
+    },
+});

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

@@ -0,0 +1,8 @@
+import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+/**
+ * A utility ruleset that will disable type-aware linting and all type-aware rules available in our project.
+ * @see {@link https://typescript-eslint.io/users/configs#disable-type-checked}
+ */
+declare const _default: (_plugin: FlatConfig.Plugin, _parser: FlatConfig.Parser) => FlatConfig.Config;
+export default _default;
+//# sourceMappingURL=disable-type-checked.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/disable-type-checked.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAErE;;;GAGG;yBAED,SAAS,UAAU,CAAC,MAAM,EAC1B,SAAS,UAAU,CAAC,MAAM,KACzB,UAAU,CAAC,MAAM;AAHpB,wBAoEG"}

package/dist/configs/flat/disable-type-checked.js

@@ -0,0 +1,78 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// SEE https://typescript-eslint.io/users/configs
+//
+// For developers working in the typescript-eslint monorepo:
+// You can regenerate it using `yarn generate:configs`
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A utility ruleset that will disable type-aware linting and all type-aware rules available in our project.
+ * @see {@link https://typescript-eslint.io/users/configs#disable-type-checked}
+ */
+exports.default = (_plugin, _parser) => ({
+    name: 'typescript-eslint/disable-type-checked',
+    rules: {
+        '@typescript-eslint/await-thenable': 'off',
+        '@typescript-eslint/consistent-return': 'off',
+        '@typescript-eslint/consistent-type-exports': 'off',
+        '@typescript-eslint/dot-notation': 'off',
+        '@typescript-eslint/naming-convention': 'off',
+        '@typescript-eslint/no-array-delete': 'off',
+        '@typescript-eslint/no-base-to-string': 'off',
+        '@typescript-eslint/no-confusing-void-expression': 'off',
+        '@typescript-eslint/no-deprecated': 'off',
+        '@typescript-eslint/no-duplicate-type-constituents': 'off',
+        '@typescript-eslint/no-floating-promises': 'off',
+        '@typescript-eslint/no-for-in-array': 'off',
+        '@typescript-eslint/no-implied-eval': 'off',
+        '@typescript-eslint/no-meaningless-void-operator': 'off',
+        '@typescript-eslint/no-misused-promises': 'off',
+        '@typescript-eslint/no-misused-spread': 'off',
+        '@typescript-eslint/no-mixed-enums': 'off',
+        '@typescript-eslint/no-redundant-type-constituents': 'off',
+        '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'off',
+        '@typescript-eslint/no-unnecessary-condition': 'off',
+        '@typescript-eslint/no-unnecessary-qualifier': 'off',
+        '@typescript-eslint/no-unnecessary-template-expression': 'off',
+        '@typescript-eslint/no-unnecessary-type-arguments': 'off',
+        '@typescript-eslint/no-unnecessary-type-assertion': 'off',
+        '@typescript-eslint/no-unnecessary-type-parameters': 'off',
+        '@typescript-eslint/no-unsafe-argument': 'off',
+        '@typescript-eslint/no-unsafe-assignment': 'off',
+        '@typescript-eslint/no-unsafe-call': 'off',
+        '@typescript-eslint/no-unsafe-enum-comparison': 'off',
+        '@typescript-eslint/no-unsafe-member-access': 'off',
+        '@typescript-eslint/no-unsafe-return': 'off',
+        '@typescript-eslint/no-unsafe-type-assertion': 'off',
+        '@typescript-eslint/no-unsafe-unary-minus': 'off',
+        '@typescript-eslint/non-nullable-type-assertion-style': 'off',
+        '@typescript-eslint/only-throw-error': 'off',
+        '@typescript-eslint/prefer-destructuring': 'off',
+        '@typescript-eslint/prefer-find': 'off',
+        '@typescript-eslint/prefer-includes': 'off',
+        '@typescript-eslint/prefer-nullish-coalescing': 'off',
+        '@typescript-eslint/prefer-optional-chain': 'off',
+        '@typescript-eslint/prefer-promise-reject-errors': 'off',
+        '@typescript-eslint/prefer-readonly': 'off',
+        '@typescript-eslint/prefer-readonly-parameter-types': 'off',
+        '@typescript-eslint/prefer-reduce-type-parameter': 'off',
+        '@typescript-eslint/prefer-regexp-exec': 'off',
+        '@typescript-eslint/prefer-return-this-type': 'off',
+        '@typescript-eslint/prefer-string-starts-ends-with': 'off',
+        '@typescript-eslint/promise-function-async': 'off',
+        '@typescript-eslint/related-getter-setter-pairs': 'off',
+        '@typescript-eslint/require-array-sort-compare': 'off',
+        '@typescript-eslint/require-await': 'off',
+        '@typescript-eslint/restrict-plus-operands': 'off',
+        '@typescript-eslint/restrict-template-expressions': 'off',
+        '@typescript-eslint/return-await': 'off',
+        '@typescript-eslint/strict-boolean-expressions': 'off',
+        '@typescript-eslint/switch-exhaustiveness-check': 'off',
+        '@typescript-eslint/unbound-method': 'off',
+        '@typescript-eslint/use-unknown-in-catch-callback-variable': 'off',
+    },
+    languageOptions: {
+        parserOptions: { program: null, project: false, projectService: false },
+    },
+});

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

@@ -0,0 +1,10 @@
+import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+/**
+ * This is a compatibility ruleset that:
+ * - disables rules from eslint:recommended which are already handled by TypeScript.
+ * - enables rules that make sense due to TS's typechecking / transpilation.
+ * @see {@link https://typescript-eslint.io/users/configs/#eslint-recommended}
+ */
+declare const _default: (_plugin: FlatConfig.Plugin, _parser: FlatConfig.Parser) => FlatConfig.Config;
+export default _default;
+//# sourceMappingURL=eslint-recommended.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eslint-recommended.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/eslint-recommended.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAIrE;;;;;GAKG;yBAED,SAAS,UAAU,CAAC,MAAM,EAC1B,SAAS,UAAU,CAAC,MAAM,KACzB,UAAU,CAAC,MAAM;AAHpB,wBAMG"}

package/dist/configs/flat/eslint-recommended.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const eslint_recommended_raw_1 = __importDefault(require("../eslint-recommended-raw"));
+/**
+ * This is a compatibility ruleset that:
+ * - disables rules from eslint:recommended which are already handled by TypeScript.
+ * - enables rules that make sense due to TS's typechecking / transpilation.
+ * @see {@link https://typescript-eslint.io/users/configs/#eslint-recommended}
+ */
+exports.default = (_plugin, _parser) => ({
+    ...(0, eslint_recommended_raw_1.default)('minimatch'),
+    name: 'typescript-eslint/eslint-recommended',
+});

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

@@ -0,0 +1,8 @@
+import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+/**
+ * A version of `recommended` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+ * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked-only}
+ */
+declare const _default: (plugin: FlatConfig.Plugin, parser: FlatConfig.Parser) => FlatConfig.ConfigArray;
+export default _default;
+//# sourceMappingURL=recommended-type-checked-only.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recommended-type-checked-only.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/recommended-type-checked-only.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAKrE;;;GAGG;yBAED,QAAQ,UAAU,CAAC,MAAM,EACzB,QAAQ,UAAU,CAAC,MAAM,KACxB,UAAU,CAAC,WAAW;AAHzB,wBAsCE"}

package/dist/configs/flat/recommended-type-checked-only.js

@@ -0,0 +1,53 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// SEE https://typescript-eslint.io/users/configs
+//
+// For developers working in the typescript-eslint monorepo:
+// You can regenerate it using `yarn generate:configs`
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base"));
+const eslint_recommended_1 = __importDefault(require("./eslint-recommended"));
+/**
+ * A version of `recommended` that only contains type-checked rules and disables of any corresponding core ESLint rules.
+ * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked-only}
+ */
+exports.default = (plugin, parser) => [
+    (0, base_1.default)(plugin, parser),
+    (0, eslint_recommended_1.default)(plugin, parser),
+    {
+        name: 'typescript-eslint/recommended-type-checked-only',
+        rules: {
+            '@typescript-eslint/await-thenable': 'error',
+            '@typescript-eslint/no-array-delete': 'error',
+            '@typescript-eslint/no-base-to-string': 'error',
+            '@typescript-eslint/no-duplicate-type-constituents': 'error',
+            '@typescript-eslint/no-floating-promises': 'error',
+            '@typescript-eslint/no-for-in-array': 'error',
+            'no-implied-eval': 'off',
+            '@typescript-eslint/no-implied-eval': 'error',
+            '@typescript-eslint/no-misused-promises': 'error',
+            '@typescript-eslint/no-redundant-type-constituents': 'error',
+            '@typescript-eslint/no-unnecessary-type-assertion': 'error',
+            '@typescript-eslint/no-unsafe-argument': 'error',
+            '@typescript-eslint/no-unsafe-assignment': 'error',
+            '@typescript-eslint/no-unsafe-call': 'error',
+            '@typescript-eslint/no-unsafe-enum-comparison': 'error',
+            '@typescript-eslint/no-unsafe-member-access': 'error',
+            '@typescript-eslint/no-unsafe-return': 'error',
+            '@typescript-eslint/no-unsafe-unary-minus': 'error',
+            'no-throw-literal': 'off',
+            '@typescript-eslint/only-throw-error': 'error',
+            'prefer-promise-reject-errors': 'off',
+            '@typescript-eslint/prefer-promise-reject-errors': 'error',
+            'require-await': 'off',
+            '@typescript-eslint/require-await': 'error',
+            '@typescript-eslint/restrict-plus-operands': 'error',
+            '@typescript-eslint/restrict-template-expressions': 'error',
+            '@typescript-eslint/unbound-method': 'error',
+        },
+    },
+];

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

@@ -0,0 +1,8 @@
+import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+/**
+ * Contains all of `recommended` along with additional recommended rules that require type information.
+ * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked}
+ */
+declare const _default: (plugin: FlatConfig.Plugin, parser: FlatConfig.Parser) => FlatConfig.ConfigArray;
+export default _default;
+//# sourceMappingURL=recommended-type-checked.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recommended-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/recommended-type-checked.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAKrE;;;GAGG;yBAED,QAAQ,UAAU,CAAC,MAAM,EACzB,QAAQ,UAAU,CAAC,MAAM,KACxB,UAAU,CAAC,WAAW;AAHzB,wBA6DE"}